A tavaszi ApplicationContext

1. Áttekintés

Ebben az oktatóanyagban megvizsgáljuk a tavaszt ApplicationConext felület részletesen.

2. A ApplicationContext Felület

A Spring keretrendszer egyik fő jellemzője az IoC (Inversion of Control) konténer. A tavaszi IoC-tároló felelős az alkalmazás objektumainak kezeléséért. Függőséginjekciót használ a kontroll inverziójának eléréséhez.

Az interfészek BeanFactory és ApplicationContext képviselik a tavaszi IoC konténert. Itt, BeanFactory a gyökérfelület a Spring tároló eléréséhez. Alapfunkciókat biztosít a bab kezeléséhez.

Másrészt a ApplicationContext egy alfelülete a BeanFactory. Ezért felajánlja a BeanFactory.

Továbbá azt biztosítjavállalatspecifikusabb funkciók. A fontos jellemzői ApplicationContext vannak üzenetek megoldása, a nemzetközivé válás támogatása, események közzététele és alkalmazásréteg-specifikus összefüggések. Ezért használjuk alapértelmezett tavaszi konténerként.

3. Mi az a tavaszi bab?

Mielőtt mélyebbre merülnénk a ApplicationContext tartályban, fontos tudni a tavaszi babról. Tavasszal egy bab egy olyan tárgy, amelyet a Spring konténer példányosít, összeszerel és kezel.

Tehát konfigurálnunk kellene az alkalmazásunk összes tárgyát tavaszi babnak? Nos, bevált gyakorlatként nem szabad.

A tavaszi dokumentációnak megfelelően általában meg kell határoznunk a babokat a szolgáltatási réteg objektumokhoz, az adatelérési objektumokhoz (DAO), a prezentációs objektumokhoz, az olyan infrastruktúra objektumokhoz, mint a Hibernate SessionFactories, JMS Queues stb.

Emellett általában nem szabad finom szemcsés tartományi objektumokat konfigurálnunk a tárolóban. Általában a DAO-k és az üzleti logika felelőssége a tartományi objektumok létrehozása és betöltése.

Tehát definiáljunk egy egyszerű Java osztályt, amelyet tavaszi babként használunk ebben az oktatóanyagban:

public class AccountService {@Autowired private AccountRepository accountRepository; // szerelők és beállítók}

4. A bab konfigurálása a konténerben

Mint tudjuk, a ApplicationContext a bab kezelése.

Tehát egy alkalmazásnak meg kell adnia a babkonfigurációt a ApplicationContext tartály. Ezért a tavaszi babkonfiguráció egy vagy több babdefinícióból áll. Ezenkívül a Spring támogatja a bab konfigurálásának különböző módjait.

4.1. Java-alapú konfiguráció

Először a Java-alapú konfigurációval kezdjük, mivel ez a bab konfigurálás legújabb és legelőnyösebb módja. 3.0 tavasztól kapható.

A Java konfiguráció általában használ @Bab-jegyzetlen módszerek a @ Konfiguráció osztály. A @Bab a metódus jegyzete azt jelzi, hogy a módszer tavaszi babot hoz létre. Sőt, egy osztály jegyzetelt @ Konfiguráció azt jelzi, hogy tartalmaz tavaszi bab konfigurációkat.

Tehát most hozzunk létre egy konfigurációs osztályt a sajátunk definiálásához AccountService osztály, mint tavaszi bab:

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

4.2. Kommentár alapú konfiguráció

A Spring 2.5 az annotáció alapú konfigurációt vezette be a babkonfigurációk engedélyezésének első lépéseként a Java-ban.

Ebben a megközelítésben először engedélyezzük az annotáció alapú konfigurációt XML konfiguráción keresztül. Ezután a bab konfigurálásához a Java osztályok, metódusok, konstruktorok vagy mezők kommentárjait használjuk. Néhány példa ezekre az annotációkra @Összetevő, @Vezérlő, @Szolgáltatás, @Raktár, @Autowired, és @ Minősítő.

Nevezetesen ezeket a kommentárokat Java alapú konfigurációval is használjuk. Ezenkívül Spring minden kiadásnál folyamatosan további képességeket ad ezekhez a kommentárokhoz.

Tehát most nézzük meg a konfiguráció egyszerű példáját.

Először létrehozzuk az XML konfigurációt, user-bean-config.xml, a kommentárok engedélyezéséhez:

Itt, a annotation-config címke lehetővé teszi az annotáció alapú leképezéseket. Továbbá a komponens-szkennelés címke megmondja Springnek, hol keresse a feljegyzésekkel ellátott osztályokat.

Másodszor, létrehozzuk a UserService osztályt és definiálja azt tavaszi babként a @Összetevő kommentár:

@Component public class UserService {// felhasználói szolgáltatáskód}

Ezután írunk egy egyszerű tesztesetet a konfiguráció tesztelésére:

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

4.3. XML-alapú konfiguráció

Végül vessünk egy pillantást az XML-alapú konfigurációra. A bab hagyományos konfigurálása tavasszal.

Nyilvánvaló, hogy ebben a megközelítésben mindannyian megtesszük bab leképezések egy XML konfigurációs fájlban.

Hozzunk létre egy XML konfigurációs fájlt, account-bean-config.xml, és definiálja a babot AccountService osztály:

5. Típusai ApplicationContext

A tavasz különböző típusú ApplicationContext különböző követelményeknek megfelelő konténerek. Ezek a ApplicationContext felület. Vessünk egy pillantást néhány gyakori típusra ApplicationContext.

5.1. AnnotationConfigApplicationContext

Először nézzük meg a AnnotationConfigApplicationContext osztály, amelyet a 3.0 tavasszal mutattak be. Ez eltarthat osztályokkal jegyzetelt @ Konfiguráció, @Összetevő, és JSR-330 metaadatok bemenetként.

Lássunk tehát egy egyszerű példát a AnnotationConfigApplicationContext tároló Java alapú konfigurációnkkal:

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

5.2. AnnotationConfigWebApplicationContext

AnnotationConfigWebApplicationContextegy webalapú változat nak,-nek AnnotationConfigApplicationContext.

Ezt az osztályt akkor használhatjuk, amikor konfiguráljuk a Spring-et ContextLoaderListener szervlet meghallgató vagy egy tavaszi MVC DispatcherServlet, a web.xml fájl.

Ezenkívül a 3.0 tavasztól ezt az alkalmazáskörnyezet-tárolót is programozottan konfigurálhatjuk. Mindössze annyit kell tennünk, hogy megvalósítsuk a WebApplicationInitializer felület:

public class MyWebApplicationInitializer végrehajtja a WebApplicationInitializer {public void onStartup (ServletContext tároló) dobja a ServletException {AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext (); context.register (AccountConfig.class); context.setServletContext (tároló); // szervlet konfiguráció}}

5.3. XmlWebApplicationContext

Ha a XML alapú konfiguráció egy webalkalmazásban, használhatjuk a XmlWebApplicationContext osztály.

Ami azt illeti, ennek a tárolónak a konfigurálása olyan, mint a AnnotationConfigWebApplicationContext csak osztály, ami azt jelenti, hogy itt konfigurálhatjuk web.xml vagy megvalósítani a WebApplicationInitializer felület:

public class MyXmlWebApplicationInitializer megvalósítja a WebApplicationInitializer {public void onStartup (ServletContext tároló) dobja a ServletException {XmlWebApplicationContext context = új XmlWebApplicationContext (); context.setConfigLocation ("/ WEB-INF / spring / applicationContext.xml"); context.setServletContext (tároló); // Servlet konfiguráció}}

5.4. FileSystemXMLApplicationContext

Használjuk a FileSystemXMLApplicationContext osztályba töltsön be egy XML-alapú Spring konfigurációs fájlt a fájlrendszerből vagy az URL-ekből. Ez az osztály akkor hasznos, ha be kell töltenünk a ApplicationContext programszerűen. Általában a tesztkötegek és az önálló alkalmazások jelentik ennek a lehetséges felhasználási eseteket.

Lássuk például, hogyan hozhatjuk létre ezt a tavaszi tárolót és tölthetjük be a babot az XML alapú konfigurációnkhoz:

Karakterlánc elérési út = "C: /myProject/src/main/resources/applicationcontext/account-bean-config.xml"; ApplicationContext context = új FileSystemXmlApplicationContext (elérési út); AccountService accountService = context.getBean ("accountService", AccountService.class);

5.5. ClassPathXmlApplicationContext

Ha szeretnénk töltsön be egy XML konfigurációs fájlt az osztályútvonalról, használhatjuk a ClassPathXmlApplicationContext osztály. Hasonló FileSystemXMLApplicationContext, hasznos tesztkötegekhez, valamint a JAR-ekbe ágyazott alkalmazási környezethez.

Tehát nézzünk meg egy példát ennek az osztálynak a használatára:

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

6. További jellemzői ApplicationContext

6.1. Üzenetfeloldás

A ApplicationContext felület támogatja az üzenet felbontását és a nemzetközivé válás kiterjesztésével MessageSource felület. Ezenkívül Spring kettőt nyújt MessageSource megvalósítások, ResourceBundleMessageSource és StaticMessageSource.

Használhatjuk a StaticMessageSource programozottan hozzáadni az üzeneteket a forráshoz. Támogatja azonban az alapvető nemzetközivé válást, és alkalmasabb tesztelésre, mint gyártási felhasználásra.

Másrészről, ResourceBundleMessageSource a leggyakoribb megvalósítása MessageSource. A mögöttes JDK-kra támaszkodik ResouceBundle végrehajtás. Használja a JDK által biztosított szabványos üzenetelemzést is MessageFormat.

Most nézzük meg, hogyan használhatjuk a MessageSource hogy olvassa el az üzeneteket egy tulajdonságfájlból.

Először létrehozzuk a üzenetek.tulajdonságok fájl az osztályúton:

account.name = TestAccount

Másodszor, hozzáadunk egy babdefiníciót a AccountConfig osztály:

@Bean public MessageSource messageSource () {ResourceBundleMessageSource messageSource = új ResourceBundleMessageSource (); messageSource.setBasename ("config / messages"); return messageSource; }

Harmadszor, beadjuk a MessageSource ban,-ben AccountService:

@Autowired private MessageSource messageSource;

Végül használhatjuk a getMessage módszer bárhol a AccountService az üzenet elolvasásához:

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

A tavasz a ReloadableResourceBundleMessageSource osztály, amely lehetővé teszi fájlok olvasását bármilyen tavaszi erőforrás helyről, és támogatja a köteg tulajdonságfájlok gyors újratöltését.

6.2. Eseménykezelés

ApplicationContext támogatja az eseménykezelést segítségével ApplicationEvent osztály és a ApplicationListener felület. Támogatja a beépített eseményeket, mint például ContextStartedEvent, ContextStoppedEvent, ContextClosedEvent, és RequestHandledEvent. Sőt, üzleti célú egyedi eseményeket is támogat.

7. Következtetés

Ebben az oktatóanyagban megvitattuk a ApplicationContext konténer tavasszal. Különböző példákat láthattunk a tavaszi bab konfigurálásáról egy AppicationContext. Láttuk, hogyan lehet különféle típusúakat létrehozni és használni ApplicationContext.

Mint mindig, a teljes kód elérhető a GitHubon.