streamalism.org

1. Oversigt

I denne vejledning ser vi på foråret ApplicationConext interface i detaljer.

2. Den ApplicationContext Interface

Et af hovedfunktionerne i Spring framework er IoC-containeren (Inversion of Control). Spring IoC-containeren er ansvarlig for at administrere objekterne i en applikation. Det bruger afhængighedsinjektion for at opnå inversion af kontrol.

Grænsefladerne BeanFactory og ApplicationContext repræsenterer Spring IoC-containeren. Her, BeanFactory er rodgrænsefladen til adgang til Spring-containeren. Det giver grundlæggende funktioner til styring af bønner.

På den anden side er ApplicationContext er en undergrænseflade til BeanFactory. Derfor tilbyder den alle funktionerne i BeanFactory.

Desuden er det giverflere virksomhedsspecifikke funktioner. De vigtige træk ved ApplicationContext er løsning af meddelelser, understøttelse af internationalisering, udgivelse af begivenheder og applikationslagsspecifikke sammenhænge. Dette er grunden til, at vi bruger det som standard Spring container.

3. Hvad er en Spring Bean?

Før vi dykker dybere ned i ApplicationContext beholder, er det vigtigt at vide om forårbønner. Om foråret er en bønne det et objekt, som fjedercontaineren instantierer, samler og administrerer.

Så skal vi konfigurere alle objekterne i vores ansøgning som springbønner? Som en bedste praksis bør vi ikke.

I henhold til Spring-dokumentation skal vi generelt definere bønner til servicelaggenstande, dataadgangsobjekter (DAO'er), præsentationsobjekter, infrastrukturobjekter såsom Hibernate SessionFabrikker, JMS køer og så videre.

Vi skal også typisk ikke konfigurere finkornede domæneobjekter i containeren. Det er normalt ansvaret for DAO'er og forretningslogik at oprette og indlæse domæneobjekter.

Så lad os definere en simpel Java-klasse, som vi bruger som en springbønne i denne vejledning:

offentlig klasse AccountService {@Autowired privat AccountRepository accountRepository; // getters og setters}

4. Konfiguration af bønner i beholderen

Som vi ved, er det primære job hos ApplicationContext er at styre bønner.

Så en applikation skal levere bønnekonfigurationen til ApplicationContext beholder. Derfor består en fjederbønnekonfiguration af en eller flere definitioner af bønner. Spring understøtter også forskellige måder at konfigurere bønner på.

4.1. Java-baseret konfiguration

Først starter vi med Java-baseret konfiguration, da den er den nyeste og mest foretrukne måde til konfiguration af bønner. Den er tilgængelig fra foråret 3.0 og fremefter.

Java-konfiguration bruger typisk @Bønne-anmærkede metoder inden for en @Konfiguration klasse. Det @Bønne anmærkning om en metode angiver, at metoden skaber en fjærbønne. Desuden en klasse kommenteret med @Konfiguration angiver, at den indeholder fjederbønnekonfigurationer.

Så lad os nu oprette en konfigurationsklasse til at definere vores Kontoservice klasse som en forårsbønne:

@Configuration public class AccountConfig {@Bean public AccountService accountService () {return new AccountService (accountRepository ()); } @Bean offentlig AccountRepository accountRepository () {returner nyt AccountRepository (); }}

4.2. Annotationsbaseret konfiguration

Spring 2.5 introducerede annoteringsbaseret konfiguration som det første skridt til at aktivere bønnekonfigurationer i Java.

I denne tilgang aktiverer vi først annoteringsbaseret konfiguration via XML-konfiguration. Derefter bruger vi et sæt kommentarer til vores Java-klasser, metoder, konstruktører eller felter til at konfigurere bønner. Nogle eksempler på disse kommentarer er @Komponent, @Kontrol, @Service, @Repository, @Autowiredog @Kvalifikator.

Især bruger vi også disse kommentarer med Java-baseret konfiguration. Spring fortsætter med at tilføje flere funktioner til disse kommentarer med hver udgivelse.

Så lad os nu se et simpelt eksempel på denne konfiguration.

Først opretter vi XML-konfigurationen, user-bean-config.xml, for at aktivere annoteringer:

Her, det annotation-config tag muliggør annoteringsbaserede tilknytninger. Også den komponent-scanning tag fortæller Spring, hvor man skal se efter annoterede klasser.

For det andet opretter vi UserService klasse og definer det som en foråret bønne ved hjælp af @Komponent kommentar:

@Komponent offentlig klasse UserService {// brugertjenestekode}

Og så skriver vi en simpel test case for at teste denne konfiguration:

ApplicationContext context = ny ClassPathXmlApplicationContext ("applicationcontext / user-bean-config.xml"); UserService userService = context.getBean (UserService.class); assertNotNull (userService);

4.3. XML-baseret konfiguration

Lad os endelig se på XML-baseret konfiguration. Det er den traditionelle måde at konfigurere bønner om foråret.

Det er klart, i denne tilgang gør vi alle bønnetilknytninger i en XML-konfigurationsfil.

Så lad os oprette en XML-konfigurationsfil, konto-bønne-config.xmlog definer bønner til vores Kontoservice klasse:

5. Typer af ApplicationContext

Foråret giver forskellige typer ApplicationContext containere, der passer til forskellige krav. Dette er implementeringer af ApplicationContext interface. Så lad os se på nogle af de almindelige typer ApplicationContext.

5.1. AnnotationConfigApplicationContext

Lad os først se AnnotationConfigApplicationContext klasse, som blev introduceret i foråret 3.0. Det kan tage klasser kommenteret med @Konfiguration, @Komponent, og JSR-330 metadata som input.

Så lad os se et simpelt eksempel på brug af AnnotationConfigApplicationContext container med vores Java-baserede konfiguration:

ApplicationContext context = ny AnnotationConfigApplicationContext (AccountConfig.class); AccountService accountService = context.getBean (AccountService.class);

5.2. AnnotationConfigWebApplicationContext

AnnotationConfigWebApplicationContexter en webbaseret variant af AnnotationConfigApplicationContext.

Vi bruger muligvis denne klasse, når vi konfigurerer Spring's ContextLoaderListener servlet-lytter eller en Spring MVC DispatcherServlet, i en web.xml fil.

Desuden kan vi fra forår 3.0 og fremover også konfigurere denne applikationskontekstbeholder programmatisk. Alt, hvad vi skal gøre er at implementere WebApplicationInitializer grænseflade:

public class MyWebApplicationInitializer implementerer WebApplicationInitializer {public void onStartup (ServletContext container) kaster ServletException {AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext (); context.register (AccountConfig.class); context.setServletContext (container); // konfiguration af servlet}}

5.3. XmlWebApplicationContext

Hvis vi bruger XML-baseret konfiguration i en webapplikation, kan vi bruge XmlWebApplicationContext klasse.

Faktisk er konfiguration af denne container ligesom AnnotationConfigWebApplicationContext kun klasse, hvilket betyder, at vi kan konfigurere det i web.xml eller implementere WebApplicationInitializer grænseflade:

offentlig klasse MyXmlWebApplicationInitializer implementerer WebApplicationInitializer {public void onStartup (ServletContext container) kaster ServletException {XmlWebApplicationContext context = new XmlWebApplicationContext (); context.setConfigLocation ("/ WEB-INF / spring / applicationContext.xml"); context.setServletContext (container); // Servlet-konfiguration}}

5.4. FileSystemXMLApplicationContext

Vi bruger FileSystemXMLApplicationContext klasse til indlæse en XML-baseret Spring-konfigurationsfil fra filsystemet eller fra webadresser. Denne klasse er nyttig, når vi har brug for at indlæse ApplicationContext programmatisk. Generelt er testseler og enkeltstående applikationer nogle af de mulige anvendelsestilfælde til dette.

Lad os for eksempel se, hvordan vi kan oprette denne Spring-container og indlæse bønnerne til vores XML-baserede konfiguration:

Strengsti = "C: /myProject/src/main/resources/applicationcontext/account-bean-config.xml"; ApplicationContext context = ny FileSystemXmlApplicationContext (sti); AccountService accountService = context.getBean ("accountService", AccountService.class);

5.5. ClassPathXmlApplicationContext

Hvis vi ønsker det indlæse en XML-konfigurationsfil fra klassestien, kan vi bruge ClassPathXmlApplicationContext klasse. Svarende til FileSystemXMLApplicationContext, det er nyttigt til test seler såvel som til applikationskontekster indlejret i JAR'er.

Så lad os se et eksempel på brug af denne klasse:

ApplicationContext context = ny ClassPathXmlApplicationContext ("applicationcontext / account-bean-config.xml"); AccountService accountService = context.getBean ("accountService", AccountService.class);

6. Yderligere funktioner i ApplicationContext

6.1. Beskedopløsning

Det ApplicationContext interface understøtter beskedopløsning og internationalisering ved at udvide MessageSource interface. Desuden giver Spring to MessageSource implementeringer, ResourceBundleMessageSource og StaticMessageSource.

Vi kan bruge StaticMessageSource for at programmatisk føje meddelelser til kilden. Det understøtter dog grundlæggende internationalisering og er mere egnet til test end produktionsanvendelse.

På den anden side, ResourceBundleMessageSource er den mest almindelige implementering af MessageSource. Den er afhængig af de underliggende JDK'er ResouceBundle implementering. Det bruger også JDK's standard meddelelsesparsing leveret af MessageFormat.

Lad os nu se, hvordan vi kan bruge MessageSource for at læse meddelelserne fra en egenskabsfil.

Først opretter vi beskeder. ejendomme fil på klassestien:

account.name = TestAccount

For det andet tilføjer vi en bønnedefinition i vores AccountConfig klasse:

@Bean public MessageSource messageSource () {ResourceBundleMessageSource messageSource = ny ResourceBundleMessageSource (); messageSource.setBasename ("config / messages"); returnere beskedKilde; }

For det tredje indsprøjter vi MessageSource i Kontoservice:

@Autowired privat MessageSource messageSource;

Endelig kan vi bruge getMessage metode overalt i Kontoservice at læse beskeden:

messageSource.getMessage ("account.name", null, Locale.ENGLISH);

Foråret giver også ReloadableResourceBundleMessageSource klasse, der giver mulighed for at læse filer fra enhver Spring ressource placering og understøtter hot genindlæsning af bundle egenskab filer.

6.2. Håndtering af begivenheder

ApplicationContext understøtter håndtering af begivenheder ved hjælp af ApplicationEvent klasse og ApplicationListener interface. Det understøtter indbyggede begivenheder som f.eks ContextStartedEvent, ContextStoppedEvent, ContextClosedEventog RequestHandledEvent. Desuden understøtter den også brugerdefinerede begivenheder til forretningsbrugssager.

7. Konklusion

I denne vejledning har vi diskuteret forskellige aspekter af ApplicationContext container om foråret. Vi har set forskellige eksempler på, hvordan man konfigurerer Spring beans i en AppicationContext. Vi har også set, hvordan man opretter og bruger forskellige typer ApplicationContext.

Som altid er den komplette kode tilgængelig på GitHub.