streamalism.org

1. Introduksjon

I denne grunnleggende opplæringen lærer vi hvordan du gjør enkel XML-basert bønnekonfigurasjon med Spring Framework.

2. Oversikt

La oss starte med å legge til Spring's bibliotekavhengighet i pom.xml:

 org.springframework spring-context 5.1.4.RELEASE 

Den siste versjonen av våravhengigheten finner du her.

3. Avhengighetsinjeksjon - en oversikt

Avhengighetsinjeksjon er en teknikk der avhengigheter av et objekt leveres av eksterne beholdere.

La oss si at vi har en applikasjonsklasse som er avhengig av en tjeneste som faktisk håndterer forretningslogikken:

offentlig klasse IndexApp {privat IService-tjeneste; // standard konstruktører / getters / setters} 

La oss si det IService er et grensesnitt:

offentlig grensesnitt IService {public String serve (); } 

Dette grensesnittet kan ha flere implementeringer.

La oss se raskt på en potensiell implementering:

offentlig klasse IndexService implementerer IService {@Override public String serve () {return "Hello World"; }} 

Her, IndexApp er en komponent på høyt nivå som avhenger av den lavnivåkomponenten som kalles IService.

I hovedsak kobler vi fra IndexApp fra en bestemt implementering av IService som kan variere ut fra de ulike faktorene.

4. Avhengighetsinjeksjon - i aksjon

La oss se hvordan vi kan injisere en avhengighet.

4.1. Bruke egenskaper

La oss se hvordan vi kan koble avhengighetene sammen ved hjelp av en XML-basert konfigurasjon:

Som vi kan se, lager vi en forekomst av IndexService og tildele den en id. Som standard er bønnen en singleton. Vi lager også en forekomst av IndexApp.

Innenfor denne bønnen injiserer vi den andre bønnen ved hjelp av settermetoden.

4.2. Bruke Constructor

I stedet for å injisere en bønne via settermetoden, kan vi injisere avhengigheten ved hjelp av konstruktøren:

4.3. Bruke Static Factory

Vi kan også injisere en bønne som returneres av en fabrikk. La oss lage en enkel fabrikk som returnerer en forekomst av IService basert på antallet som er oppgitt:

offentlig klasse StaticServiceFactory {offentlig statisk IService getNumber (int-nummer) {// ...}} 

La oss nå se hvordan vi kunne bruke implementeringen ovenfor for å injisere en bønne i IndexApp ved hjelp av en XML-basert konfigurasjon:

I eksemplet ovenfor kaller vi det statiske getService metoden bruker fabrikk-metode å lage en bønne med id meldingstjeneste som vi sprøyter inn i IndexApp.

4.4. Bruke fabrikkmetoden

La oss vurdere en forekomstfabrikk som returnerer en forekomst av IService basert på antallet som er oppgitt. Denne gangen er metoden ikke statisk:

public class InstanceServiceFactory {public IService getNumber (int number) {// ...}} 

La oss nå se hvordan vi kunne bruke implementeringen ovenfor for å injisere en bønne i IndexApp bruker XML-konfigurasjon:

I eksemplet ovenfor kaller vi getService metode på en forekomst av InstanceServiceFactory ved hjelp av fabrikk-metode å lage en bønne med id meldingstjeneste som vi injiserer i IndexApp.

5. Testing

Slik får vi tilgang til konfigurerte bønner:

@Test offentlig ugyldig nårGetBeans_returnsBean () {ApplicationContext applicationContext = ny ClassPathXmlApplicationContext ("..."); IndexApp indexApp = applicationContext.getBean ("indexApp", IndexApp.class); assertNotNull (indexApp); } 

6. Konklusjon

I denne raske opplæringen illustrerte vi eksempler på hvordan vi kan injisere avhengighet ved hjelp av XML-basert konfigurasjon ved hjelp av Spring Framework.

Implementeringen av disse eksemplene finnes i GitHub-prosjektet - dette er et Maven-basert prosjekt, så det skal være enkelt å importere og kjøre som det er.