Lezers zoals jij steunen MUO. Wanneer u een aankoop doet via links op onze site, kunnen we een aangesloten commissie verdienen. Lees verder.

Spring is een Java-framework dat een container gebruikt om de verschillende componenten van een applicatie te maken en te beheren. De container (vaak de Spring-toepassingscontext genoemd) verbindt de verschillende componenten in een toepassing met behulp van het ontwerppatroon voor afhankelijkheidsinjectie (DI). Met DI kunt u een object in een afhankelijke klasse gebruiken, zonder er een nieuwe instantie van te maken binnen de afhankelijke klasse.

Dus in plaats van elke component nieuwe instanties te laten maken van degene waarop ze vertrouwen, maakt en onderhoudt de container van Spring een instantie van elk van de componenten die het host. Deze container injecteert vervolgens een exemplaar van een component in alle andere componenten die het nodig hebben.

De kernfuncties van Spring verkennen

Het Spring-framework heeft ongeveer 20 goed georganiseerde modules die een integrale rol spelen bij het maken en beheren van applicaties. Op basis van de primaire kenmerken van deze modules kunt u ze groeperen in vijf categorieën:

instagram viewer

  • Kerncontainer
  • Gegevenstoegang/integratie
  • Web
  • Aspectgeoriënteerd programmeren en instrumenteren
  • Test

Lente container

Spring gebruikt een container om verschillende componenten (die het bonen noemt) van een applicatie te maken en te beheren. De container is toegankelijk via de ApplicationContext-interface van Spring, waarmee u objecten (of bonen) kunt instantiëren, configureren en samenstellen. De container van Spring kan zijn functie vervullen met behulp van configuratiemetadata.

Deze configuratiemetadata kunnen verschillende vormen hebben, maar de typische vorm is XML. Naast bonen bestaat de container van Spring ook uit een kern-, context- en een uitdrukkingsmodule.

Spring Data Access/Integratie

Het aspect gegevenstoegang/integratie van het springframework bestaat uit verschillende submodules: JDBC, ORM, OXM, JMS en transactie. Deze modules werken samen om alle gegevens te beheren die uw toepassing gebruikt.

lente web

De webfunctie van de Spring-applicatie biedt webgeoriënteerde integratie voor uw applicatie. Naast webgeoriënteerde integratie biedt Spring een webservletmodule. De webservletmodule is verantwoordelijk voor Spring's implementatie van model-view-controller (MVC)..

Spring Aspect-Oriented Programming (AOP)

Het AOP-framework van Spring is een ander belangrijk onderdeel. Hoewel het AOP-framework niet cruciaal is voor de containerfunctie van Spring, vult het de container wel aan door een capabele middleware-oplossing te zijn. Een van de belangrijkste kenmerken van het AOP-framework is dat het declaratieve bedrijfsservices voor uw toepassing biedt, namelijk het beheer van aangiftetransacties.

Declaratief transactiebeheer is een wenselijke benadering van softwareontwikkeling omdat het een minimale impact heeft op de applicatiecode.

Lente proef

Spring hecht veel belang aan het testen van applicaties. De testmodule ondersteunt integratietesten en unittesten met behulp van JUnit of TestNG.

Een lente-applicatie maken

Er zijn verschillende manieren om de boilerplate voor een nieuwe Spring-toepassing te maken. De verschillende benaderingen omvatten:

  • Van de webapplicatie (of Spring Initializr) op de officiële website van Spring.
  • Handmatig een projectdirectorystructuur maken en specificaties opstellen.
  • Met de Spring Tool Suite.
  • Vanaf de opdrachtregel met de opdrachtregelinterface van Spring Boot.
  • Met de Eclipse-IDE.
  • Met de IntelliJ IDEA IDE.

De meest populaire benadering is de Spring Initializr:

Zoals je kunt zien op de afbeelding hierboven, moet je verschillende beslissingen nemen. De eerste is het type project dat u wilt initialiseren. Spring biedt drie opties: Gradle voor Groovy, Gradle voor Kotlin of Maven. Deze voorbeeldtoepassing gebruikt een Maven-project.

De andere opties die u moet selecteren, zijn de taal (Java), de versie van Spring Boot die u wilt gebruiken en de metadata van het project. Spring heeft al enkele dummy-gegevens in zijn vijf velden die u zullen helpen bij het maken van een voorbeeldtoepassing. U moet deze velden echter bijwerken met projectspecifieke gegevens, aangezien deze metadata uw Spring-toepassing beschrijven, inclusief Spring Beans en hun methoden.

Vervolgens moet je de verpakking selecteren waarin je je bestanden wilt hebben (jar of war). Vervolgens kunt u de versie van Java selecteren die op uw apparaat staat. De uiteindelijke beslissing die u moet nemen, is het type afhankelijkheden dat u voor uw toepassing wilt.

Spring biedt verschillende afhankelijkheden die u kunt gebruiken om eigenschappen aan uw toepassing toe te voegen. Om een ​​nieuwe afhankelijkheid aan uw toepassing toe te voegen, klikt u eenvoudig op de knop Afhankelijkheden toevoegen rechts van Spring Initializr. Deze actie genereert de volgende overlay op uw scherm:

Voor deze voorbeeldtoepassing is Spring Web de enige afhankelijkheid die u nodig hebt. Met deze afhankelijkheid kunt u webapplicaties bouwen met behulp van de MVC-architectuur. Nadat u alle afhankelijkheden heeft geselecteerd die u in uw applicatie wilt gebruiken, kunt u een klik genereren. Hiermee wordt de projectstandaard voor u gedownload.

Nu heb je een Spring Boot-project (een van de bibliotheken van Spring). De laatste stap is het importeren van het project in de IDE van uw voorkeur. Uw Spring-project heeft de volgende projectstructuur:

Dit is een normale Maven-projectstructuur en er zijn verschillende belangrijke bestanden waarmee u vertrouwd moet raken.

  • Pom.xml: dit bevat de configuratiegegevens van de Spring-toepassing.
  • OnlineShopaholicsApplication.java: Dit is de hoofdklasse van Spring Boot, die de toepassing uitvoert.
  • OnlineShopaholicsApplicationTest.java: Dit is een JUnit-test klasse die ervoor zorgt dat de Spring-toepassingscontext (of container) correct wordt geladen.

Een Spring-toepassing uitvoeren

De bootstrap-klasse van Spring, in dit geval de klasse OnlineShopaholicsApplication, heeft de volgende initiële code:

pakket com.onlineshopaholics;
importerenorg.springkader.laars.SpringApplicatie;
importerenorg.springkader.laars.autoconfiguratie.SpringBoot-toepassing;
@SpringBootApplicatie
openbaarklasOnlineShopaholics-applicatie{
openbaarstatischleegtevoornaamst(String[] argumenten){
 SpringApplication.run (OnlineShopaholicsApplication.klas, argumenten);
 }
}

Een van de belangrijkste aspecten van de bovenstaande code is de @SpringBootApplicatie annotatie, een samengestelde annotatie waarmee uw toepassing toegang heeft tot de functies van drie andere annotaties:

  • @EnableAutoconfiguration: Deze annotatie maakt automatische configuratie van Spring Boot mogelijk. Dit betekent dat het Spring boot vertelt om elk onderdeel te configureren waarvan het denkt dat uw toepassing nodig heeft om te functioneren.
  • @ComponentScan: Met deze annotatie kunt u het scannen van componenten inschakelen. Deze functie is belangrijk, het stelt Spring in staat om automatisch andere geannoteerde componenten te ontdekken en te registreren voor gebruik door de Spring-toepassingscontext (of container).
  • @SpringBootConfiguration: Dit is een gespecialiseerde vorm van de @Configuration-annotatie, waarmee u bonen (of objecten) kunt registreren in de context van de Spring-toepassing.

Het andere belangrijke aspect van de bovenstaande code is de voornaamst() methode, voert het uw toepassing uit. Wanneer de toepassing nu wordt uitgevoerd, start deze gewoon de server. Dus als u meer functionaliteit aan de applicatie wilt toevoegen, moet u de code bijwerken:

pakket com.onlineshopaholics;
importerenorg.springkader.laars.SpringApplicatie;
importerenorg.springkader.laars.autoconfiguratie.SpringBoot-toepassing;
importerenorg.springkader.web.binden.annotatie.GetMapping;
importerenorg.springkader.web.binden.annotatie.RequestParam;
importerenorg.springkader.web.binden.annotatie.RestController;


@SpringBootApplicatie
@RestController
openbaarklasOnlineShopaholics-applicatie{
openbaarstatischleegtevoornaamst(String[] argumenten){
 SpringApplication.run (OnlineShopaholicsApplication.klas, argumenten);
 }
@GetMapping("/klant")
 openbaar Snaar Welkom(@RequestParam (waarde = "naam", standaardwaarde = "Klant") Snaar naam) {
opbrengstSnaar.formaat("Welkom %s!", naam);
 }
}

De Spring Boot-applicatie heeft nu drie nieuwe annotaties:

  • @RestController: Deze annotatie markeert de klasse als een controller, dus elke methode in de bovenstaande klasse (behalve main()) retourneert een domeinobject in plaats van een weergave.
  • @GetMapping: deze annotatie wijst HTTP GET-verzoeken toe aan specifieke headermethoden. Dus elke keer dat u een verzoek voor "/customer" in de browser maakt, zal de methode Welcome() het verzoek afhandelen door een tekenreekswaarde terug te sturen.
  • @RequestParam: Deze annotatie geeft aan dat een methodeparameter gebonden moet zijn aan een webverzoekparameter.

Met de bijgewerkte code wordt uw Spring OnlineShopaholics-applicatie heeft nu een klantenpagina die u in uw browser kunt bekijken. Door de toepassing uit te voeren, wordt de server gestart en wordt uitvoer in de console geproduceerd.

Er staat veel belangrijke informatie in de uitvoer. Het vertelt je dat de server actief is, het vertelt je hoe lang het initialisatieproces duurde en het vertelt je op welke poort de applicatie draait (standaard 8080). Daarom, als u navigeert naar http://localhost: 8080/klant u ziet de volgende uitvoer in uw browser:

Nu kunt u uw toepassingsweergave ontwerpen

Een ander belangrijk bestand in de projectstructuur dat u misschien opmerkt, is het Sjablonen map. Idealiter is de OnlineShopaholics-applicatie class zou moeten dienen als een controller, die verzoeken om verschillende weergaven afhandelt. Daarom zou de controller-klasse in een volledige toepassing niet de tekst moeten bevatten die wordt weergegeven in de weergave van het verzoek.

In plaats daarvan moet u sjabloonbestanden maken met HTML en deze in de sjabloonmap van uw Spring-toepassing plaatsen.