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 BeanFactory
und ApplicationContext
- welche sind unter welchen Bedingungen geeignet?
Ich verstehe, dass ApplicationContext
sich das erweitert BeanFactory
, aber wenn ich nur eine einfache Hauptmethode schreibe, brauche ich die zusätzliche Funktionalität, die sie ApplicationContext
bietet? Und genau welche zusätzlichen Funktionen bietet ApplicationContext
es?
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.
BeanFactory
wir Konstruktorparameter dynamisch übergeben, aber mit könnenApplicationContext
wir das nicht tun.FileSystemXmlApplicationContext
Bohnen geladen durch den vollen Weg.ClassPathXmlApplicationContext
Durch den KLASSENPFAD geladene BohnenXMLWebApplicationContext
undAnnotationConfigWebApplicationContext
Beans, die über den Webanwendungskontext geladen werden.AnnotationConfigApplicationContext
Laden von Spring Beans aus der Annotation-basierten Konfiguration.Beispiel:
ApplicationContext
ist der Container, der durch a initialisiertContextLoaderListener
oderContextLoaderServlet
in a definiertweb.xml
und inContextLoaderPlugin
definiert iststruts-config.xml
.Hinweis :
XmlBeanFactory
ist ab Frühjahr 3.1 zugunsten vonDefaultListableBeanFactory
und veraltetXmlBeanDefinitionReader
.quelle
Für mich ist der Hauptunterschied zu wählen
BeanFactory
überApplicationContext
scheint zu sein , dassApplicationContext
Pre-instantiate werden alle die Bohnen. Von dem Frühling docs :Vor diesem Hintergrund habe ich mich zunächst
BeanFactory
fü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 -BeanFactory
unterstützt dieclasspath
XML-Konfiguration nicht. AlsoBeanFactory
undApplicationContext
jedes 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:quelle
BeanFactory doesn't support classpath XML configuration.
Ich denke es tut: stackoverflow.com/questions/5231371/…Um die Antwort von Miguel Ping zu ergänzen, finden Sie hier einen weiteren Abschnitt aus der Dokumentation , der dies ebenfalls beantwortet:
(Veröffentlichung für zukünftige Frühlingsanfänger, die diese Frage lesen könnten)
quelle
ApplicationContext
ist bevorzugter Weg alsBeanFactory
In neuen Spring-Versionen
BeanFactory
wird durch ersetztApplicationContext
.BeanFactory
Besteht aber noch aus Gründen der AbwärtskompatibilitätApplicationContext extends BeanFactory
und hat die folgenden Vorteilequelle
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 .
quelle
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.
quelle
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.
quelle
ApplicationContext
alle Funktionen des enthältBeanFactory
, wird im Allgemeinen empfohlen, ihn bevorzugt zu verwendenBeanFactory
, mit Ausnahme einiger begrenzter Situationen, z. B. in einemApplet
Fall, in dem der Speicherverbrauch kritisch sein kann und einige zusätzliche Kilobyte Einen Unterschied machen. Für die meisten "typischen" Unternehmensanwendungen und -systeme ist dies jedoch das,ApplicationContext
was Sie verwenden möchten.Der Unterschied zwischen BeanFactory und ApplicationContext ist folgender:
Verwenden von BeanFactory:
Verwenden von ApplicationContext:
quelle
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.
UNTERSCHIED
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.
BeanFactory bietet keine Unterstützung für die Internationalisierung, aber ApplicationContext bietet Unterstützung dafür.
Ein weiterer Unterschied zwischen BeanFactory und ApplicationContext besteht in der Möglichkeit, Ereignisse in Beans zu veröffentlichen, die als Listener registriert sind.
Eine der beliebtesten Implementierungen der BeanFactory- Schnittstelle ist XMLBeanFactory, während eine der beliebtesten Implementierungen von ApplicationContext- Schnittstelle ClassPathXmlApplicationContext ist .
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
BeanFactory unterstützt standardmäßig Lazy Loading und ApplicationContext unterstützt standardmäßig Aggresive Loading.
quelle
Funktionsmatrix von Bean Factory vs. Anwendungskontext aus Frühjahrsdokumenten
Screenshot der Funktionen von BeanFacotry und ApplicationContext
quelle
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.
oder
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.
quelle
Grundsätzlich können wir Federbehälterobjekte auf zwei Arten erstellen
beide sind die Schnittstellen,
Mit Implementierungsklassen können wir Objekte für Spring Container erstellen
zu den Unterschieden kommen
BeanFactory:
Unterstützt die auf Anmerkungen basierende Abhängigkeitsinjektion nicht.
Unterstützt I18N nicht.
Standardmäßig unterstützt es Lazy Loading.
Die Konfiguration mehrerer Konfigurationsdateien ist nicht möglich.
Beispiel: BeanFactory context = new XmlBeanFactory (neue Ressource ("applicationContext.xml"));
ApplicationContext
Unterstützung Annotation-basierte Abhängigkeit Injection.-@Autowired, @PreDestroy
Unterstützung I18N
Standardmäßig wird aggressives Laden unterstützt.
Es ermöglicht die Konfiguration mehrerer Konfigurationsdateien.
Beispiel:
ApplicationContext context = new ClasspathXmlApplicationContext ("applicationContext.xml");
quelle
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.
quelle
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.
quelle
In einem Echtzeitszenario ist der Unterschied zwischen dem Spring IOC Core-Container (BeanFactory) und dem Advanced J2EE-Container (ApplicationContext) wie folgt.
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.BeanFactory: (Lazy Container, da die Objekte für die Beans nur erstellt werden, wenn Sie explizit von der Benutzer- / Hauptklasse aufrufen.)
ApplicationContext: (Eifriger Container, da beim Laden der Datei spring.xml selbst die Objekte aller Singleton-Beans erstellt wurden)
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.
quelle
Ich denke, es ist erwähnenswert, dass Sie seit Frühjahr 3, wenn Sie eine Fabrik erstellen möchten, auch die
@configuration
Anmerkung in Kombination mit der richtigen verwenden können@scope
Ihre Factory sollte für Spring Container mithilfe der
@ComponentScan
Annotation- oder XML-Konfiguration sichtbar seinSpring Bean Scopes Artikel von Baeldung Site
quelle
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.
quelle
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
quelle
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
quelle