BeanFactory vs ApplicationContext

Jestem całkiem nowy w Spring Framework, bawiłem się nim i składałem kilka przykładowych aplikacji w celu oceny Spring MVC do wykorzystania w nadchodzącym projekcie firmowym. Jak dotąd bardzo podoba mi się to, co widzę w Spring MVC, wydaje się bardzo łatwe w użyciu i zachęca do pisania klas, które są bardzo przyjazne dla testów jednostkowych.

Jako ćwiczenie piszę główną metodę dla jednego z moich projektów próbek / testów. Jedną z rzeczy, których nie jestem pewien, są dokładne różnice między BeanFactoryi ApplicationContext- który jest odpowiedni do zastosowania w jakich warunkach?

Rozumiem, że to się ApplicationContextrozszerza BeanFactory, ale jeśli piszę prostą główną metodę, czy potrzebuję dodatkowej funkcjonalności, która ApplicationContextzapewnia? I dokładnie, jaką dodatkową funkcję ApplicationContextzapewnia?

Czy oprócz odpowiedzi na pytanie „których powinienem użyć w metodzie main ()”, czy istnieją jakieś standardy lub wytyczne dotyczące tego, które wdrożenie powinienem zastosować w takim scenariuszu? Czy moja metoda main () powinna być napisana tak, aby zależała od konfiguracji komponentu bean / aplikacji w formacie XML - czy jest to bezpieczne założenie, czy też blokuję użytkownika na czymś konkretnym?

I czy ta odpowiedź zmienia się w środowisku internetowym - czy którakolwiek z moich klas musiała wiedzieć o Springu, czy jest bardziej prawdopodobne, że będzie jej potrzebować ApplicationContext?

Dziękuję za wszelką pomoc. Wiem, że na wiele z tych pytań prawdopodobnie znajduje się odpowiedź w podręczniku referencyjnym, ale ciężko mi znaleźć wyraźny podział tych dwóch interfejsów i zalet / wad każdego z nich bez czytania instrukcji za pomocą grzebienia o drobnych zębach.

Wiosenne dokumenty są w tym świetne: 3.8.1. BeanFactory czy ApplicationContext? . Mają tabelę z porównaniem, opublikuję fragment:

Fabryka Fasoli

• Tworzenie instancji / okablowanie komponentu bean

Kontekst aplikacji

• Tworzenie instancji / okablowanie komponentu bean
• Automatyczna rejestracja BeanPostProcessor
• Automatyczna rejestracja BeanFactoryPostProcessor
• Wygodny dostęp do źródła wiadomości (dla i18n)
• Publikacja ApplicationEvent

Więc jeśli potrzebujesz któregokolwiek z punktów przedstawionych po stronie kontekstu aplikacji, powinieneś użyć ApplicationContext.

Wiosna zapewnia dwa rodzaje kontenerów MKOl, jeden jest, XMLBeanFactorya drugi jest ApplicationContext.

+---------------------------------------+-----------------+--------------------------------+
|                                       | BeanFactory     |       ApplicationContext       |
+---------------------------------------+-----------------+--------------------------------+
| Annotation support                    | No              | Yes                            |
| BeanPostProcessor Registration        | Manual          | Automatic                      |
| implementation                        | XMLBeanFactory  | ClassPath/FileSystem/WebXmlApplicationContext|
| internationalization                  | No              | Yes                            |
| Enterprise services                   | No              | Yes                            |
| ApplicationEvent publication          | No              | Yes                            |
+---------------------------------------+-----------------+--------------------------------+

• FileSystemXmlApplicationContext Fasola załadowana przez pełną ścieżkę.
• ClassPathXmlApplicationContext Fasola ładowana przez CLASSPATH
• XMLWebApplicationContexti AnnotationConfigWebApplicationContextziarna ładowane przez kontekst aplikacji internetowej.
• AnnotationConfigApplicationContext Ładowanie fasoli szparagowej z konfiguracji opartej na adnotacjach.

przykład:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextto kontener zainicjowany przez a ContextLoaderListenerlub ContextLoaderServletzdefiniowany w a web.xmli ContextLoaderPluginzdefiniowany w struts-config.xml.

Uwaga : XmlBeanFactoryjest przestarzałe od wiosny 3.1 na rzecz DefaultListableBeanFactoryi XmlBeanDefinitionReader.

Dla mnie Podstawowa różnica do wyboru BeanFactoryponad ApplicationContextwydaje się, że ApplicationContextbędzie pre-instancję wszystkich ziaren. Od tych wiosennych docs :

Wiosna ustawia właściwości i rozwiązuje zależności tak późno, jak to możliwe, kiedy fasola jest faktycznie tworzona. Oznacza to, że kontener Spring, który został poprawnie załadowany, może później wygenerować wyjątek, gdy zażądasz obiektu, jeśli wystąpi problem z tworzeniem tego obiektu lub jednej z jego zależności. Na przykład komponent bean zgłasza wyjątek w wyniku brakującej lub niepoprawnej właściwości. Ta potencjalnie opóźniona widoczność niektórych problemów konfiguracyjnych jest powodem, dla którego implementacje ApplicationContext domyślnie wykonują pojedyncze komponenty bean singleton. Kosztem czasu i pamięci potrzebnej do utworzenia tych ziaren, zanim będą one rzeczywiście potrzebne, odkryjesz problemy z konfiguracją podczas tworzenia ApplicationContext, a nie później. Nadal możesz nadpisać to domyślne zachowanie, aby fasola singleton leniwie zainicjowała, a nie była wcześniej utworzona.

Biorąc to pod uwagę, początkowo zdecydowałem się BeanFactoryna użycie w testach integracji / wydajności, ponieważ nie chciałem ładować całej aplikacji do testowania izolowanych ziaren. Jednak - i ktoś mnie poprawi, jeśli się mylę - BeanFactorynie obsługuje classpathkonfiguracji XML. Tak BeanFactoryi ApplicationContextkażdy zapewnić kluczową cechę chciałem, ale też nie obu.

Prawie, jak mogę stwierdzić, w dokumentacji znajduje się uwaga na temat nadpisywania domyślnego zachowania tworzenia instancji i dotyczy ona jednego komponentu bean, więc nie mogę po prostu ustawić atrybutu „lazy-init” w pliku XML lub utknąłem utrzymując jego wersję do testów i jedną do wdrożenia.

Skończyło się na tym, ClassPathXmlApplicationContextże leniwie ładowałem fasolę do użycia w takich testach:

public class LazyLoadingXmlApplicationContext extends ClassPathXmlApplicationContext {

    public LazyLoadingXmlApplicationContext(String[] configLocations) {
        super(configLocations);
    }

    /**
     * Upon loading bean definitions, force beans to be lazy-initialized.
     * @see org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)
     */

    @Override
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        super.loadBeanDefinitions(reader);
        for (String name: reader.getBeanFactory().getBeanDefinitionNames()) {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) reader.getBeanFactory().getBeanDefinition(name);
            beanDefinition.setLazyInit(true);
        }
    }

}

Aby dodać do odpowiedzi Miguela Pinga, oto kolejna część dokumentacji, która również na to odpowiada:

Krótka wersja: użyj ApplicationContext, chyba że masz naprawdę dobry powód, aby tego nie robić. Dla tych z Was, którzy szukają nieco większej głębi w kwestii „ale dlaczego” powyższej rekomendacji, czytajcie dalej.

(publikując to dla przyszłych wiosennych nowicjuszy, którzy mogą przeczytać to pytanie)

1. ApplicationContext jest bardziej preferowanym sposobem niż BeanFactory

2. W nowych wersjach wiosennych BeanFactoryjest zastąpiony przez ApplicationContext. Ale nadal BeanFactoryistnieje kompatybilność wsteczna

3. ApplicationContext extends BeanFactory i ma następujące zalety
   • obsługuje internacjonalizację wiadomości tekstowych
   • obsługuje publikację wydarzeń dla zarejestrowanych słuchaczy
   • dostęp do zasobów, takich jak adresy URL i pliki

ApplicationContext: Ładuje fasolkę szparagową skonfigurowaną w wiosennym pliku konfiguracyjnym i zarządza cyklem życia fasolki szparagowej jako i KIEDY POJEMNIK ZACZYNA SIĘ. Nie będzie czekać aż getBean („springbeanref”) .

BeanFactory Ładuje ziarna fasoli skonfigurowane w pliku konfiguracji wiosny, zarządza cyklem życia ziarna fasoli, gdy wywołujemy getBean („springbeanref”) . Tak więc, gdy wywołujemy getBean („springbeanref”) w momencie rozpoczęcia cyklu życia fasoli wiosennej .

Myślę, że lepiej zawsze używać ApplicationContext, chyba że jesteś w środowisku mobilnym, jak ktoś już powiedział. ApplicationContext ma większą funkcjonalność i zdecydowanie chcesz używać PostProcesorów, takich jak RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor i CommonAnnotationBeanPostProcessor, które pomogą uprościć pliki konfiguracyjne Spring, a możesz używać adnotacji takich jak @Required, @PostConstruct, @ResConstruct, @ResCource .

Nawet jeśli nie używasz wszystkich rzeczy, które oferuje ApplicationContext, lepiej go użyć mimo to, a później, jeśli zdecydujesz się użyć pewnych zasobów, takich jak wiadomości lub postprocesory, lub inny schemat, aby dodać porady transakcyjne i takie, będzie już miał ApplicationContext i nie będzie musiał zmieniać żadnego kodu.

Jeśli piszesz samodzielną aplikację, załaduj ApplicationContext do swojej głównej metody, używając ClassPathXmlApplicationContext, a następnie pobierz główny komponent bean i wywołaj jego funkcję run () (lub inną metodę), aby uruchomić aplikację. Jeśli piszesz aplikację internetową, użyj ContextLoaderListener w pliku web.xml, aby utworzyć ApplicationContext, a później możesz pobrać ją z ServletContext, niezależnie od tego, czy używasz JSP, JSF, JSTL, rozpórek, Tapestry itp. .

Pamiętaj też, że możesz użyć wielu plików konfiguracyjnych Spring i możesz albo utworzyć ApplicationContext, wyświetlając listę wszystkich plików w konstruktorze (lub umieszczając je w parametrze kontekstowym dla ContextLoaderListener), albo możesz po prostu załadować główny plik konfiguracyjny, który ma instrukcje importu. Możesz zaimportować plik konfiguracyjny Spring do innego pliku konfiguracyjnego Spring, używając <import resource = "otherfile.xml" />, co jest bardzo przydatne, gdy programowo tworzysz ApplicationContext w metodzie głównej i ładujesz tylko jeden plik konfiguracyjny Spring.

W większości przypadków preferowany jest ApplicationContext, chyba że trzeba oszczędzać zasoby, np. W aplikacji mobilnej.

Nie jestem pewien, czy zależy to od formatu XML, ale jestem prawie pewien, że najczęstszymi implementacjami ApplicationContext są te XML, takie jak ClassPathXmlApplicationContext, XmlWebApplicationContext i FileSystemXmlApplicationContext. To jedyne trzy, których kiedykolwiek użyłem.

Jeśli tworzysz aplikację internetową, możesz śmiało powiedzieć, że musisz użyć XmlWebApplicationContext.

Jeśli chcesz, aby Twoja fasola wiedziała o Spring, możesz zaimplementować do tego BeanFactoryAware i / lub ApplicationContextAware, abyś mógł użyć BeanFactory lub ApplicationContext i wybrać interfejs do wdrożenia.

Różnice między BeanFactory a ApplicationContext są następujące:

1. BeanFactory używa leniwej inicjalizacji, ale ApplicationContext używa szybkiej inicjalizacji. W przypadku BeanFactory komponent bean jest tworzony podczas wywoływania metody getBeans (), ale komponent bean jest tworzony z góry w przypadku ApplicationContext podczas tworzenia obiektu ApplicationContext.
2. BeanFactory wyraźnie udostępnia obiekt zasobu za pomocą składni, ale ApplicationContext samodzielnie tworzy obiekty zasobów i zarządza nimi.
3. BeanFactory nie obsługuje internatiolizacji, ale ApplicationContext obsługuje internacjonalizację.
4. Z BeanFactory wstrzykiwanie zależności oparte na adnotacjach nie jest obsługiwane, ale wstrzykiwanie zależności oparte na adnotacjach jest obsługiwane w ApplicationContext.

Korzystanie z BeanFactory:

BeanFactory beanfactory = new XMLBeanFactory(new FileSystemResource("spring.xml"));
 Triangle triangle =(Triangle)beanFactory.getBean("triangle");

Korzystanie z ApplicationContext:

ApplicationContext context = new ClassPathXMLApplicationContext("spring.xml")
Triangle triangle =(Triangle)context.getBean("triangle");

BeanFactory i ApplicationContext to sposoby na uzyskanie fasoli z wiosennego pojemnika IOC, ale nadal istnieją pewne różnice.

BeanFactory to rzeczywisty kontener, który tworzy instancję, konfiguruje i zarządza wieloma komponentami bean. Ziarna te zazwyczaj współpracują ze sobą, a zatem mają zależności między sobą. Zależności te znajdują odzwierciedlenie w danych konfiguracyjnych używanych przez BeanFactory.

BeanFactory i ApplicationContext to interfejsy Java, a ApplicationContext rozszerza BeanFactory. Oba są konfigurowane przy użyciu plików konfiguracyjnych XML. W skrócie BeanFactory zapewnia podstawową inwersję kontroli ( IoC ) i funkcje wstrzykiwania zależności ( DI ), podczas gdy ApplicationContext zapewnia zaawansowane funkcje.

BeanFactory jest reprezentowany przez interfejs „ org.springframework.beans.factory ” Where BeanFactory, dla którego istnieje wiele implementacji.

ClassPathResource resource = new ClassPathResource("appConfig.xml");
XmlBeanFactory factory = new XmlBeanFactory(resource);

RÓŻNICA

1. BeanFactory instancja komponentu bean po wywołaniu metody getBean () , podczas gdy ApplicationContext tworzy instancję komponentu singleton bean po uruchomieniu kontenera, nie czeka na wywołanie metody getBean ().

2. BeanFactory nie zapewnia obsługi internacjonalizacji, ale ApplicationContext ją obsługuje.

3. Inną różnicą między BeanFactory a ApplicationContext jest możliwość publikowania zdarzeń w komponentach bean zarejestrowanych jako detektor.

4. Jedną z popularnych implementacji interfejsu BeanFactory jest XMLBeanFactory, a jedną z popularnych implementacji interfejsu ApplicationContext jest ClassPathXmlApplicationContext .

5. Jeśli korzystasz z automatycznego okablowania i używasz BeanFactory , musisz zarejestrować AutoWiredBeanPostProcessor za pomocą interfejsu API, który możesz skonfigurować w XML, jeśli używasz ApplicationContext . Podsumowując, BeanFactory nadaje się do testowania i do użytku nieprodukcyjnego, ale ApplicationContext ma bardziej bogatą funkcjonalność implementację kontenera i należy go faworyzować nad BeanFactory

6. BeanFactory domyślnie obsługuje Leniwe ładowanie i ApplicationContext domyślnie obsługuje Agresywne ładowanie.

Matryca funkcji fabryki fasoli a kontekst aplikacji pochodzi z dokumentów wiosennych

_{Zrzut ekranu przedstawiający funkcje BeanFacotry i ApplicationContext}

za. Jedną różnicą między fabryką fasoli a kontekstem aplikacji jest to, że poprzednia tylko instancja komponentu bean po wywołaniu metody getBean () podczas gdy ApplicationContext tworzy instancję komponentu bean Singleton po uruchomieniu kontenera, nie czeka na wywołanie getBean.

b.

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

lub

ApplicationContext context = new ClassPathXmlApplicationContext{"spring_dao.xml","spring_service.xml};

Możesz użyć jednego lub więcej plików XML w zależności od wymagań projektu. Ponieważ jestem tutaj, używam dwóch plików xml, tj. Jednego do szczegółów konfiguracji dla klas usług innych dla klas dao. Tutaj ClassPathXmlApplicationContext jest potomkiem ApplicationContext.

do. Pojemnik BeanFactory jest podstawowym pojemnikiem, może tylko tworzyć obiekty i wstrzykiwać zależności. Ale nie możemy dołączać innych usług, takich jak bezpieczeństwo, transakcje, przesyłanie wiadomości itp., Aby zapewnić wszystkie usługi, których musimy użyć ApplicationContext Container.

re. BeanFactory nie zapewnia wsparcia dla internacjonalizacji, tj. I18n, ale ApplicationContext zapewnia wsparcie dla niego.

mi. Pojemnik BeanFactory nie obsługuje funkcji automatycznego skanowania (obsługuje wstrzykiwanie zależności na podstawie adnotacji), ale obsługiwany jest kontener ApplicationContext.

fa. Pojemnik Beanfactory nie utworzy obiektu fasoli do czasu żądania. Oznacza to, że pojemnik na ziarna kawy leniwie ładuje fasolę. Podczas gdy ApplicationContext Container tworzy obiekty fasoli Singleton tylko podczas ładowania. Oznacza to, że ładowanie jest wczesne.

sol. Pojemnik na ziarna kawy obsługuje tylko dwa zakresy (singleton i prototyp) ziaren. Ale ApplicationContext Container obsługuje cały zakres komponentów bean.

Zasadniczo możemy utworzyć sprężynowy obiekt kontenerowy na dwa sposoby

1. using BeanFactory.
2. using ApplicationContext.

oba są interfejsami,

za pomocą klas implementacyjnych możemy stworzyć obiekt dla kontenera sprężynowego

dochodzić do różnic

BeanFactory:

1. Nie obsługuje wstrzykiwania zależności na podstawie adnotacji.

2. Nie obsługuje I18N.

3. Domyślnie jego obsługa Lazy ładuje.

4. nie pozwala na konfigurację wielu plików konfiguracyjnych.

np .: BeanFactory kontekst = nowy XmlBeanFactory (nowy zasób („applicationContext.xml”));

ApplicationContext

1. Obsługa iniekcji w oparciu o adnotacje. --@Autowired, @PreDestroy

2. Obsługa I18N

3. Domyślnie obsługuje agresywne ładowanie.

4. Pozwala skonfigurować wiele plików konfiguracyjnych.

np .:
ApplicationContext kontekst = nowy ClasspathXmlApplicationContext („applicationContext.xml”);

Zapoznaj się z tym dokumentem z Spring Docs:

http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/beans.html#context-introduction-ctx-vs-beanfactory

5.15.1 BeanFactory czy ApplicationContext?

Użyj ApplicationContext, chyba że masz ku temu dobry powód.

Ponieważ ApplicationContext obejmuje całą funkcjonalność BeanFactory, jest ogólnie zalecany w porównaniu z BeanFactory, z wyjątkiem kilku sytuacji, takich jak aplet, w którym zużycie pamięci może być krytyczne, a kilka dodatkowych kilobajtów może mieć znaczenie. Jednak w przypadku najbardziej typowych aplikacji i systemów dla przedsiębiorstw, ApplicationContext jest tym, czego będziesz chciał użyć. Spring 2.0 i nowsze wersje intensywnie wykorzystują punkt rozszerzenia BeanPostProcessor (aby uzyskać efekt proxy i tak dalej). Jeśli używasz tylko zwykłego BeanFactory, spora część wsparcia, takiego jak transakcje i AOP, nie wejdzie w życie, przynajmniej nie bez dodatkowych kroków z twojej strony. Ta sytuacja może być myląca, ponieważ tak naprawdę nic nie jest nie tak z konfiguracją.

ApplicationContext jest starszym bratem BeanFactory i to wszystko zapewnia BeanFactory oraz wiele innych rzeczy.

Oprócz standardowych funkcji cyklu życia org.springframework.beans.factory.BeanFactory implementacje ApplicationContext wykrywają i wywołują komponenty bean ApplicationContextAware, a także fasole ResourceLoaderAware, ApplicationEventPublisherAware i MessageSourceAware.

W scenariuszu w czasie rzeczywistym różnice między kontenerem Spring IOC Core (BeanFactory) a kontenerem Advanced J2EE (ApplicationContext) są następujące.

1. BeanFactory utworzy obiekty dla ziaren (tj. Dla klas POJO) wymienionych w pliku spring.xml ( <bean></bean>) tylko wtedy, gdy wywołasz metodę .getBean (), ale podczas gdy ApplicationContext tworzy obiekty dla wszystkich ziaren ( <bean></bean>jeśli jego zakres nie jest wyraźnie wymieniony jako „Prototyp”) skonfigurowany w pliku spring.xml podczas ładowania samego pliku spring.xml.

2. BeanFactory: (Leniwy kontener, ponieważ tworzy obiekty dla ziaren tylko wtedy, gdy jawnie wywołujesz z klasy user / main)

   /*
    * Using core Container - Lazy container - Because it creates the bean objects On-Demand
    */
   //creating a resource
   Resource r = (Resource) new ClassPathResource("com.spring.resources/spring.xml");
   //creating BeanFactory 
   BeanFactory factory=new XmlBeanFactory(r);
   
   //Getting the bean for the POJO class "HelloWorld.java"
   HelloWorld worldObj1 = (HelloWorld) factory.getBean("test");

   ApplicationContext: (Chętny pojemnik z powodu tworzenia obiektów wszystkich ziaren singletonu podczas ładowania samego pliku spring.xml)

   ApplicationContext context = new ClassPathXmlApplicationContext("com/ioc/constructorDI/resources/spring.xml");

3. Technicznie zalecane jest użycie ApplicationContext, ponieważ w aplikacjach czasu rzeczywistego obiekty komponentu bean zostaną utworzone podczas uruchamiania aplikacji na samym serwerze. Skraca to czas odpowiedzi na żądanie użytkownika, ponieważ obiekty są już dostępne do odpowiedzi.

Myślę, że warto wspomnieć, że od wiosny 3, jeśli chcesz stworzyć fabrykę, możesz również użyć @configurationadnotacji w połączeniu z odpowiednim@scope

@Configuration
public class MyFactory {

    @Bean
    @Scope("prototype")
    public MyClass create() {
        return new MyClass();
    }
}

Fabryka powinna być widoczna dla kontenera Spring przy użyciu @ComponentScanadnotacji lub konfiguracji xml

Artykuł na temat fasoli wiosennej ze strony Baeldung

używaj BeanFactory w aplikacjach innych niż WWW, ponieważ obsługuje tylko zakresy fasoli Singleton i Prototype.

Kontener ApplicationContext obsługuje wszystkie zakresy komponentu bean, dlatego należy go używać w aplikacjach internetowych.

W podsumowaniu:

ApplicationContext zawiera wszystkie funkcjonalności BeanFactory. Ogólnie zaleca się stosowanie tego pierwszego.

Istnieją pewne ograniczone sytuacje, na przykład w aplikacji mobilnej, w których zużycie pamięci może być krytyczne.

W takich scenariuszach uzasadnione może być użycie bardziej lekkiego BeanFactory . Jednak w większości aplikacji dla przedsiębiorstw ApplicationContext należy użyć .

Aby uzyskać więcej informacji, zobacz mój post na blogu:

Różnica między BeanFactory a ApplicationContext na wiosnę - blog javski od podstaw

Muszę wyjaśnić BeanFactory & ApplicationContext.

BeanFactory: BeanFactory to interfejs użytkownika root do uzyskiwania dostępu do kontenera SpringBean. Istnieje podstawowy widok klienta kontenera fasoli. Interfejs ten jest implementowany przez klasę obiektów, która przechowuje liczbę definicji komponentów bean, a każda z nich jest jednoznacznie identyfikowana przez nazwę ciągu.
W zależności od definicji komponentu Bean fabryka zwróci instancję, która może być instancją obiektu zawartego lub pojedynczą instancją współużytkowaną. Rodzaj instancji, który zostanie zwrócony, zależy od konfiguracji fabryki fasoli.
Normalnie fabryka Bean załaduje wszystkie definicje wszystkich ziaren, które są przechowywane w źródle konfiguracji, takim jak XML ... itd.

BeanFactory to najprostszy pojemnik zapewniający podstawową obsługę wstrzykiwania zależności

Kontekst aplikacji aplikacji to centralny interfejs w aplikacji wiosennej, który dostarcza informacje o konfiguracji do aplikacji. Implementuje interfejs fabryki fasoli.

Kontekst aplikacji jest zaawansowanym kontenerem, który dodaje zaawansowany poziom specyficznych dla przedsiębiorstwa funkcji, takich jak możliwość rozwiązania komunikatu tekstowego z pliku właściwości .... itd.

ApplicationContext zapewnia:

Fabryczne metody uzyskiwania dostępu do komponentów aplikacji. Dziedziczony z ListableBeanFactory. Możliwość ładowania zasobów plików w sposób ogólny. Dziedziczony z interfejsu ResourceLoader. Możliwość publikowania wydarzeń zarejestrowanym słuchaczom. Dziedziczony z interfejsu ApplicationEventPublisher. Zdolność do rozwiązywania komunikatów, wspierająca internacjonalizację. Dziedziczony z interfejsu MessageSource. Dziedziczenie z kontekstu nadrzędnego. Definicje w kontekście potomnym zawsze będą miały pierwszeństwo. Oznacza to na przykład, że pojedynczy kontekst nadrzędny może być używany przez całą aplikację internetową, podczas gdy każdy serwlet ma własny kontekst potomny, który jest niezależny od kontekstu dowolnego innego serwletu. Oprócz standardowych możliwości cyklu życia BeanFactory,