BeanFactory vs ApplicationContext

Ich bin ziemlich neu im Spring Framework, habe damit herumgespielt und ein paar Beispiel-Apps zusammengestellt, um Spring MVC für die Verwendung in einem bevorstehenden Unternehmensprojekt zu evaluieren. Bisher gefällt mir das, was ich in Spring MVC sehe, sehr gut, es scheint sehr einfach zu bedienen zu sein und ermutigt Sie, Kurse zu schreiben, die sehr einheitstestfreundlich sind.

Nur als Übung schreibe ich eine Hauptmethode für eines meiner Beispiel- / Testprojekte. Eine Sache, über die ich unklar bin, sind die genauen Unterschiede zwischen BeanFactoryund ApplicationContext- welche sind unter welchen Bedingungen geeignet?

Ich verstehe, dass ApplicationContextsich das erweitert BeanFactory, aber wenn ich nur eine einfache Hauptmethode schreibe, brauche ich die zusätzliche Funktionalität, die sie ApplicationContextbietet? Und genau welche zusätzlichen Funktionen bietet ApplicationContextes?

Gibt es neben der Antwort "Was soll ich in einer main () -Methode verwenden?" Standards oder Richtlinien für die Implementierung, die ich in einem solchen Szenario verwenden soll? Sollte meine main () -Methode so geschrieben werden, dass sie von der Bean- / Anwendungskonfiguration im XML-Format abhängt - ist das eine sichere Annahme, oder sperre ich den Benutzer an etwas Bestimmtes?

Und ändert sich diese Antwort in einer Webumgebung - wenn eine meiner Klassen Spring kennen muss, ist es wahrscheinlicher, dass sie benötigt wird ApplicationContext?

Vielen Dank für jede Hilfe. Ich weiß, dass viele dieser Fragen wahrscheinlich im Referenzhandbuch beantwortet werden, aber es fällt mir schwer, eine klare Aufschlüsselung dieser beiden Schnittstellen und ihrer Vor- und Nachteile zu finden, ohne das Handbuch mit einem feinen Kamm durchzulesen.

Die Frühlingsdokumente sind in dieser Hinsicht großartig: 3.8.1. BeanFactory oder ApplicationContext?. Sie haben eine Tabelle mit einem Vergleich, ich werde einen Ausschnitt posten:

Bohnenfabrik

• Bean Instanziierung / Verkabelung

Anwendungskontext

• Bean Instanziierung / Verkabelung
• Automatische BeanPostProcessor-Registrierung
• Automatische BeanFactoryPostProcessor-Registrierung
• Bequemer MessageSource-Zugriff (für i18n)
• ApplicationEvent-Veröffentlichung

Wenn Sie also einen der auf der Seite Anwendungskontext dargestellten Punkte benötigen, sollten Sie ApplicationContext verwenden.

Spring bietet zwei Arten von IOC-Containern, einen XMLBeanFactoryund einen 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 Bohnen geladen durch den vollen Weg.
• ClassPathXmlApplicationContext Durch den KLASSENPFAD geladene Bohnen
• XMLWebApplicationContext und AnnotationConfigWebApplicationContext Beans, die über den Webanwendungskontext geladen werden.
• AnnotationConfigApplicationContext Laden von Spring Beans aus der Annotation-basierten Konfiguration.

Beispiel:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

• ApplicationContextist der Container, der durch a initialisiert ContextLoaderListeneroder ContextLoaderServletin a definiert web.xmlund in ContextLoaderPlugindefiniert ist struts-config.xml.

Hinweis : XmlBeanFactoryist ab Frühjahr 3.1 zugunsten von DefaultListableBeanFactoryund veraltetXmlBeanDefinitionReader .

Für mich ist der Hauptunterschied zu wählen BeanFactoryüber ApplicationContextscheint zu sein , dass ApplicationContextPre-instantiate werden alle die Bohnen. Von dem Frühling docs :

Spring legt Eigenschaften fest und löst Abhängigkeiten so spät wie möglich auf, wenn die Bean tatsächlich erstellt wird. Dies bedeutet, dass ein korrekt geladener Spring-Container später eine Ausnahme generieren kann, wenn Sie ein Objekt anfordern, wenn beim Erstellen dieses Objekts oder einer seiner Abhängigkeiten ein Problem auftritt. Beispielsweise löst die Bean eine Ausnahme aufgrund einer fehlenden oder ungültigen Eigenschaft aus. Diese möglicherweise verzögerte Sichtbarkeit einiger Konfigurationsprobleme ist der Grund, warum ApplicationContext-Implementierungen Singleton-Beans standardmäßig vorinstanziieren. Auf Kosten einiger Zeit und Speicher im Voraus, um diese Beans zu erstellen, bevor sie tatsächlich benötigt werden, stellen Sie Konfigurationsprobleme fest, wenn der ApplicationContext erstellt wird, nicht später. Sie können dieses Standardverhalten weiterhin überschreiben, sodass Singleton-Beans nicht vorinstanziiert, sondern verzögert initialisiert werden.

Vor diesem Hintergrund habe ich mich zunächst BeanFactoryfür die Verwendung in Integrations- / Leistungstests entschieden, da ich nicht die gesamte Anwendung zum Testen isolierter Beans laden wollte. Allerdings - und jemand korrigiert mich, wenn ich falsch liege - BeanFactoryunterstützt die classpathXML-Konfiguration nicht. Also BeanFactoryund ApplicationContextjedes bietet eine entscheidende Funktion, die ich wollte, aber beides nicht.

Soweit ich das beurteilen kann, findet der Hinweis in der Dokumentation zum Überschreiben des Standardinstanziierungsverhaltens in der Konfiguration statt und ist pro Bean, sodass ich nicht einfach das Attribut "lazy-init" in der XML-Datei festlegen kann oder bin Es blieb stecken, eine Version für Testzwecke und eine für die Bereitstellung beizubehalten.

Am Ende habe ich mich darauf ausgedehnt ClassPathXmlApplicationContext, Bohnen für Tests wie diese träge zu laden:

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);
        }
    }

}

Um die Antwort von Miguel Ping zu ergänzen, finden Sie hier einen weiteren Abschnitt aus der Dokumentation , der dies ebenfalls beantwortet:

Kurzversion: Verwenden Sie einen ApplicationContext, es sei denn, Sie haben einen wirklich guten Grund, dies nicht zu tun. Für diejenigen unter Ihnen, die etwas mehr Tiefe in Bezug auf das "aber warum" der obigen Empfehlung suchen, lesen Sie weiter.

(Veröffentlichung für zukünftige Frühlingsanfänger, die diese Frage lesen könnten)

1. ApplicationContext ist bevorzugter Weg als BeanFactory

2. In neuen Spring-Versionen BeanFactorywird durch ersetzt ApplicationContext. BeanFactoryBesteht aber noch aus Gründen der Abwärtskompatibilität

3. ApplicationContext extends BeanFactory und hat die folgenden Vorteile
   • Es unterstützt die Internationalisierung von Textnachrichten
   • Es unterstützt die Veröffentlichung von Ereignissen für die registrierten Listener
   • Zugriff auf Ressourcen wie URLs und Dateien

ApplicationContext: Lädt Spring Beans, die in der Spring Configuration-Datei konfiguriert sind, und verwaltet den Lebenszyklus der Spring Beans als und WENN CONTAINER STARTS. Es wird nicht gewartet, bis getBean ("springbeanref") aufgerufen wird.

BeanFactory Lädt Spring Beans, die in der Spring Configuration-Datei konfiguriert sind, und verwaltet den Lebenszyklus der Spring Bean, wenn wir getBean ("springbeanref") aufrufen. Also, wenn wir getBean ("springbeanref") zum Zeitpunkt des Starts des Spring Bean-Lebenszyklus aufrufen .

Ich denke, es ist besser, immer ApplicationContext zu verwenden, es sei denn, Sie befinden sich in einer mobilen Umgebung, wie bereits jemand anderes gesagt hat. ApplicationContext bietet mehr Funktionen und Sie möchten auf jeden Fall PostProcessors wie RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor und CommonAnnotationBeanPostProcessor verwenden, mit denen Sie Ihre Spring-Konfigurationsdateien vereinfachen können. Sie können auch Anmerkungen wie @Required, @PostCon verwenden .

Selbst wenn Sie nicht alle Inhalte verwenden, die ApplicationContext bietet, ist es besser, sie trotzdem zu verwenden, und später, wenn Sie sich dafür entscheiden, einige Ressourcen wie Nachrichten oder Postprozessoren oder das andere Schema zum Hinzufügen von Transaktionshinweisen und dergleichen zu verwenden hat bereits einen ApplicationContext und muss keinen Code ändern.

Wenn Sie eine eigenständige App schreiben, laden Sie den ApplicationContext mithilfe eines ClassPathXmlApplicationContext in Ihre Hauptmethode, rufen Sie die Haupt-Bean ab und rufen Sie deren run () (oder eine andere Methode) auf, um Ihre App zu starten. Wenn Sie eine Webanwendung schreiben, verwenden Sie den ContextLoaderListener in web.xml, damit der ApplicationContext erstellt wird. Sie können ihn später aus dem ServletContext abrufen, unabhängig davon, ob Sie JSP, JSF, JSTL, Struts, Tapestry usw. Verwenden .

Denken Sie auch daran, dass Sie mehrere Spring-Konfigurationsdateien verwenden können und entweder den ApplicationContext erstellen können, indem Sie alle Dateien im Konstruktor auflisten (oder sie im Kontextparameter für den ContextLoaderListener auflisten), oder einfach eine Hauptkonfigurationsdatei laden, die über Folgendes verfügt Anweisungen importieren. Sie können eine Spring-Konfigurationsdatei mithilfe von <import resource = "otherfile.xml" /> in eine andere Spring-Konfigurationsdatei importieren. Dies ist sehr nützlich, wenn Sie den ApplicationContext in der Hauptmethode programmgesteuert erstellen und nur eine Spring-Konfigurationsdatei laden.

Zum größten Teil wird ApplicationContext bevorzugt, es sei denn, Sie müssen Ressourcen sparen, wie bei einer mobilen Anwendung.

Ich bin mir nicht sicher, ob ich vom XML-Format abhängig bin, aber ich bin mir ziemlich sicher, dass die häufigsten Implementierungen von ApplicationContext XML-Implementierungen wie ClassPathXmlApplicationContext, XmlWebApplicationContext und FileSystemXmlApplicationContext sind. Das sind die einzigen drei, die ich jemals benutzt habe.

Wenn Sie eine Web-App entwickeln, können Sie mit Sicherheit sagen, dass Sie XmlWebApplicationContext verwenden müssen.

Wenn Sie möchten, dass Ihre Beans Spring kennen, können Sie BeanFactoryAware und / oder ApplicationContextAware dafür implementieren, sodass Sie entweder BeanFactory oder ApplicationContext verwenden und auswählen können, welche Schnittstelle implementiert werden soll.

Der Unterschied zwischen BeanFactory und ApplicationContext ist folgender:

1. BeanFactory verwendet eine verzögerte Initialisierung , ApplicationContext jedoch eine eifrige Initialisierung. Im Fall von BeanFactory wird Bean erstellt, wenn Sie die Methode getBeans () aufrufen. Bei ApplicationContext wird Bean jedoch im Voraus erstellt, wenn das ApplicationContext-Objekt erstellt wird.
2. BeanFactory stellt ein Ressourcenobjekt explizit mithilfe der Syntax bereit , ApplicationContext erstellt und verwaltet Ressourcenobjekte jedoch selbstständig .
3. BeanFactory unterstützt aber keine Internatiolisierung ApplicationContext unterstützt die Internationalisierung.
4. Mit BeanFactory wird die annotationsbasierte Abhängigkeitsinjektion nicht unterstützt, aber die annotationsbasierte Abhängigkeitsinjektion wird in ApplicationContext unterstützt.

Verwenden von BeanFactory:

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

Verwenden von ApplicationContext:

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

BeanFactory und ApplicationContext sind beide Möglichkeiten, Beans aus Ihrem Spring IOC- Container zu holen, aber es gibt immer noch einige Unterschiede.

BeanFactory ist der eigentliche Container, der eine Reihe von Beans instanziiert, konfiguriert und verwaltet. Diese Beans arbeiten normalerweise zusammen und haben daher Abhängigkeiten untereinander. Diese Abhängigkeiten spiegeln sich in den Konfigurationsdaten wider, die von der BeanFactory verwendet werden.

BeanFactory und ApplicationContext sind beide Java-Schnittstellen und ApplicationContext erweitert BeanFactory. Beide werden mithilfe von XML-Konfigurationsdateien konfiguriert. Kurz gesagt, BeanFactory bietet grundlegende Funktionen für Inversion of Control ( IoC ) und Dependency Injection ( DI ), während ApplicationContext erweiterte Funktionen bietet Funktionen bietet.

Eine BeanFactory wird durch die Schnittstelle " org.springframework.beans.factory " dargestellt, wobei BeanFactory, für die es mehrere Implementierungen gibt.

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

UNTERSCHIED

1. BeanFactory instanziiert Bean, wenn Sie die Methode getBean () aufrufen , während ApplicationContext Singleton Bean instanziiert, wenn der Container gestartet wird. Es wartet nicht darauf, dass getBean () aufgerufen wird.

2. BeanFactory bietet keine Unterstützung für die Internationalisierung, aber ApplicationContext bietet Unterstützung dafür.

3. Ein weiterer Unterschied zwischen BeanFactory und ApplicationContext besteht in der Möglichkeit, Ereignisse in Beans zu veröffentlichen, die als Listener registriert sind.

4. Eine der beliebtesten Implementierungen der BeanFactory- Schnittstelle ist XMLBeanFactory, während eine der beliebtesten Implementierungen von ApplicationContext- Schnittstelle ClassPathXmlApplicationContext ist .

5. Wenn Sie die automatische Verkabelung und BeanFactory verwenden , müssen Sie AutoWiredBeanPostProcessor mithilfe der API registrieren , die Sie in XML konfigurieren können, wenn Sie ApplicationContext verwenden . Zusammenfassend ist BeanFactory zum Testen und nicht produktiven Gebrauch aber OK ApplicationContext jedoch eine funktionsreichere Containerimplementierung bietet und gegenüber BeanFactory bevorzugt werden sollte

6. BeanFactory unterstützt standardmäßig Lazy Loading und ApplicationContext unterstützt standardmäßig Aggresive Loading.

Funktionsmatrix von Bean Factory vs. Anwendungskontext aus Frühjahrsdokumenten

_{Screenshot der Funktionen von BeanFacotry und ApplicationContext}

ein. Ein Unterschied zwischen Bean Factory und Anwendungskontext besteht darin, dass erstere Bean nur beim Aufrufen der Methode getBean () instanziieren, während ApplicationContext Singleton-Bean beim Starten des Containers instanziiert. Es wartet nicht auf den Aufruf von getBean.

b.

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

oder

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

Sie können je nach Projektanforderung eine oder mehrere XML-Dateien verwenden. Da ich hier zwei XML-Dateien verwende, dh eine für Konfigurationsdetails für Serviceklassen, andere für Dao-Klassen. Hier ist ClassPathXmlApplicationContext ein untergeordnetes Element von ApplicationContext.

c. BeanFactory Container ist ein Basiscontainer, der nur Objekte erstellen und Abhängigkeiten einfügen kann. Wir können jedoch keine anderen Dienste wie Sicherheit, Transaktion, Messaging usw. anhängen, um alle Dienste bereitzustellen, die für die Verwendung von ApplicationContext Container erforderlich sind.

d. BeanFactory bietet keine Unterstützung für die Internationalisierung, dh i18n, aber ApplicationContext bietet Unterstützung dafür.

e. BeanFactory Container unterstützt die Funktion von AutoScanning (Support Annotation Based Dependency Injection) nicht, ApplicationContext Container jedoch.

f. Beanfactory Container erstellt erst zur Anforderungszeit ein Bean-Objekt. Dies bedeutet, dass Beanfactory Container träge Bohnen lädt. Während ApplicationContext Container nur zum Zeitpunkt des Ladens Objekte der Singleton-Bean erstellt. Dies bedeutet, dass frühzeitig geladen wird.

G. Beanfactory Container unterstützt nur zwei Bereiche (Singleton & Prototyp) der Beans. ApplicationContext Container unterstützt jedoch den gesamten Beans-Bereich.

Grundsätzlich können wir Federbehälterobjekte auf zwei Arten erstellen

1. mit BeanFactory.
2. mit ApplicationContext.

beide sind die Schnittstellen,

Mit Implementierungsklassen können wir Objekte für Spring Container erstellen

zu den Unterschieden kommen

BeanFactory:

1. Unterstützt die auf Anmerkungen basierende Abhängigkeitsinjektion nicht.

2. Unterstützt I18N nicht.

3. Standardmäßig unterstützt es Lazy Loading.

4. Die Konfiguration mehrerer Konfigurationsdateien ist nicht möglich.

Beispiel: BeanFactory context = new XmlBeanFactory (neue Ressource ("applicationContext.xml"));

ApplicationContext

1. Unterstützung Annotation-basierte Abhängigkeit Injection.-@Autowired, @PreDestroy

2. Unterstützung I18N

3. Standardmäßig wird aggressives Laden unterstützt.

4. Es ermöglicht die Konfiguration mehrerer Konfigurationsdateien.

Beispiel:
ApplicationContext context = new ClasspathXmlApplicationContext ("applicationContext.xml");

Verweisen Sie auf dieses Dokument aus 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 oder ApplicationContext?

Verwenden Sie einen ApplicationContext, es sei denn, Sie haben einen guten Grund, dies nicht zu tun.

Da der ApplicationContext alle Funktionen der BeanFactory enthält, wird er im Allgemeinen gegenüber der BeanFactory empfohlen, mit Ausnahme einiger Situationen, z. B. in einem Applet, in denen der Speicherverbrauch kritisch sein kann und einige zusätzliche Kilobyte einen Unterschied machen können. Für die meisten typischen Unternehmensanwendungen und -systeme ist der ApplicationContext jedoch das, was Sie verwenden möchten. Spring 2.0 und höher verwendet den BeanPostProcessor-Erweiterungspunkt stark (um das Proxying usw. zu bewirken). Wenn Sie nur eine einfache BeanFactory verwenden, wird eine angemessene Menge an Unterstützung wie Transaktionen und AOP nicht wirksam, zumindest nicht ohne zusätzliche Schritte von Ihrer Seite. Diese Situation kann verwirrend sein, da an der Konfiguration nichts falsch ist.

ApplicationContext ist ein großer Bruder von BeanFactory und dies alles, was BeanFactory bietet, sowie viele andere Dinge.

Zusätzlich zu den Standardfunktionen für den Lebenszyklus von org.springframework.beans.factory.BeanFactory erkennen ApplicationContext-Implementierungen ApplicationContextAware-Beans sowie ResourceLoaderAware-, ApplicationEventPublisherAware- und MessageSourceAware-Beans und rufen sie auf.

In einem Echtzeitszenario ist der Unterschied zwischen dem Spring IOC Core-Container (BeanFactory) und dem Advanced J2EE-Container (ApplicationContext) wie folgt.

1. BeanFactory erstellt nur dann Objekte für die in der Datei spring.xml () genannten Beans (dh für POJO-Klassen), <bean></bean>wenn Sie die Methode .getBean () aufrufen. ApplicationContext erstellt jedoch die Objekte für alle Beans ( <bean></bean>sofern der Gültigkeitsbereich dies nicht ist) explizit als "Prototyp" bezeichnet) in der Datei spring.xml konfiguriert, während die Datei spring.xml selbst geladen wird.

2. BeanFactory: (Lazy Container, da die Objekte für die Beans nur erstellt werden, wenn Sie explizit von der Benutzer- / Hauptklasse aufrufen.)

   /*
    * 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: (Eifriger Container, da beim Laden der Datei spring.xml selbst die Objekte aller Singleton-Beans erstellt wurden)

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

3. Technisch wird die Verwendung von ApplicationContext empfohlen, da in Echtzeitanwendungen die Bean-Objekte erstellt werden, während die Anwendung auf dem Server selbst gestartet wird. Dies reduziert die Antwortzeit für die Benutzeranforderung, da die Objekte bereits zum Antworten verfügbar sind.

Ich denke, es ist erwähnenswert, dass Sie seit Frühjahr 3, wenn Sie eine Fabrik erstellen möchten, auch die @configurationAnmerkung in Kombination mit der richtigen verwenden können@scope

@Configuration
public class MyFactory {

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

Ihre Factory sollte für Spring Container mithilfe der @ComponentScanAnnotation- oder XML-Konfiguration sichtbar sein

Spring Bean Scopes Artikel von Baeldung Site

Verwenden Sie BeanFactory für Nicht-Webanwendungen, da nur Singleton- und Prototype-Bean-Bereiche unterstützt werden.

Während der ApplicationContext-Container alle Bean-Bereiche unterstützt, sollten Sie ihn für Webanwendungen verwenden.

Zusammenfassend:

Der ApplicationContext enthält alle Funktionen der BeanFactory. Es wird allgemein empfohlen, die erstere zu verwenden.

Es gibt einige eingeschränkte Situationen, z. B. in einer mobilen Anwendung, in denen der Speicherverbrauch kritisch sein kann.

In diesen Szenarien kann es gerechtfertigt sein, die leichtere BeanFactory zu verwenden . In den meisten Unternehmensanwendungen jedoch der ApplicationContext jedoch das, was Sie verwenden möchten.

Weitere Informationen finden Sie in meinem Blogbeitrag:

Unterschied zwischen BeanFactory und ApplicationContext im Frühjahr - Der Java Spring Blog aus den Grundlagen

Ich muss den BeanFactory & ApplicationContext erklären.

BeanFactory: BeanFactory ist die Root-Schnittstelle für den Zugriff auf den SpringBean-Container. Es gibt eine grundlegende Client-Ansicht eines Bean-Containers. Diese Schnittstelle wird von der Objektklasse implementiert, die die Anzahl der Beans-Definitionen enthält, und jede wird eindeutig durch den String-Namen identifiziert.
Abhängig von der Bean-Definition gibt die Factory die Instanz zurück, dass die Instanz die Instanz des enthaltenen Objekts oder eine einzelne gemeinsam genutzte Instanz sein kann. Welcher Instanztyp zurückgegeben wird, hängt von der Konfiguration der Bean Factory ab.
Normalerweise lädt Bean Factory die gesamte Bean-Definition, die in der Konfigurationsquelle wie XML ... usw. Gespeichert ist.

BeanFactory ist ein einfachster Container, der die grundlegende Unterstützung für Dependency Injection bietet

Anwendungskontext Der Anwendungskontext ist eine zentrale Schnittstelle in der Frühjahrsanwendung, die der Anwendung die Konfigurationsinformationen bereitstellt. Es implementiert die Bean Factory-Schnittstelle.

Der Anwendungskontext ist ein Erweiterungscontainer, der eine erweiterte Ebene unternehmensspezifischer Funktionen bietet, z. B. die Möglichkeit, die Textnachricht aus der Eigenschaftendatei aufzulösen

Ein ApplicationContext bietet:

Bean Factory-Methoden für den Zugriff auf Anwendungskomponenten. Von ListableBeanFactory geerbt. Die Möglichkeit, Dateiressourcen generisch zu laden. Von der ResourceLoader-Schnittstelle geerbt. Die Möglichkeit, Ereignisse für registrierte Listener zu veröffentlichen. Von der ApplicationEventPublisher-Oberfläche geerbt. Die Fähigkeit, Nachrichten aufzulösen und die Internationalisierung zu unterstützen. Von der MessageSource-Schnittstelle geerbt. Vererbung aus einem übergeordneten Kontext. Definitionen in einem Nachkommenkontext haben immer Vorrang. Dies bedeutet beispielsweise, dass ein einzelner übergeordneter Kontext von einer gesamten Webanwendung verwendet werden kann, während jedes Servlet einen eigenen untergeordneten Kontext hat, der von dem eines anderen Servlets unabhängig ist. Zusätzlich zu den Standardfunktionen des BeanFactory-Lebenszyklus bietet