Um zu lernen, wie man Bohnen im Frühling injiziert, müssen Sie zunächst verstehen, welche Abhängigkeitsinjektion ist. Die Abhängigkeitsinjektion bezieht sich auf: Lassen Sie die Aufrufklasse die Abhängigkeit der Implementierungsklasse der Implementierungsklasse einer bestimmten Schnittstelle von Dritten injiziert, um die Abhängigkeit der Aufrufklasse von der Implementierungsklasse einer bestimmten Schnittstelle zu beseitigen.
Zu den in Federbehältern unterstützten Abhängigkeitsinjektionsmethoden gehören hauptsächlich Eigenschafteninjektion, Konstruktorinjektion und Fabrikmethode -Injektion. Als nächstes werden wir diese drei Abhängigkeitsinjektionsmethoden und ihre spezifischen Konfigurationsmethoden im Detail einführen.
1. Attributinjektion
Attributinjektionsmittelwerte, die den Attributwert oder abhängigen Objekt der Bean über die Methode setxxx () injizieren. Da die Attributinjektionsmethode selektiv und flexibel ist, ist es auch die am häufigsten verwendete Injektionsmethode in der tatsächlichen Entwicklung.
Spring ruft zuerst den Standardkonstruktor der Bean auf, um das Bean -Objekt zu instanziieren, und dann die festgelegte Methode über die reflektierte Methode aufzurufen, um den Eigenschaftswert zu injizieren.
Immobilieninjektion verpflichtet die Bean, einen Standardkonstruktor bereitzustellen, und muss eine festgelegte Methode für die Eigenschaften bereitstellen, die injiziert werden müssen.
Tipps: Der sogenannte Standardkonstruktor, dh ein Konstruktor ohne Parameter. Wenn in der Klasse kein benutzerdefinierter Konstruktor vorhanden ist, generiert das System (JVM) automatisch einen Standardkonstruktor ohne Parameter. Wenn der Konstruktor mit Parametern in der Klasse explizit angepasst wird, generiert das System den Standardkonstruktor nicht automatisch und Sie müssen einen Konstruktor ohne Parameter manuell hinzufügen.
Das Folgende ist ein Beispiel, um die Eigentumseinspritzmethode von Bohnen im Frühjahr zu demonstrieren:
Schreiben Sie eine Benutzerklasse:
Paket com.kevin.bean;/** * Erstellen Sie eine Klassen -Test Bean Property Injection -Methode * @Author Kevin * */public class User {private String username; public String getUnername () {return userername; } public void setUnername (String -Benutzername) {this.username = userername; }}Konfigurationsdatei:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! </Property> </beans>
Unter ihnen entspricht jeder Eigenschaftswert einem Eigenschafts -Tag, und der Name des Namens Eigenschaft ist der Name der Eigenschaft in der Klasse. In der Bean -Implementierungsklasse verfügt es über die entsprechende Implementierungsmethode setUnername ().
Tipps: Spring prüft nur, ob die Bean eine Settermethode enthält, und erfüllt keine spezifischen Anforderungen dafür, ob entsprechende Attributvariablen vorhanden sind. Nach den herkömmlichen Regeln sollten wir jedoch die entsprechenden Attributvariablen dafür festlegen.
Benennungsspezifikationen für <Stief> -Tags im Frühjahr:
Im Allgemeinen beginnen Java -Attribut -Variablennamen mit Kleinbuchstaben. In Anbetracht einiger englischer Abkürzungen mit besonderen Bedeutungen ermöglichen Java -Bohnen auch variable Namen, beginnend mit Großbuchstaben. Die folgenden zwei Punkte müssen jedoch erfüllt sein:
Bei Attributinjektionsmethoden können Garantien nur in der Konfigurationsdatei künstlich bereitgestellt werden, jedoch können Garantien nicht auf Syntaxebene bereitgestellt werden. Zu diesem Zeitpunkt müssen Sie die Konstruktorinjektion verwenden, um die Anforderungen besser zu erfüllen.
2. Konstruktorinjektion
Die Konstruktorinjektion ist neben der Attributinjektion ein weiteres häufig verwendetes Injektionsmethode. Es kann sicherstellen, dass einige notwendige Eigenschaften festgelegt werden, wenn die Bohnen instanziiert werden und nach der Instanziierung verwendet werden können.
Die Voraussetzung für die Verwendung von Konstruktorinjektion ist, dass die Bohne einen Konstruktor mit Argumenten liefern muss.
Für die Konstruktorinjektion können Konfigurationsdateien auf folgende Weise verwendet werden:
【Übereinstimmung Parametereintragsmethode nach Typ】
Schreiben Sie Bean Code:
Paket com.kevin.bean;/** * Schreiben Sie Bean -Test, um Parameter mit Typ zu entsprechen privates Ganzzahlalter; public String getName () {return name; } public void setName (String -Name) {this.name = name; } public Integer getage () {Return Age; } public void setage (Ganzzahl älter) {this.age = älter; }}Konfigurationsdateien schreiben:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! <wert> kevin </value> </constructor-arg> <constructor-arg type = "Integer"> <wert> 20 </value> </constructor-arg> </beans>
Konfigurationsdateien von Spring verwenden Konfigurationsstrategien, die unabhängig von der Reihenfolge der Elementbezeichnungen sind. Daher kann die Sicherheit der Konfigurationsinformationen bis zu einem gewissen Grad garantiert werden.
Wenn dann mehrere Typparameter des Konstruktors in einer Bean gleich sind, kann es leicht zu Verwirrung führen, indem Parameter entsprechend dem Typ angepasst werden. Zu diesem Zeitpunkt ist eine andere Methode erforderlich: Matching -Parameter gemäß dem Index.
【Übereinstimmung Parameter nach Index】
Schreiben Sie Bean Code:
Paket com.kevin.bean;/** * Schreiben Sie Bean -Tests und -Parameter in die Indexmethode * @Author Kevin * */public class Student {private Zeichenfolge Name; privates String -Geschlecht; private doppelte Punktzahl; public student (String -Name, String -Geschlecht, Doppelpunktzahl) {Super (); this.name = name; this.Geper = Geschlecht; this.score = Score; }}Die Konfigurationsdatei wird wie folgt geschrieben:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! value = "kevin"> </constructor-arg> <constructor-arg index = "1" value = "male"> </constructor-arg> <constructor-arg index = "2" value = "66"> </constructor-Arg> </bean> </beans> </beans>
Tipps: Während der Eigenschaftsinjektion bestimmt Feder das Konfigurationsattribut und die entsprechende Settermethode gemäß den Spezifikationen der Java -Bean und verwendet den Java -Reflexionsmechanismus, um die Settermethode des Attributs aufzurufen, um die Eigenschaftsinjektion zu vervollständigen. Der Java -Reflexionsmechanismus erinnert sich jedoch nicht an den Parameternamen des Konstruktors, sodass wir den Konstruktor nicht konfigurieren können, indem wir den Parameternamen des Konstruktors formulieren, sodass wir die Eigenschaftsinjektion des Konstruktors durch den Parametertyp und den Parametertyp und den Index indirekt nur indirekt vervollständigen können.
【Kombinierte Verwendungstyp- und Index -Matching -Parameter】】
In einigen komplexen Konfigurationsdateien müssen Typ und Index gleichzeitig verwendet werden, um die Parameterinjektion des Konstruktors zu vervollständigen. Hier ist ein Beispiel zu demonstrieren.
Bohnen schreiben:
Paket com.kevin.bean;/** * Schreiben Sie Bean -Tests, um Typ- und Index -Matching -Parameter gemeinsam zu verwenden private String -Adresse; privates Doppelgehalt; privates int Alter; öffentlicher Lehrer (String -Name, String -Adresse, Doppelgehalt) {Super (); this.name = name; this.address = Adresse; this.Salary = Gehalt; } öffentlicher Lehrer (String -Name, String -Adresse, int Alter) {Super (); this.name = name; this.address = Adresse; this.age = Alter; }}In dieser Klasse gibt es zwei überlastete Konstruktoren, die alle drei Parameter haben. In diesem Fall kann die Verwendung der Typ- und Indexmethoden die Anforderungen nicht erfüllen. Zu diesem Zeitpunkt müssen beide Eigenschaften gleichzeitig verwendet werden.
Konfigurationsdatei:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! <wert> kevin </value> </constructor-arg> <constructor-arg index = "1" type = "string"> <wert> China </value> </constructor-arg> <constructor-arg Index = "2" Typ "int"
Sie können sehen, dass sich der Fokus tatsächlich auf den Typ des dritten Parameters befindet. Daher geben wir den Index an und tippen in der Konfigurationsdatei ein, damit der Feder wissen, welcher Konstruktor für Parameter einspritzen soll.
Tipps: Hinzufügen zu unserer Konfigurationsdatei gibt es ein Unklarheitsproblem. Der Frühlingscontainer kann normal gestartet werden und meldet keinen Fehler. Es wird zufällig einen passenden Konstruktor verwenden, um die Bohne zu instanziieren. Der zufällig ausgewählte Konstruktor wird möglicherweise nicht vom Benutzer benötigt. Daher sollten wir vorsichtig sein, um diese Mehrdeutigkeit bei der Programmierung zu vermeiden.
【Passen Sie die Parameter über seine eigene Typreflexion ab】】
Wenn der Typ des Bean -Konstruktorparameters erkennbar ist, da der Java -Reflexionsmechanismus den Typ des Konstruktorparameters erhalten kann, kann die Feder auch dann, wenn die Injektion des Konstruktors keine Typ- und Indexinformationen liefert, die Injektion von Konstruktorinformationen weiter vervollständigen. Beispielsweise kann im folgenden Beispiel der Parametertyp des Konstruktors der Manager -Klasse unterschieden werden.
Schreibmanagerklasse schreiben:
Paket com.kevin.bean;/** * Schreiben Sie einen Bean -Test, um Argumente über seine eigene Type Reflexion zu entsprechen privates Doppelgehalt; Privatperson; public Manager (String -Name, Doppelgehalt, Person Person) {Super (); this.name = name; this.Salary = Gehalt; this.person = Person; }}Konfigurationsdateien schreiben:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! </constructor-arg> <constructor-arg> <ref bean = "user"/> </constructor-arg> <constructor-arg> <ref bean = "person"/> </constructor-arg> </beans>
Die oben genannten Methoden können die Injektion von Konstruktorparametern implementieren. Um das Auftreten von Problemen zu vermeiden, wird empfohlen, explizite Index und Typen zur Konfiguration der Konstruktorparametereintragsinformationen zu verwenden.
3. Injektion der Fabrikmethode
Die Werksmethode ist ein Entwurfsmuster, das häufig in Anwendungen verwendet wird und auch die Hauptmethode zur Implementierung der Idee der Steuerinversion und des Einzelinstanzdesigns ist. Die Fabrikklasse ist dafür verantwortlich, eine oder mehrere Fabrikklasseninstanzen zu erstellen. Die Fabrikklassenmethode gibt im Allgemeinen die Zielklasseninstanz in Form einer Schnittstelle oder abstrakte Klassenvariable zurück.
Die Fabrikklasse blockiert die Instanziierungsschritte der Zielklasse extern, und der Anrufer muss nicht einmal angeben, was die spezifische Zielklasse ist. Da Federbehälter die Funktionalität von Werksmethoden in Framework -Methoden liefern und für Entwickler transparent offen sind. Daher ist es selten notwendig, technische Methoden manuell zu schreiben. In einigen Legacy-Systemen oder einer Bibliothek von Drittanbietern werden jedoch weiterhin technische Methoden auftreten. Zu diesem Zeitpunkt kann die Springfabrik -Injektionsmethode verwendet werden, um die Feder zu injizieren.
Springfabrik-Injektionsmethoden können in statische und nicht statische Unterschiede unterteilt werden.
【Nicht-statische Fabrikmethode】
Einige Fabrikmethoden sind nicht statisch und müssen so instanziiert werden, dass die Fabrikmethoden aufgerufen werden können. Das Folgende ist ein Beispiel zu demonstrieren.
Schreiben Sie die Fabrikklasse:
Paket com.kevin.factoryBean;/** * Schreiben Sie Fabrikklassen-Tests nicht statische Fabrikmethoden Injektion * @Author Kevin * */public class BookFactory {public book buybook () {book book = new book (); book.setName ("denken in java"); Rückbuch; }}Konfigurationsdatei schreiben:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <! factory-bean = "bookFactory" factory-method = "buybook"> </bean> </beans>
Da die Fabrikmethode des Buchfaktoriums nicht statisch ist, müssen Sie zuerst eine Bohne der Fabrikklasse definieren und dann über die Fabrikbekämpfung auf die Factory Bean-Instanz verweisen. Anschließend wird die entsprechende Fabrikmethode verwendet, um die entsprechende Fabrikmethode anzugeben.
【Statische Fabrikmethode】
Viele Fabrikklassenmethoden sind statisch, was bedeutet, dass Fabrikklassenmethoden aufgerufen werden können, ohne die Instanzen der Fabrikklassen zu erstellen. Daher sind statische technische Methoden bequemer und prägnanter als nicht-statische Fabrikmethoden. Das Folgende ist ein Beispiel, um die statische Fabrikmethode zu demonstrieren.
Schreiben Sie die Fabrikklasse:
Paket com.kevin.factoryBean;/** * Schreiben Sie Fabrikklassen -Test statische Fabrikmethode Injektion * @Author Kevin * */öffentliche Klassenkirzkarzinorie {public static Car CreateCar () {Car Car = new Car (); car.setbrand ("lamborghini"); Auto zurückkehren; }}Konfigurationsdateien schreiben:
<? xmlns: context = "http://www.springframework.org/schema/context" xsi: Schemalocation = "http://www.spingframework.org/schema/beans http://www.springramework.org/schema/beans/ http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd "> <!-Bean Definitionen hier-> <!
Zusammenfassen
Feder bietet drei optionale Injektionsmethoden, aber in tatsächlichen Anwendungen gibt es keinen einheitlichen Standard, für das wir wählen sollten. Hier sind einige Gründe, auf die Sie sich beziehen können:
Grund für die Konstruktorinjektion:
Eigenschaften Injektionsgrund:
Tatsächlich bietet Spring uns so viele Methoden zur Injektion von Parametern, daher müssen diese Methoden ihre eigenen Gründe haben. Jede Methode hat einzigartige Vorteile in einem bestimmten Problem. Wir müssen nur die entsprechende Methode entsprechend unseren spezifischen Nutzungsbedürfnissen auswählen, aber die Fabrikmethode -Injektion wird im Allgemeinen nicht empfohlen.
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.