The Spring ApplicationContext

1. Overzicht

In deze tutorial kijken we naar de lente ApplicationConext interface in detail.

2. Het ApplicationContext Koppel

Een van de belangrijkste kenmerken van het Spring-framework is de IoC-container (Inversion of Control). De Spring IoC-container is verantwoordelijk voor het beheer van de objecten van een applicatie. Het maakt gebruik van afhankelijkheidsinjectie om inversie van controle te bereiken.

De interfaces BeanFactory en ApplicationContext vertegenwoordigen de Spring IoC-container. Hier, BeanFactory is de root-interface voor toegang tot de Spring-container. Het biedt basisfunctionaliteiten voor het beheren van bonen.

Aan de andere kant is het ApplicationContext is een subinterface van de BeanFactory. Daarom biedt het alle functionaliteiten van BeanFactory.

Bovendien is het biedtmeer bedrijfsspecifieke functionaliteiten. De belangrijkste kenmerken van ApplicationContext zijn het oplossen van berichten, het ondersteunen van internationalisering, het publiceren van evenementen en specifieke contexten op de toepassingslaag. Daarom gebruiken we het als de standaard Spring-container.

3. Wat is een lenteboon?

Voordat we dieper in de ApplicationContext container, is het belangrijk om te weten over Spring beans. In het voorjaar is dat een boon een object dat de Spring-container instantieert, assembleert en beheert.

Moeten we dus alle objecten van onze applicatie configureren als Spring beans? Nou, als beste praktijk zouden we dat niet moeten doen.

Volgens Spring-documentatie moeten we in het algemeen bonen definiëren voor servicelaagobjecten, gegevenstoegangsobjecten (DAO's), presentatieobjecten, infrastructuurobjecten zoals Hibernate SessieFabrieken, JMS-wachtrijen, enzovoort.

Bovendien moeten we doorgaans geen fijnmazige domeinobjecten in de container configureren. Het is meestal de verantwoordelijkheid van DAO's en bedrijfslogica om domeinobjecten te maken en te laden.

Laten we dus een eenvoudige Java-klasse definiëren die we in deze zelfstudie als Spring bean zullen gebruiken:

openbare klasse AccountService {@Autowired privé AccountRepository accountRepository; // getters en setters}

4. Bonen in de container configureren

Zoals we weten, is de primaire taak van de ApplicationContext is om bonen te beheren.

Een applicatie moet dus de beanconfiguratie aan het ApplicationContext container. Daarom bestaat een Spring bean-configuratie uit een of meer bean-definities. Spring ondersteunt ook verschillende manieren om bonen te configureren.

4.1. Op Java gebaseerde configuratie

Eerst beginnen we met op Java gebaseerde configuratie, aangezien dit de nieuwste en meest geprefereerde manier van bean-configuratie is. Het is beschikbaar vanaf Spring 3.0.

Java-configuratie gebruikt doorgaans @Boon-geannoteerde methoden binnen een @Configuratie klasse. De @Boon annotatie bij een methode geeft aan dat de methode een Spring bean maakt. Bovendien is een klasse geannoteerd met @Configuratie geeft aan dat het Spring bean-configuraties bevat.

Dus laten we nu een configuratieklasse maken om onze AccountService klasse als Spring bean:

@Configuratie openbare klasse AccountConfig {@Bean openbare AccountService accountService () {retourneer nieuwe AccountService (accountRepository ()); } @Bean public AccountRepository accountRepository () {retourneer nieuwe AccountRepository (); }}

4.2. Op aantekeningen gebaseerde configuratie

Spring 2.5 introduceerde op annotaties gebaseerde configuratie als de eerste stap om bean-configuraties in Java mogelijk te maken.

In deze benadering maken we eerst op annotaties gebaseerde configuratie mogelijk via XML-configuratie. Vervolgens gebruiken we een reeks annotaties op onze Java-klassen, -methoden, constructors of velden om bonen te configureren. Enkele voorbeelden van deze annotaties zijn @Component, @Controller, @Onderhoud, @Repository, @Autowired, en @Kwalificatie.

We gebruiken deze annotaties met name ook met op Java gebaseerde configuratie. Spring blijft ook bij elke release meer mogelijkheden toevoegen aan deze annotaties.

Laten we nu een eenvoudig voorbeeld van deze configuratie bekijken.

Eerst maken we de XML-configuratie, user-bean-config.xml, om annotaties in te schakelen:

Hier, de annotation-config tag maakt op annotaties gebaseerde toewijzingen mogelijk. Ook de component-scan tag vertelt Spring waar te zoeken naar geannoteerde klassen.

Ten tweede maken we het Gebruikersservice class en definieer het als een Spring bean met behulp van de @Component annotatie:

@Component openbare klasse UserService {// gebruikersservicecode}

En dan zullen we een eenvoudige testcase schrijven om deze configuratie te testen:

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

4.3. XML-gebaseerde configuratie

Laten we tot slot eens kijken naar op XML gebaseerde configuratie. Het is de traditionele manier om bonen in het voorjaar te configureren.

Het is duidelijk dat we bij deze benadering alles doen bean-toewijzingen in een XML-configuratiebestand.

Laten we dus een XML-configuratiebestand maken, account-bean-config.xml, en definieer bonen voor ons AccountService klasse:

5. Soorten ApplicationContext

De lente biedt verschillende soorten ApplicationContext containers geschikt voor verschillende eisen. Dit zijn implementaties van het ApplicationContext koppel. Laten we dus eens kijken naar enkele veelvoorkomende soorten ApplicationContext.

5.1. AnnotationConfigApplicationContext

Laten we eerst eens kijken naar het AnnotationConfigApplicationContext class, die werd geïntroduceerd in Spring 3.0. Het kan duren klassen geannoteerd met @Configuratie, @Component, en JSR-330-metagegevens als invoer.

Laten we dus een eenvoudig voorbeeld bekijken van het gebruik van de AnnotationConfigApplicationContext container met onze op Java gebaseerde configuratie:

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

5.2. AnnotationConfigWebApplicationContext

AnnotationConfigWebApplicationContextis een webgebaseerde variant van AnnotationConfigApplicationContext.

We kunnen deze klasse gebruiken wanneer we Spring's configureren ContextLoaderListener servlet listener of een Spring MVC DispatcherServlet, in een web.xml het dossier.

Bovendien kunnen we vanaf Spring 3.0 deze applicatiecontextcontainer ook programmatisch configureren. Het enige wat we hoeven te doen is het WebApplicationInitializer koppel:

openbare klasse MyWebApplicationInitializer implementeert WebApplicationInitializer {public void onStartup (ServletContext-container) gooit ServletException {AnnotationConfigWebApplicationContext context = nieuwe AnnotationConfigWebApplicationContext (); context.register (AccountConfig.class); context.setServletContext (container); // servlet configuratie}}

5.3. XmlWebApplicationContext

Als we de XML-gebaseerde configuratie in een webapplicatie, kunnen we de XmlWebApplicationContext klasse.

In feite is het configureren van deze container hetzelfde als het AnnotationConfigWebApplicationContext class, wat betekent dat we het kunnen configureren in web.xml of implementeer het WebApplicationInitializer koppel:

openbare klasse MyXmlWebApplicationInitializer implementeert WebApplicationInitializer {openbare leegte onStartup (ServletContext-container) gooit ServletException {XmlWebApplicationContext-context = nieuwe XmlWebApplicationContext (); context.setConfigLocation ("/ WEB-INF / spring / applicationContext.xml"); context.setServletContext (container); // Servlet-configuratie}}

5.4. FileSystemXMLApplicationContext

Wij gebruiken de FileSystemXMLApplicationContext klas naar laad een XML-gebaseerd Spring-configuratiebestand uit het bestandssysteem of van URL's. Deze klasse is handig wanneer we het ApplicationContext programmatisch. Over het algemeen zijn testharnassen en stand-alone applicaties hiervoor enkele van de mogelijke use cases.

Laten we bijvoorbeeld eens kijken hoe we deze Spring-container kunnen maken en de bonen kunnen laden voor onze op XML gebaseerde configuratie:

String path = "C: /myProject/src/main/resources/applicationcontext/account-bean-config.xml"; ApplicationContext context = nieuw FileSystemXmlApplicationContext (pad); AccountService accountService = context.getBean ("accountService", AccountService.class);

5.5. ClassPathXmlApplicationContext

Voor het geval we dat willen laad een XML-configuratiebestand vanuit het klassenpad, kunnen we de ClassPathXmlApplicationContext klasse. Gelijkwaardig aan FileSystemXMLApplicationContext, het is zowel nuttig voor testharnassen als voor toepassingscontexten die zijn ingebed in JAR's.

Laten we dus een voorbeeld bekijken van het gebruik van deze klasse:

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

6. Extra functies van ApplicationContext

6.1. Berichtresolutie

De ApplicationContext koppel ondersteunt berichtresolutie en internationalisering door het MessageSource koppel. Verder biedt Spring er twee MessageSource implementaties, ResourceBundleMessageSource en StaticMessageSource.

We kunnen de StaticMessageSource om programmatisch berichten aan de bron toe te voegen. Het ondersteunt echter basisinternationalisering en is meer geschikt voor tests dan voor productiegebruik.

Aan de andere kant, ResourceBundleMessageSource is de meest voorkomende implementatie van MessageSource. Het is gebaseerd op de onderliggende JDK's ResouceBundle implementatie. Het maakt ook gebruik van de standaard berichtparsing van de JDK die wordt geleverd door MessageFormat.

Laten we nu eens kijken hoe we de MessageSource om de berichten uit een eigenschappenbestand te lezen.

Eerst maken we het messages.properties bestand op het klassenpad:

account.name = TestAccount

Ten tweede voegen we een boondefinitie toe aan onze Accountconfiguratie klasse:

@Bean openbare MessageSource messageSource () {ResourceBundleMessageSource messageSource = nieuwe ResourceBundleMessageSource (); messageSource.setBasename ("config / messages"); terug messageSource; }

Ten derde zullen we de MessageSource in de AccountService:

@Autowired privé MessageSource messageSource;

Ten slotte kunnen we de getMessage methode overal in het AccountService om het bericht te lezen:

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

De lente biedt ook de HerlaadbareResourceBundleMessageSource class, die het lezen van bestanden vanaf elke Spring-bronlocatie mogelijk maakt en het hot herladen van bundeleigenschappenbestanden ondersteunt.

6.2. Afhandeling van gebeurtenissen

ApplicationContext ondersteunt de afhandeling van gebeurtenissen met behulp van de ApplicationEvent klasse en de ApplicationListener koppel. Het ondersteunt ingebouwde evenementen zoals ContextStartedEvent, ContextStoppedEvent, ContextClosedEvent, en RequestHandledEvent. Bovendien ondersteunt het ook aangepaste evenementen voor zakelijk gebruik.

7. Conclusie

In deze zelfstudie hebben we verschillende aspecten van het ApplicationContext container in het voorjaar. We hebben verschillende voorbeelden gezien van hoe Spring Beans in een AppicationContext. We hebben ook gezien hoe u verschillende soorten ApplicationContext.

Zoals altijd is de volledige code beschikbaar op GitHub.