Spring är ett Java-ramverk som använder en behållare för att skapa och hantera de olika komponenterna i en applikation. Behållaren (ofta kallad Spring application context) kopplar samman de olika komponenterna i en applikation med hjälp av dependency injection (DI) designmönster. DI låter dig använda ett objekt i en beroende klass, utan att skapa en ny instans av det inom den beroende klassen.
Så istället för att tillåta varje komponent att skapa nya instanser av de de litar på, skapar och underhåller Springs behållare en instans av var och en av komponenterna som den är värd för. Denna behållare injicerar sedan en instans av en komponent i alla andra komponenter som behöver den.
Utforska vårens kärnfunktioner
Spring-ramverket har ett 20-tal välorganiserade moduler som spelar en integrerad roll i dess förmåga att skapa och hantera applikationer. Baserat på de primära funktionerna i dessa moduler kan du gruppera dem i fem kategorier:
- Kärnbehållare
- Dataåtkomst/Integration
- webb
- Aspektorienterad programmering och instrumentering
- Testa
Vårbehållare
Spring använder en behållare för att skapa och hantera olika komponenter (som den kallar bönor) i en applikation. Behållaren är tillgänglig via Springs ApplicationContext-gränssnitt, som låter dig instansiera, konfigurera och sätta ihop objekt (eller bönor). Springs behållare kan utföra sin funktion med hjälp av konfigurationsmetadata.
Denna konfigurationsmetadata kan ha flera olika former, men dess typiska form är XML. Förutom bönor består Springs behållare även av en kärna, ett sammanhang och en uttrycksmodul.
Spring Data Access/Integration
Dataaccess/integrationsaspekten av fjäderramverket består av flera undermoduler: JDBC, ORM, OXM, JMS och transaktion. Dessa moduler arbetar tillsammans för att hantera all data som din applikation använder.
Vårwebben
Webbfunktionen i Spring-applikationen ger webborienterad integration för din applikation. Förutom webborienterad integration tillhandahåller Spring en webbservletmodul. Webservletmodulen ansvarar för Spring's implementering av model-view-controller (MVC)..
Spring Aspect-Oriented Programmering (AOP)
Springs AOP-ramverk är en annan av dess nyckelkomponenter. Även om AOP-ramverket inte är avgörande för Springs containerfunktion, kompletterar det containern genom att vara en kapabel mellanprogramlösning. En av AOP-ramverkets nyckelfunktioner är att den tillhandahåller deklarativa företagstjänster för din applikation, nämligen hantering av deklarationstransaktioner.
Deklarativ transaktionshantering är ett önskvärt tillvägagångssätt för mjukvaruutveckling eftersom det har minimal inverkan på applikationskoden.
Vårtest
Våren lägger stor vikt vid applikationstestning. Dess testmodul stöder integrationstestning och enhetstestning med JUnit eller TestNG.
Skapa en vårapplikation
Det finns flera sätt att skapa pannplattan för en ny fjäderapplikation. De olika tillvägagångssätten inkluderar:
- Från webbapplikationen (eller Spring Initializr) på Springs officiella webbplats.
- Skapa en projektkatalogstruktur manuellt och bygga specifikationer.
- Med Spring Tool Suite.
- Från kommandoraden med Spring Boots kommandoradsgränssnitt.
- Med Eclipse IDE.
- Med IntelliJ IDEA IDE.
Den mest populära metoden är Spring Initializr:
Som du kan se från bilden ovan har du flera beslut att fatta. Den första är den typ av projekt du vill initiera. Spring erbjuder tre alternativ: Gradle för Groovy, Gradle för Kotlin eller Maven. Denna exempelapplikation kommer att använda ett Maven-projekt.
De andra alternativen du måste välja är språket (Java), den version av Spring Boot du vill använda och projektets metadata. Spring har redan en del dummydata i sina fem fält som hjälper dig att skapa en exempelapplikation. Du måste dock uppdatera dessa fält med projektspecifik data, eftersom denna metadata kommer att beskriva din Spring-applikation inklusive Springbönor och deras metoder.
Därefter måste du välja den förpackning du vill ha dina filer i (burk eller krig). Sedan kan du välja vilken version av Java du har på din enhet. Det slutliga beslutet du måste göra är vilken typ av beroenden du vill ha för din applikation.
Spring tillhandahåller flera beroenden som du kan använda för att lägga till egenskaper i din applikation. För att lägga till ett nytt beroende till din applikation, klicka helt enkelt på knappen Lägg till beroenden till höger om Spring Initializr. Den här åtgärden genererar följande överlagring på din skärm:
För denna exempelapplikation är det enda beroende du behöver vara Spring Web. Detta beroende gör att du kan bygga webbapplikationer med MVC-arkitekturen. När du har valt alla beroenden du vill använda i din applikation, fortsätt och generera ett klick. Detta kommer att ladda ner projektets planlösning åt dig.
Nu har du ett Spring Boot-projekt (som är ett av Springs bibliotek). Det sista steget är att importera projektet till din föredragna IDE. Ditt vårprojekt kommer att ha följande projektstruktur:
Detta är en normal Maven-projektstruktur, och det finns flera viktiga filer som du behöver bekanta dig med.
- Pom.xml: Detta innehåller Spring-applikationens konfigurationsdata.
- OnlineShopaholicsApplication.java: Detta är Spring Boot-huvudklassen, som kör applikationen.
- OnlineShopaholicsApplicationTest.java: Detta är en JUnit test klass som säkerställer att Spring-applikationskontexten (eller behållaren) läses in korrekt.
Köra en vårapplikation
Springs bootstrap-klass, som i det här fallet är OnlineShopaholicsApplication-klassen, har följande initiala kod:
paket com.onlineshopaholics;importeraorg.springframework.känga.SpringApplication;
importeraorg.springframework.känga.autoconfigure.SpringBootApplication;
@SpringBootApplication
offentligklassOnlineShopaholics-applikation{
offentligstatisktomhethuvud(String[] args){
SpringApplication.run (OnlineShopaholicsApplication.klass, args);
}
}
En av de viktigaste aspekterna av koden ovan är @SpringBootApplication annotation, som är en sammansatt kommentar som gör att din applikation får tillgång till funktionerna i tre andra kommentarer:
- @EnableAutoconfiguration: Den här anteckningen möjliggör automatisk konfiguration av Spring Boot. Det betyder att den säger åt Spring boot att konfigurera alla komponenter som den tror att din applikation kommer att behöva fungera.
- @ComponentScan: Denna anteckning låter dig aktivera komponentskanning. Den här funktionen är viktig, den tillåter Spring att automatiskt upptäcka och registrera andra kommenterade komponenter för användning av Spring-applikationskontexten (eller behållaren).
- @SpringBootConfiguration: Detta är en specialiserad form av @Configureation-kommentaren, som låter dig registrera bönor (eller objekt) i Spring-applikationssammanhang.
Den andra viktiga aspekten av koden ovan är main() metod kör den din applikation. När applikationen körs nu startar den helt enkelt servern. Så om du vill lägga till mer funktionalitet till applikationen måste du uppdatera koden:
paket com.onlineshopaholics;importeraorg.springframework.känga.SpringApplication;
importeraorg.springframework.känga.autoconfigure.SpringBootApplication;
importeraorg.springframework.webb.binda.anteckning.GetMapping;
importeraorg.springframework.webb.binda.anteckning.RequestParam;
importeraorg.springframework.webb.binda.anteckning.RestController;@SpringBootApplication
@RestController
offentligklassOnlineShopaholics-applikation{
offentligstatisktomhethuvud(String[] args){
SpringApplication.run (OnlineShopaholicsApplication.klass, args);
}
@GetMapping("/kund")
offentlig Sträng Welcome(@RequestParam (värde = "namn", defaultValue = "Kund") Sträng namn) {
lämna tillbakaSträng.formatera("Välkommen %s!", namn);
}
}
Spring Boot-applikationen har nu tre nya kommentarer:
- @RestController: Denna anteckning markerar klassen som en kontroller, så varje metod i klassen ovan (förutom main()) kommer att returnera ett domänobjekt istället för en vy.
- @GetMapping: Den här anteckningen mappar HTTP GET-förfrågningar till specifika rubrikmetoder. Så varje gång du skapar en begäran om "/customer" i webbläsaren, kommer metoden Welcome() att hantera begäran genom att returnera ett strängvärde.
- @RequestParam: Denna annotering indikerar att en metodparameter ska vara bunden till en webbbegäranparameter.
Med den uppdaterade koden din Spring OnlineShopaholics-applikation har nu en kundsida som du kan se i din webbläsare. Om du kör programmet startar servern och producerar utdata i konsolen.
Det finns mycket viktig information i produktionen. Den talar om för dig att servern körs, den talar om för dig hur lång tid initieringsprocessen tog och den talar om vilken port programmet körs på (8080, som standard). Därför, om du navigerar till http://localhost: 8080/kund du kommer att se följande utdata i din webbläsare:
Nu kan du designa din applikationsvy
En annan viktig fil i projektstrukturen som du kanske märker är mallar mapp. Helst OnlineShopaholics-applikation klass ska fungera som en kontrollant, som hanterar förfrågningar om olika vyer. Därför, i en komplett applikation, bör kontrollerklassen inte innehålla texten som kommer att visas i vyn av dess begäran.
Istället måste du skapa mallfiler med HTML och placera dem i mallmappen i din Spring-applikation.
