In diesem Artikel wird eine kurze Diskussion über das Abhängigkeitsinjektionsprinzip von Frühlings -IOC -Containern eingeführt und teilt sie wie folgt mit Ihnen mit:
Die Hauptaufgabe zur Initialisierung des IOC -Containers besteht darin, eine BeanDefinition -Datenkarte im IOC -Container aufzubauen. Ich habe nicht gesehen, wie der IOC -Container die Bohnenabhängigkeitsbeziehung injizierte.
Unter der Annahme, dass der aktuelle IOC-Container benutzerdefinierte Bean-Informationen geladen hat, erfolgt die Abhängigkeitsinjektion hauptsächlich in zwei Stufen.
Unter normalen Umständen wird es ausgelöst, wenn der Benutzer zum ersten Mal nach einer Bohne aus dem IOC -Container fragt.
Wir können jedoch das Lazy-Init-Attribut in den BeanDefinition-Informationen steuern, damit der Container die Bean, dh der Prozess der Abhängigkeitsinjektion bestimmter Bohnen, während des Initialisierungsprozesses abgeschlossen wird.
1. Abhängigkeitsinjektion, die von getBean ausgelöst wird
In der Basis -Beanfaktor -Schnittstelle von IOC -Container gibt es eine Schnittstellendefinition für GetBean. In der Implementierung dieser Schnittstelle tritt die Triggerabhängigkeitsinjektion auf. Um den Prozess der Abhängigkeitsinjektion weiter zu verstehen, beginnen wir mit der Basisklasse.
// Hier ist die Implementierung der Beanfactory -Schnittstelle, wie die GetBean -Schnittstellenmethode // Diese GetBean -Schnittstellenmethoden werden letztendlich implementiert, indem dorgetbean @Override öffentliches Objekt getBean (String -Name) bezeichnet wird. } @Override public <T> T getBean (String -Name, Klasse <T> forderttype) löscht Beansexception {return dodbean (name, forderstype, null, false); } @Override public Object getBean (String -Name, Objekt ... args) löst Beansexception {return dodbean (Name, null, args, false); } public <t> T getBean (String -Name, Klasse <T> fordert type, Objekt ... args) löscht Beansexception {return dodbean (name, forders type, args, false); } // Hier wird die Bean tatsächlich erhalten, dh die Abhängigkeitsinjektion wird @Suppresswarnings ("deaktiviert") geschützt <t> t deggetbean (endgültiger String -Name, endgültige Klasse <T> Erforderliche Erforderliche, endgültige Objekt [] args, boolan typeckonly). Objektbohne; // Überprüfen Sie den Singleton -Cache für manuell registrierte Singletons eifrig. // Überprüfen Sie den Singleton -Cache für manuell registrierte Singletons eifrig. // Überprüfen Sie eifrig Singleton -Cache auf manuelle Registrierung Singletons // Abrufen Sie die Bohnen zuerst aus dem Cache ab und verarbeiten Sie die erstellten Singleton -Bohnen. Erstellen Sie nicht wiederholt das Objekt SharedInstance = Getsingleton (Beanname); if (SharedInstance! } else {logger.debug ("zurückgegebene Instanz von Singleton Bean '" + BeAnName + "'"); }} // Die GetObjectForBeanInstance vervollständigt die relevante Verarbeitung von FactoryBean, um die relevante Verarbeitung der Fabrikbearbeitung zu erhalten, um die Produktionsergebnisse von FactoryBean zu erhalten. Der Unterschied zwischen Beanfactory und FactoryBean wurde früher erwähnt. Dieser Prozess wird später ausführlich analysiert. = GetObjectForBeanInstance (SharedInstance, Name, Beanname, NULL); } else {// scheitern, wenn wir diese Bean -Instanz bereits erstellen: // Wir werden in einer kreisförmigen Referenz angenommen. if (isPrototypecurentIncreation (Beanname)) {werfen neuer beancrealeincreationException (Beanname); } // // prüfen Sie, ob die BeanDefinition im IOC -Container existiert. Wenn es in der aktuellen Fabrik nicht vorhanden ist, folgen Sie der übergeordneten Beanfaktor -Kette und schauen Sie nach oben den beanfakktorischen Elternteil. if (parentBeanFactory! String nametolookup = originalBeanname (Name); if (args! = null) {// Delegation an Eltern mit expliziten Argumenten. return (t) parentBeanFactory.getbean (nametolookup, args); } else {// no args -> delegieren Sie die Standard -GetBean -Methode. return parentBeanFactory.getBean (nametolookup, forders type); }} if (! typecheckonly) {markbeanAscreated (Beanname); } try {// Beandefinition Final RootbeanDeFinition mbd = getMergedLocalbeanDeFinition (Beanname); checkmergedbeandefinition (MBD, Beanname, Args); // Garantie der Initialisierung von Bohnen, von denen die aktuelle Bohne abhängt. // rekursiv alle Bohnen erhalten, von denen die aktuelle Bean abhängt (wenn überhaupt) String [] Develementson = mbd.getDependson (); if (abhängigSon! } RegisterDependentBean (DEP, Beanname); GetBean (DEP); } } //Create Singleton bean instance by calling the createBean method if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { try { return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explizit aus dem Singleton -Cache entfernen: Es wurde möglicherweise durch den Erstellungsprozess eingerichtet, um eine kreisförmige Referenz zu ermöglichen. Bean = GetObjectForBeanInstance (SharedInstance, Name, Beanname, MBD); } // Dies ist der Ort, an dem eine Prototyp -Bean sonst erstellt wird, wenn (mbd.riprototype ()) {// Es ist ein Prototyp -> eine neue Instanz erstellen. Objektprototypeinstanz = null; Versuchen Sie {vorprototypecreation (Beanname); prototypeinstance = createBean (Beanname, mbd, args); } endlich {AfterPrototypecreation (Beanname); } bean = getObjectforBeanInstance (Prototypeinstanz, Name, Beanname, MBD); } else {String scopename = mbd.getScope (); Final Scope Scope = this.scopes.get (Scopename); if (scope == null) {neue illegaleStateException werfen ("Kein Bereich für den Scope -Namen '" + Scopename + "'"); } try { Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() { @Override public Object getObject() throws BeansException { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } } }); Bean = GetObjectForBeanInstance (ScopedInstance, Name, Beanname, MBD); } catch (illegalStateException ex) {werfen neue BeancreationException (Beanname, "Scope" " + Scopename +" 'nicht für den aktuellen Thread aktiv; Betrachten Sie " +", um einen Scoped -Proxy für diese Bohne zu definieren, wenn Sie sich von einem Singleton darauf beziehen ", Ex); }}} catch (Beansexception ex) {CleanUpAfterBeanCreationFailure (Beanname); Ex werfen; }} // Überprüfen Sie, ob der erforderliche Typ mit dem Typ der tatsächlichen Bean -Instanz übereinstimmt. // Die Schädigung wird hier auf der erstellten Bean durchgeführt. Wenn es kein Problem gibt, wird die neu erstellte Bean zurückgegeben. Diese Bean ist bereits eine Bean, die die Abhängigkeit enthält, wenn (forderttype! = Null && bean! } catch (typemismatchException ex) {if (logger.isdebugenabled ()) {logger.debug ("" Bean " +" name + "'in den erforderlichen Typ'" + clasutils.getqualifiedName (forders type) + "", ex); } neue BeannotofRequiredTypexception (Name, forders fordertype, bean.getClass ()); }} return (t) bean; }Die Abhängigkeitsinjektion wird hier ausgelöst. Die Abhängigkeitsinjektion tritt auf, wenn die BeanDefinitionsdaten im Container festgelegt wurden. Obwohl wir den IOC -Container einfachsten beschreiben können, dh ihn als HashMap behandeln, können wir nur sagen, dass diese HashMap die grundlegendste Datenstruktur des Containers ist, nicht der gesamte IOC -Container.
Dieser Abhängigkeitsinjektionsprozess wird nachstehend ausführlich erläutert. Abbildung 1.1 zeigt den allgemeinen Prozess der Abhängigkeitsinjektion.
Abbildung 1.1 Abhängigkeitsinjektionsprozess
GetBean ist der Ausgangspunkt der Abhängigkeitsinjektion. Danach wird CreateBean in AbstractAutoWirecapableBeanFactory zur Herstellung der erforderlichen Bohnen aufgerufen, und die Bean-Initialisierung wird auch verarbeitet, z.
@Override Protected Object createBean (String beanname, RootbeandeFinition MBD, Object [] args) beancreationException {if (logger.isdebugenabled ()) {logger.debug ("Erstellen von Instanz von Bean" + BeanName + ""); } RootbeanDeFinition mbdtouse = mbd; // Stellen Sie sicher, dass die Bean -Klasse zu diesem Zeitpunkt tatsächlich aufgelöst wird, und klonen Sie die Bean -Definition im Falle einer dynamisch aufgelösten Klasse //, die in der Shared Fusion Bean Definition nicht gespeichert werden kann. // Hier bestimmen wir, ob die zu erstellende Bean instanziiert werden kann, ob diese Klasse über die Klassenladerklasse <?> ResoledClass = ResolveBeanClass (MBD, Beanname) geladen werden kann. if (ResoledClass! = null &&! mbdtouse.setBeanClass (ResoledClass); } // Vorbereitende Methodenüberschreibungen. try {mbdtouse.preparemethodoverrides (); } catch (BeanDefinitionValidationException ex) {neue BeanDefinitionStoreException (mbdtouse.getResourcedescription (), Beanname, "Validierung von Überschreibungen der Methode fehlgeschlagen", Ex); } try {// Geben Sie BeanPostProcessors die Möglichkeit, einen Proxy anstelle der Ziel -Bean -Instanz zurückzugeben. // Wenn die Bean den Postprozessor konfiguriert hat, dann ist die zurückgegebene Proxy -Objekt bean = ResolveBeforeinstantiation (Beanname, mbdtouse); if (bean! = null) {return bean; }} catch (throwable ex) {neue beancreationException (mbdtouse.getResourcedescription (), Beanname, "BeanpostProcessor vor der Instanziierung von Bean fehlgeschlagen", ex); } try {Object beanInstance = docreatebean (Beanname, mbdtouse, args); if (logger.isdebugenabled ()) {logger.debug ("Beendigung der Instanz von Bean '" + Beanname + "'"); } Rückkehr beanInstance; } catch (BeancreationException ex) {// Eine zuvor erkannte Ausnahme mit einem ordnungsgemäßen Kontext der Bean -Erstellung bereits ... werfen ex; } catch (implicitlyAppearedSingLetOnexception ex) {// eine illegalStateException, die mit der Standardsingingletonbeanregistry mitgeteilt werden soll; } catch (throwable ex) {neue beancreationException (mbdtouse.getResourcedescription (), Beanname, "Unerwartete Ausnahme während der Bohnenerstellung", Ex); }} // neben docreate, um zu sehen, wie Beans geschützt werden. // verwendet, um das erstellte Bean -Objekt -Beanwrapper InstanceWrapper = NULL zu halten; // Wenn es sich um ein Singleton handelt, löschen Sie zuerst die gleichnamige Bean im Cache if (mbd.issingleton ()) {InstanceWrapper = this.factoryBeanInstanceCache.remove (Beanname); } // Dies ist der Ort, an dem die Bean erstellt werden kann, und es geschieht durch CreateBeanInstance if (Instancewrapper == NULL) {// Erstellen einer neuen Instanz, die auf der angegebenen Bean mit der entsprechenden Strategie basiert, wie: Fabrikmethode, Konstruktor -automatische Injektion, einfache Initialisierungsinstanzinstanz = CreateBeaninstance (BeAnName, MBD, MBD, Argumentation). } Final Object bean = (InstanceWrapper! Class <?> BeanType = (InstanceWrapper! // Erlauben Sie Postprozessoren, die fusionierte Bean-Definition zu ändern. synchronisiert (mbd.postprocessinglock) {if (! mbd.postprocessed = true; }} // Sachgemäß Singletons, um kreisförmige Referenzen aufzulösen // selbst wenn sie durch Lebenszyklus -Schnittstellen wie beanfactoryAware ausgelöst werden. // ist notwendig, im Voraus aufzudecken: Singleton und Zullleton -Abhängigkeiten und die aktuelle Bean erzeugt, zyklische Abhängigkeiten boolean EarlysingLetOnexposure = (mbd.issingleton () && this.allowcircularReferences && issingLetoncurentincreation (BeanName); if (frühesingletOnexposure) {if (logger.isdebugenabled ()) {logger.debug ("eifrig zwischen Bean '" + BeAnName + "', um potenzielle zirkuläre Referenzen aufzulösen"); } // Um die Abhängigkeiten im späten Zyklus zu vermeiden, kann das Objektfaktor, das eine Instanz erstellt, der Fabrik hinzugefügt werden, bevor die Bean-Initialisierung abgeschlossen ist. AddSingletonFactory (Beanname, New ObjectFactory <Foject> () {@Override öffentliches Objekt getObject () löst Beansexception aus {// verlassen sich wieder auf Referenzen auf Beans, wobei sie hauptsächlich SmartinStantialiationaware Beanpostprozessor verwenden. GetearlyBeanReference (Beanname, MBD, Bean); } // Initialisieren Sie die Bean -Instanz. // Dies ist die Initialisierung der Bohne, und hier tritt häufig häufig die Abhängigkeitsinjektion auf. Dieses exponierte Bedauern muss nach der Verarbeitung der Initialisierung als Bohne zurückgekehrt sind. Objekt exposedObject = bean; Versuchen Sie es mit {// die Bean und injizieren Sie jeden Attributwert. Unter ihnen kann es Attribute geben, die von anderen Bohnen abhängen. Die Abhängigkeitsbohne wird rekursiv bevölkern (Beanname, MBD, InstanceWrapper); if (exposedObject! = null) {// Aufruf der Initialisierungsmethode, wie init-Methode exposedObject = initializeBean (Beanname, exponsedObject, mbd); }} catch (throwable ex) {if (ex instanceof beancreationException && beanname.equals (((beancreationException) ex) .getBeanname ())) {throw (beancreationException) ex; } else {throune BeancreationException (mbd.getResourcedescription (), Beanname, "Initialisierung von Bean fehlgeschlagen", ex); }} if (frühsingtletOnexposition) {Objekt frühsingletonReference = Getsingleton (Beanname, false); // FrühesingletonReference ist nur dann nicht leer, wenn eine zirkuläre Abhängigkeit festgestellt wird, wenn (frühsingletonReference! } else if (! this.allowrawinjectionDepiteWrapping && Hasdependentbean (Beanname)) {String [] abhängigbeans = getDependentBeans (Beanname); Set <String> tatsächliche DependentBeans = new LinkedHashSet <String> (abhängigbeans.length); für (String abhängigeBean: abhängigeBeans) {// Erkennungsabhängigkeit if (! removesingLetonifcreateTForTyPeCtechononly (abhängig)) {trupleDependentBeans.add (abhängigBean); }} // Da die Bohnen, von denen es nach der Erstellung der Bohne abhängt, erstellt worden sein muss, ist die tatsächliche Dependentbeans nicht leer, was bedeutet, dass die Bohnen, von denen es abhängt, nachdem die aktuelle Bohne erstellt wurde, nicht erstellt wurden, dh eine zirkuläre Abhängigkeit, wenn (! Tatsächliche dependente. "'wurde in andere Bohnen [" + Stringutils.CollectionTocommadelimitedString (tatsächliche DependentBeans) +] in seiner rohen Version als Teil einer kreisförmigen Referenz injiziert, wurde aber schließlich " +" eingeschlossen. Dies bedeutet, dass andere Bohnen nicht die endgültige Version von " +" -Bean verwenden. "DeglyeAgerinit" -Fahne ausgeschaltet, zum Beispiel ausgeschaltet. "); }}}}} // Die Bean als verfügbar registrieren. Versuchen Sie {// Registrieren Sie Bean basierend auf Scope RegisterDisposableBeanIFNe -of -of -of -ofcht (Beanname, Bean, MBD); } catch (BeanDefinitionValidationException ex) {neue BeancreationException (mbd.getResourcedescription (), Beanname, "Ungültige Zerstörungssignatur", Ex); } return exposedObject; }Die Abhängigkeitsinjektion umfasst tatsächlich zwei Hauptprozesse
Aus dem obigen können wir sehen, dass die Methoden, die besonders eng mit der Abhängigkeitsinjektion zusammenhängen
CreateBeanInstance
Generieren Sie Java -Objekte, die in Bohnen enthalten sind
Bevölkerung.
Verarbeitung des Prozesses der Verarbeitung der Eigenschaften verschiedener Bean -Objekte (d. H. Der Prozess der Abhängigkeitsverarbeitung)
Schauen wir uns zuerst den Quellcode für createBeanInstance an
/** * Erstellen Sie eine neue Instanz für die angegebene Bean unter Verwendung einer geeigneten Instanzstrategie: * Fabrikmethode, Konstruktor -Autowerk oder einfache Instanz. * @param beannname Der Name der Bean * @param mbd Die Bean -Definition für die Bean * @param args explizite Argumente für Konstruktor- oder Fabrikmethodenanruf an dieser Stelle. // Bestätigen Sie, dass die Klasse der Bean -Instanz, die Sie erstellen möchten, instanziiert werden kann. if (beanclass! = null &&! modifier.ispublic (beanclass.getModifiers ()) &&! } Lieferanten <?> Instancesupplier = Mbd.getInstancesUPPLier (); if (InstancesUsPlier! } // Wenn die Fabrikmethode nicht leer ist, verwenden Sie die Fabrikmethodestrategie, um die Bean zu instanziieren, wenn (mbd.getFactoryMethodname ()! } // Verknüpfung beim Wiederherstellen derselben Bean ... boolean aufgelöst = false; boolean AutoWIREn -Angemessene = false; if (args == null) {synchronized (mbd.constructorArgumentLock) {// Eine Klasse hat mehrere Konstruktoren, jeder Konstruktor hat unterschiedliche Parameter, also müssen Sie vor dem Aufrufen den Konstruktor oder die entsprechende Fabrikmethode gemäß den Parametern if (Mbd.resolvedocedConcortedRectorFactoryMethy! AutoWIREn -ansäure = mbd.ConstructorArgumentsResolved; }}} // Wenn es analysiert wurde, verwenden Sie die Parsen -Konstruktor -Methode, ohne erneut zu sperren, wenn (aufgelöst) {if (autoWiren -eventary) {// Konstruktor automatisch injiziert, return AutoWireconstructor (Beanname, MBD, NULL, NULL); } else {// Konstruktor, der den Standardkonstruktor zum Konstruktor -Instantiatbean (Beanname, MBD) verwendet; }} // Muss den Konstruktor bestimmen ... // Die Bean mithilfe des Konstruktor -Konstruktors <?> [] Ctors = DeterdeconstructorsFroombanPostProcessors (Beanclass, Beanname); if (ctors! } // KEINE Spezialhandhabung: Verwenden Sie einfach No-Arg-Konstruktor. // die Bohne mit ihrem Standardkonstruktor instanziieren; } /*** Instantieren Sie die angegebene Bean mit ihrem Standardkonstruktor. * @param beannname Der Name der Bean * @param mbd Die Bean -Definition für die Bean * @return a Beanwrapper für die neue Instanz */// Die häufigste Instantiate -geschützte BeanWrapper InstantiateBean (endgültige String -Be Anname, endgültige Rootbeandefinition mbd) {// // Instantiate The Beanname mit der Standard -Instantiationsstrategie. Die Standard -Instantiationsstrategie ist // cglibsubclasssinginstantiationStrategy, dh die Bohne mit CGGLIB. Versuchen Sie {Object BeanInstance; endgültig beanfactory übergeordnet = this; if (system.getSecurityManager ()! } else {beanInstance = getInstantiationStrategy (). Instantiate (MBD, Beanname, Parent); } Beanwrapper bw = new BeanWrapperImpl (BeanInstance); InitBeanWrapper (BW); Return BW; } catch (throwable ex) {neue beancreationException (mbd.getResourcedescription (), Beanname, "Instantiation of Bean fehlgeschlagen", Ex); }}CGGLIB wird hier verwendet, um Bohnen zu instanziieren. CGLIB ist eine Klassenbibliothek für Bytecode -Generatoren, die eine Reihe von APIs zur Verfügung stellt, um die Funktion des Generierens und der Konvertierung von Java -Bytecode bereitzustellen.
Im Frühjahr AOP wird CGLIB auch zur Verbesserung von Java -Bytecode verwendet. In IOC -Behältern, um zu verstehen, wie CGGLIB verwendet wird, um Bean -Objekte zu erzeugen, müssen Sie sich die SimpleInstantiationStrategy -Klasse ansehen. Es ist die Standardklasse, die von Spring verwendet wird, um Bean -Objekte zu erzeugen. Es bietet zwei Methoden zur Instanziierung von Bean -Objekten.
öffentliche Klasse SimpleInstantiationStrategy Implementle InstanctiationStrategy {@Override öffentliches Objekt Instanziat (RootbeanDefinition BD, String -Beanname, BeanFactory -Besitzer) {// Überschreiben Sie die Klasse nicht mit CGGLIB, wenn keine Überschreibungen. if (bd.getMethodoverrides (). isEmpty ()) {// Hier erhalten Sie den angegebenen Konstruktor oder die Fabrikmethode, um den Beanconstructor <> Constructortouse zu instanziieren; synchronisiert (bd.constructorargumentLock) {constructOrouse = (constructor <>) bd.resolvedConstructororFactoryMethod; if (constructOrtouse == null) {endgültige Klasse <?> clazz = bd.getBeanClass (); if (clazz.Isersinterface ()) {neue BeaninStantiationException (Clazz, "angegebene Klasse ist eine Schnittstelle"); } try {if (system.getSecurityManager ()! } else {constructOrtouse = clazz.getDeclaredConstructor ((Klasse []) null); } Bd.ResolvedConstructororFactoryMethod = constructOrtouse; } catch (throwable ex) {neue BeanInIniationException werfen (Clazz, "kein Standardkonstruktor gefunden", Ex); }}} // Instantiert durch Beanutils. Die Instanziierung dieser Beanutils instanziiert die Bohne durch den Konstruktor. In Beanutils können Sie den spezifischen Anruf ctor.Newinstance (args) zurücksehen Beanutils.instantiateClass (constructOrtouse); } else {// Das Objekt zurücksende Instanzipenewithmethodinjection (BD, Beanname, Eigentümer); }}}Umgang mit Abhängigkeiten zwischen Bohnen
Der Eintrag zur Abhängigkeitsverarbeitung ist die oben erwähnte PopulateBean -Methode. Da es zu viele Aspekte gibt, werde ich den Code hier nicht veröffentlichen. Eine kurze Einführung in den Prozess der Abhängigkeitsverarbeitung: In der PopulateBean -Methode,
Lassen Sie zuerst den Eigenschaftswert in BeanDefinition erhalten und dann den Abhängigkeitsinjektionsprozess starten.
Zuerst kann die AutoWire -Injektion, Byname oder Bytype verarbeitet werden, und dann werden die Attribute injiziert.
Dann müssen Sie die Bohnenreferenz analysieren. Nach dem Parsen von Managelist, Management, Managemap usw. haben Sie die Bedingungen für die Abhängigkeitsinjektion vorbereitet. Hier setzen Sie das Bohnenobjekt wirklich auf eine andere Bean -Eigenschaft, von der es abhängt, und die verarbeiteten Eigenschaften sind verschiedene.
Die Abhängigkeitsinjektion erfolgt in den SetPropertyValues von Beanwrapper, aber der spezifische Abschluss wird in der Beanwrapper -Unterklasse BeanWrapperimpl implementiert. Die Injektion des Eigentumswerts der Bohne, einschließlich der Injektion von Array, der Injektion von Sammelklassen wie der Liste und der Injektion von Nicht-Sammelklassen.
Nach einer Reihe von Injektionen wird der Abhängigkeitsinjektionsprozess verschiedener Bohneneigenschaften abgeschlossen.
Während des Erstellens von Bohnen und Objektabhängigkeitsinjektion muss die Abhängigkeitsinjektion auf der Grundlage der Informationen in der BeanDefinition rekursiv abgeschlossen werden.
Aus den vorherigen Rekursionsprozessen können wir feststellen, dass diese Rekursionen alle mit GetBean tragbar sind.
Eine Rekursion besteht darin, die erforderlichen Bohnen zu finden und den rekursiven Aufruf an die Bohnen im Kontextsystem zu erstellen.
Eine andere Rekursion besteht darin, die GetBean -Methode des Containers während der Abhängigkeitsinjektion rekursiv aufzurufen, um die Abhängigkeitsbohne der aktuellen Bean zu erhalten und auch die Erstellung und Injektion der Abhängigkeitsbohne auszulösen.
Bei der Durchführung der Abhängigkeitsinjektion für die Eigenschaften einer Bohne ist der Parsingprozess auch ein rekursiver Prozess. Auf diese Weise werden nach Abhängigkeit die Erstellung und Injektion der Bohne Schicht für Schicht abgeschlossen, bis die Erstellung der Strombohne endgültig abgeschlossen ist. Mit der Schaffung dieser Top-Level-Bohne und der Fertigstellung seiner Attributabhängigkeitsinjektion bedeutet dies, dass die Einspritzlösung der gesamten Abhängigkeitskette in Bezug auf die aktuelle Bohne abgeschlossen ist.
Nach Abschluss der Bohnenerstellung und Abhängigkeitsinjektion werden im IOC -Behälter eine Reihe von Bohnen festgelegt, die durch Abhängigkeiten verbunden sind. Diese Bohne ist kein einfaches Java -Objekt mehr. Nachdem die Abhängigkeitsbeziehung zwischen der Bean-Serie und den Beans festgestellt wurde, kann sie für Anwendungen der oberen Ebene über die relevanten Schnittstellenmethoden des IOC sehr bequem verwendet werden.
2. Lazy-Init-Attribut und Vorinstanz
In der vorherigen Aktualisierungsmethode können wir feststellen, dass die FinishbeanFactoryInitialisierung aufgerufen wird, um Beans mit Lazy-Init-Konfiguration zu verarbeiten.
Tatsächlich wird bei dieser Methode die Verarbeitung des Lazy-Init-Attributs eingekapselt, und die tatsächliche Verarbeitung erfolgt in der preinstantiatesingleton-Methode des Basic-Containers von StandardListableBeanFactory. Diese Methode vervollständigt die vorinstabilen Singleton-Bohnen, und diese vorinstizierte Fertigstellung wird geschickt in den Container delegiert, um sie zu implementieren. Wenn Vorinstitution erforderlich ist, wird hier GetBean verwendet, um die Abhängigkeitsinjektion auszulösen. Im Vergleich zu normalen Abhängigkeitsinjektionsauslöschern sind die Auslöserzeit und der Anlass nur unterschiedlich. Hier tritt eine Abhängigkeitsinjektion während des Aktualisierungsprozesses des Containers auf, dh während des IOC -Containerinitialisierungsprozesses im Gegensatz zur gewöhnlichen Abhängigkeitsinjektion, wenn der Container die Bohne zum ersten Mal nach der Initialisierung des IOC -Containers über GetBean anfordert.
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.