BeanFactory vs Application

https://stackoverflow.com/questions/243385

04-07-2019
|

Frage

für die Zwecke Apps zusammen auszuwerten Spring MVC für den Einsatz in einer kommenden Gesellschaft Projekt

Ich bin ziemlich neu auf dem Spring Framework, ich habe mit ihm gespielt herum und ein paar Proben setzen. Bisher Ich mag, was ich in Spring MVC zu sehen, scheint sehr einfach zu bedienen und fordert Sie dazu auf Klassen zu schreiben, die sehr Unit-Test freundlich sind.

Just als eine Übung, ich bin eine Hauptmethode für eine meiner Probe / Testprojekte zu schreiben. Eine Sache, die ich nicht klar bin, ist, die genauen Unterschiede zwischen BeanFactory und ApplicationContext - was unter welchen Bedingungen der Verwendung geeignet ist,

Ich verstehe, dass ApplicationContext BeanFactory erstreckt, aber wenn ich eine einfache Methode main nur ich schreibe, muss ich die zusätzliche Funktionalität, die ApplicationContext bietet? Und genau, welche Art von zusätzlichen Funktionen bietet ApplicationContext bieten?

Zusätzlich zu beantworten „was soll ich in einer main () Methode verwendet werden“, gibt es irgendwelche Normen oder Richtlinien, soweit die die Umsetzung ich in einem solchen Szenario verwenden sollte? Sollte meine Methode main () geschrieben wird auf der Bohne / Anwendungskonfiguration abzuhängen im XML-Format zu sein - ist, dass eine sichere Annahme, oder bin ich Verriegelungs den Benutzer in etwas Bestimmtes

Und hat diese Antwort Änderung in einer Web-Umgebung - wenn überhaupt meine Klassen bewusst Frühling sein müssen, sind sie eher ApplicationContext braucht

Vielen Dank für jede Hilfe. Ich weiß, dass viele dieser Fragen wahrscheinlich in der Referenz-Handbuch beantwortet werden, aber ich habe eine harte Zeit, um eine klare Aufteilung dieser beiden Schnittstellen und die Vor- / Nachteile der einzelnen zu finden, ohne mit einem feinen Kamm Zahn durch das Handbuch zu lesen.

Lösung

Die Feder docs ist groß, auf diese: 3.8.1. BeanFactory oder Application? . Sie haben eine Tabelle mit einem Vergleich, ich werde einen Ausschnitt schreiben:

Bean-Fabrik

Bean Instanziierung / Verdrahtung

Anwendungskontext

Bean Instanziierung / Verdrahtung
Automatische BeanPostProcessor Registrierung
Automatische BeanFactoryPostProcessor Registrierung
Convenient Messagezugang (i18n)
ApplicationEvent Veröffentlichung

Also, wenn Sie eines der Punkte müssen auf der Anwendungskontext Seite präsentiert, sollten Sie Application verwenden.

Andere Tipps

Für mich ist der primäre Unterschied BeanFactory über ApplicationContext zu wählen scheint, dass ApplicationContext zu sein werden alle die Bohnen vorge instanziiert. Aus der Frühling docs :

Frühling legt Eigenschaften und löst Abhängigkeiten so spät wie möglich, wenn die Bohne tatsächlich erstellt wird. Dies bedeutet, dass ein Federbehälter, der später richtig geladen hat, kann eine Ausnahme generieren, wenn Sie ein Objekt anfordern, wenn es ein Problem gibt, das Objekt oder eine ihrer Abhängigkeiten zu schaffen. Zum Beispiel wirft die Bohne eine Ausnahme als Folge eines fehlenden oder ungültigen Eigenschaft. Diese möglicherweise verzögert Sichtbarkeit einiger Konfigurationsprobleme Deshalb Application Implementierungen standardmäßig vorge instantiate Singletons Bohnen. Auf Kosten von etwas im Voraus Zeit und Speicher diese Bohnen zu erstellen, bevor sie tatsächlich benötigt werden, entdecken Sie Konfigurationsprobleme, wenn die Application erstellt wird, nicht später. Sie können immer noch dieses Standardverhalten außer Kraft setzen, so dass Singletons Bohnen werden faul initialisieren, anstatt vorab instanziert werden.

Diese Gegeben, entschied ich mich zunächst BeanFactory für den Einsatz in Tests Integration / Leistung, da ich nicht den Zweck zu testen Bohnen isoliert die gesamte Anwendung laden wollte. Allerdings - und korrigieren Sie mich jemand, wenn ich falsch - BeanFactory nicht classpath XML-Konfiguration unterstützen. So BeanFactory und ApplicationContext jeweils eine entscheidende Eigenschaft, die ich wollte, aber auch nicht beide.

In der Nähe, wie ich sagen kann, ist die Notiz in der Dokumentation über zwingenden Standard Instanziierungsverhalten erfolgt in der Konfiguration, und es ist pro-Bohne, also kann ich nicht nur das „lazy-init“ Attribut in der XML-Datei festgelegt oder ich bin fest eine Version davon für Test und eine für den Einsatz zu halten.

Was ich am Ende tut ClassPathXmlApplicationContext wurde erstreckt Bohnen in Tests für den Einsatz zu faul lädt etwa so:

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

}

Frühling bietet zwei Arten von IOC-Container, ist XMLBeanFactory und andere 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 Beans geladen durch den vollständigen Pfad.
ClassPathXmlApplicationContext Beans geladen durch die CLASSPATH
XMLWebApplicationContext und AnnotationConfigWebApplicationContext Bohnen über den Web-Anwendungskontext geladen.
AnnotationConfigApplicationContext Laden Spring-Beans von Annotation-basierte Konfiguration.

Beispiel:

  ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

ApplicationContext ist der Behälter durch eine ContextLoaderListener oder ContextLoaderServlet in einem web.xml und ContextLoaderPlugin in struts-config.xml definiert definiert initialisiert.

Hinweis : XmlBeanFactory ist veraltet ab Frühjahr 3.1 für DefaultListableBeanFactory und XmlBeanDefinitionReader.

auf Hinzufügen, was Miguel Ping beantwortet, hier ist ein weiterer Abschnitt der Dokumentation , dass dies auch antwortet:

Kurzversion: Verwenden Sie einen Application, wenn Sie einen wirklich guten Grund haben, dies nicht zu tun. Für diejenigen von Ihnen, die für etwas mehr Tiefe in Bezug auf das suchen ", aber warum der oben genannten Empfehlung, lesen Sie weiter.

(dies für zukünftigen Frühling Novizen Posting, die diese Frage lesen können)

ApplicationContext ist mehr bevorzugte Art und Weise als BeanFactory
In neuen Frühjahr Versionen BeanFactory mit ApplicationContext ersetzt wird. Aber noch BeanFactory existiert für Rückwärtskompatibilität
ApplicationContext extends BeanFactory und hat folgende Vorteile
- unterstützt Internationalisierung für Textnachrichten
- it Veranstaltung Veröffentlichung an die registrierten Hörer unterstützt
- Zugriff auf die Ressourcen wie URLs und Dateien

Ich denke, es ist besser, immer Application zu verwenden, es sei denn, Sie in einer mobilen Umgebung sind wie schon jemand anderes gesagt hat. Application hat mehr Funktionalität und Sie wollen auf jeden Fall die Postprozessoren verwenden, wie RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor und CommonAnnotationBeanPostProcessor, die Sie Ihre Spring-Konfigurationsdateien vereinfachen helfen, und Sie können Anmerkungen wie @Required, verwenden @PostConstruct, @Resource, etc in Ihre Bohnen .

Auch wenn Sie all Sachen Application keine Angebote nutzen, ist es besser, es zu benutzen sowieso, und dann später, wenn Sie einige Ressourcen Sachen wie Nachrichten oder Postprozessoren oder anderes Schema entscheiden zu verwenden, um Transaktions Ratschläge hinzufügen und so, werden Sie bereits ein Application haben und keinen Code ändern müssen.

Wenn Sie eine Standalone-Anwendung zu schreiben, die in Application Ihrer Hauptmethode laden, einen ClassPathXmlApplicationContext verwenden, und den Haupt-Bean erhalten und rief seinen run () (oder was auch immer Methode) Ihre Anwendung zu starten. Wenn Sie einen Web-App schreiben, die Context in web.xml verwenden, so dass es die Application erstellt und Sie können es später aus dem ServletContext erhalten, und zwar unabhängig davon, ob Sie mit JSP, JSF, JSTL, Streben, Tapisserie, usw. .

Beachten Sie auch, Sie mehrere Spring-Konfigurationsdateien verwenden können, und Sie können entweder die Application erstellen, indem Sie im Konstruktor alle Dateien Auflistung (oder sie im Kontext-param für die Context Listing), oder Sie können nur eine Haupt-Konfigurations laden Datei, die Import-Anweisungen hat. Sie können mit eine Spring-Konfigurationsdatei in einer anderen Spring-Konfigurationsdatei importieren, die sehr nützlich ist, wenn Sie programmatisch die Application im Hauptverfahren und Last nur ein Feder-Konfigurationsdatei erstellen.

Application: Es lädt Frühling Bohnen im Frühjahr Konfigurationsdatei konfiguriert und verwaltet den gesamten Lebenszyklus der Feder Bohne wie und wann CONTAINER STARTS.It erst getBean ( „springbeanref“) warten aufgerufen wird.

BeanFactory Es lädt Frühling Bohnen im Frühjahr Konfigurationsdatei konfiguriert, verwaltet den gesamten Lebenszyklus der Feder Bohne, wenn wir die getBean ( „springbeanref“) .So nennen, wenn wir nennen das getBean ( „springbeanref“) zum Zeitpunkt des Frühling Bohne Lebenszyklus beginnt.

Zum größten Teil wird Application bevorzugt, es sei denn Sie brauchen Ressourcen zu sparen, wie auf einer mobilen Anwendung.

Ich bin etwa in Abhängigkeit von XML-Format nicht sicher, aber ich bin mir ziemlich sicher, dass die am häufigsten verwendeten Implementierungen von Application die XML diejenigen sind wie ClassPathXmlApplicationContext, XmlWebApplicationContext und FileSystemXmlApplicationContext. Das sind die einzigen drei, die ich je benutzt habe.

Wenn ein Web-App zu entwickeln, ist es sicher zu sagen, Sie XmlWebApplicationContext verwenden müssen.

Wenn Sie Ihre Bohnen wollen bewusst Frühling sein, Sie können sie BeanFactoryAware und / oder ApplicationContextAware dafür haben implementieren, so können Sie entweder BeanFactory oder Application und wählen, welche Schnittstelle zu implementieren.

BeanFactory und Application sind beide Wege Bohnen aus dem Frühjahr IOC Behälter aber immer noch zu bekommen sind einige Unterschiede.

BeanFactory ist der eigentliche Behälter, die instanziiert, konfiguriert und verwaltet eine Reihe von Bean. Diese Bohnen sind in der Regel der Zusammenarbeit miteinander und damit Abhängigkeiten untereinander. Diese Abhängigkeiten werden in den Konfigurationsdaten reflektiert durch die BeanFactory verwendet.

BeanFactory und Application sind beide Java-Schnittstellen und Application erweitert BeanFactory. Beide sind Konfiguration XML-Konfigurationsdateien. Kurz BeanFactory bietet grundlegende Inversion of Control ( IoC ) und Dependency Injection ( DI ) verfügt, während Application bietet Erweitert Funktionen.

Eine BeanFactory wird durch die Schnittstelle repräsentiert " org.springframework.beans.factory " Wo BeanFactory, für die es mehrere Implementierungen.

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

Differenz

BeanFactory Bean instanziiert, wenn Sie anrufen getBean () Methode während Application Singleton instanziiert Bohne, wenn der Behälter gestartet wird, wartet nicht für getBean () zu genannt werden.
BeanFactory bietet keine Unterstützung für die Internationalisierung aber Application bietet Unterstützung für sie.
Ein weiterer Unterschied zwischen BeanFactory vs Application ist die Fähigkeit Ereignis Bohnen zu veröffentlichen, die als Zuhörer registriert sind.
Eines der beliebtesten Implementierung von BeanFactory Schnittstelle XMLBeanFactory , während eine der beliebtesten Implementierung von Application Schnittstelle ClassPathXmlApplicationContext .
Wenn Sie die automatische Verdrahtung verwenden und mit BeanFactory als Sie sich registrieren müssen AutoWiredBeanPostProcessor mit API, die Sie in XML konfigurieren können, wenn Sie mit Application . Zusammengefasst BeanFactory ist OK für die Prüfung und nicht produktiven Einsatz aber Application mehr funktionsreiche Container-Implementierung und begünstigt über sollte BeanFactory
BeanFactory standardmäßig seine Unterstützung Faule Laden und Application standardmäßig Unterstützung Aggresive Laden.

Der Unterschied zwischen BeanFactory und Application sind folgende:

BeanFactory verwendet faul Initialisierung und Application verwendet eifrig Initialisierung. Im Falle von BeanFactory, Bohne wird erstellt, wenn Sie getBeans () -Methode aufrufen, aber Bean bei Application im Voraus erstellt, wenn das Application Objekt erstellt wird.
BeanFactory bieten explizit eine Ressourcenobjekt Syntax und Application erstellt und Ressourcenobjekte auf eigene verwaltet.
BeanFactory doesnt Unterstützung internatiolization und Application unterstützt Internationalisierung.
Mit BeanFactory Annotation basierend Dependency Injection wird nicht unterstützt und Annotation basierend Dependency Injection ist in Application unterstützt.

Mit BeanFactory:

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

Mit Application:

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

Feature Matrix von BeanFactory vs Anwendungskontext sourced von Feder docs

_{Bildschirmfoto von Merkmalen BeanFacotry und Application}

Im Grunde können wir Federcontainerobjekt auf zwei Arten erstellen

mit BeatFactory
mit Application

beide sind die Schnittstellen

Implementierungsklassen nutzen wir Objekt für Federbehälter schaffen

auf die Unterschiede kommen

BeanFactory

unterstützt nicht die Annotation basierend Dependency Injection.
unterstützt nicht L18N
In der Standardeinstellung seiner Unterstützung Lazy Loading
es nicht zulassen konfigurieren, um mehrere Konfigurationsdateien.

ex: BeanFactory Kontext = new XmlBeanFactory (neue Ressource ( "applicationContext.xml"));

Application

Support Annotation basierend Abhängigkeit Injection.-@Autowired, @PreDestroy
Support L18N
sein standardmäßig Unterstützung Aggresive Belastung.
es erlaubt, mehrere Konfigurationsdateien zu konfigurieren.

ex:
Application Kontext = new ClasspathXmlApplicationContext ( "applicationContext.xml");

a. Ein Unterschied zwischen BeanFactory und Anwendungskontext ist, dass erstere nur Bean instanziiert, wenn Sie anrufen getBean () -Methode während Application instanziiert Singleton Bohne, wenn der Container gestartet wird, es wartet nicht, bis getBean aufgerufen werden.

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

oder

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

Sie können mit einer oder mehrere XML-Datei auf Ihrem Projekt je nach Bedarf. Wie ich hier bin mit zwei XML-Dateien das heißt eine für Konfigurationsdetails für Serviceklassen andere für DAO-Klassen. Hier ClassPathXmlApplicationContext ist Kind von Application.

c. BeanFactory Container Basiscontainer ist, kann es nur Objekte erstellen und Abhängigkeiten injizieren. Aber wir können nicht andere Dienste anhängen wie Sicherheit, Transaktionen, Messaging usw. alle Dienstleistungen bieten wir haben Application Container zu verwenden.

d. BeanFactory bietet keine Unterstützung für die Internationalisierung heißt i18n aber Application bietet Unterstützung für sie.

e. BeanFactory Container nicht die Funktion der automatischen Prüfung (Unterstützung Annotation basierend Dependency Injection) unterstützen, aber Application Container unterstützt.

f. BeanFactory Container wird keine Bean-Objekt, bis die Anforderungszeit erstellen. Es bedeutet BeanFactory Container Lasten träge Bohnen. Während Application Container erstellt Objekte von Singleton Bohne zur Zeit nur zum Laden. Es bedeutet, dass es eine frühe Belastung ist.

g. BeanFactory Containerabstellvorrichtung nur zwei Bereiche (Singleton & Prototyp) der Bohnen. Aber Application Container unterstützt alle Bohnen Umfang.

Siehe dieses Dokument von Spring Text & Tabellen:

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 Application?

ein Application verwenden, wenn Sie einen guten Grund, dies nicht zu tun.

Da die Application alle Funktionen des BeanFactory enthält, wird es in der Regel über die BeanFactory empfohlen, bis auf ein paar Situationen, wie zum Beispiel in einem Applet in den Speicherverbrauch von entscheidenden Bedeutung sein könnte und ein paar zusätzliche Kilobyte könnten einen Unterschied machen. Doch für die meisten typischen Unternehmensanwendungen und Systemen ist das Application, was Sie verwenden möchten. Frühling 2.0 und später macht intensiven Gebrauch von dem BeanPostProcessor Erweiterungspunkt (Proxying zu bewirken und so weiter). Wenn Sie nur eine einfache BeanFactory, eine angemessene Menge an Unterstützung wie Transaktionen und AOP nicht wirksam, zumindest nicht ohne einige zusätzliche Schritte auf Ihrer Seite. Diese Situation verwirrend sein könnte, weil eigentlich nichts falsch mit der Konfiguration ist.

Application ist ein großer Bruder von BeanFactory und dies alles, was würde das BeanFactory ist bieten und viele andere Dinge.

Zusätzlich zu dem Standard org.springframework.beans.factory.BeanFactory Lifecycle-Funktionen, Application Implementierungen erkennen und aufrufen ApplicationContextAware Bohnen sowie ResourceLoaderAware, ApplicationEventPublisherAware und MessageSourceAware Bohnen.

In einem Echtzeit-Szenario, die Differenz zwischen den Feder IOC Kernbehältern (BeanFactory) und Advanced J2EE-Container (Application) ist wie folgt.

BeanFactory werden Objekte für die Bohnen (dh für POJO Klassen) erstellen, die nur in der spring.xml Datei (<bean></bean>) erwähnt, wenn Sie die .getBean () -Methode aufrufen, aber während Application erstellt die Objekte für alle Bohnen (<bean></bean> wenn in ihrem Umfang nicht explizit als „Prototyp“ genannt wird), konfiguriert in der spring.xml während die spring.xml Datei laden selbst.

BeanFactory: (Faule Container, weil es die Objekte für die Bohnen schafft nur, wenn Sie explizit aufrufen vom Benutzer / Hauptklasse)

/*
 * 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");

Application: (Eager Container wegen der Objekte aller Singleton Bohnen zu schaffen, während die spring.xml Datei Laden selbst)

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

Technisch wird mit Application empfohlen, da in Echtzeitanwendungen werden die Bean-Objekte erstellt werden, während die Anwendung in dem Server selbst begonnen. Dadurch verringert sich die Reaktionszeit für die Benutzeranforderung als die Objekte sind bereits verfügbar zu reagieren.

Ich denke, es ist erwähnenswert, dass seit dem Frühjahr 3, wenn Sie eine Fabrik erstellen möchten, können Sie auch die Verwendung @configuration Anmerkung kombiniert mit dem richtigen @scope

@Configuration
public class MyFactory {

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

Ihre Fabrik soll bis zum Frühjahr Behälter mit dem @ComponentScan Anmerkung oder xML-Konfiguration

Spring-Bean Tive Artikel von baeldung Website

BeanFactory verwenden für Nicht-Web-Anwendungen, da es nur Singleton und Prototype-Bean-Bereiche unterstützt.

Während Application Container all bean-Bereiche jedoch zwingend nötig, so dass Sie es für Web-Anwendungen verwendet werden sollen.

Zusammenfassung:

Die Application enthält alle Funktionen des BeanFactory. Es ist im allgemeinen die ersteren zu verwenden empfohlen.

Es gibt einige begrenzte Situationen wie in einer mobilen Anwendung, wo der Speicherverbrauch von entscheidender Bedeutung sein könnte.

, dass Szenarien kann es gerechtfertigt sein, die leichter zu bedienen BeanFactory . Doch in den meisten Unternehmensanwendungen, die Application ist das, was Sie verwenden möchten.

Für mehr finden Sie in meinem Blog-Post:

Unterschied zwischen BeanFactory und Application in Spring - Das Java Frühjahr Blog von den Grundlagen

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow