1. Abhängigkeitsinjektion (DI)
Die Abhängigkeitsinjektion klingt sehr tiefgreifend, aber in der Tat ist es: Zuordnungswerte zuweisen. Insgesamt gibt es zwei Methoden. Die erste ist in Form von Konstruktorparametern und die andere in Form der Einstellungsmethode.
1 Konstruktorinjektion
1 Injektion mit dem Konstruktor
Injektionsmethode unter Verwendung von XML
A. Reihenfolge der Parameter
<constructor-arg index = "0"> <wert> Zhang sAN </value> </constructor-arg>
<constructor-arg index = "1"> <wert> 56 </value> </constructor-arg>
B. Art des Parameters
<constructor-arg type = "java.lang.InEger"> <wert> 56 </value> </constructor-arg>
<constructor-arg type = "java.lang.String"> <wert> Zhang SAN </value> </constructor-arg>
Spezifische Beispiele
Wenn Sie jetzt Parameter in eine Personenklasse einbringen möchten, ist der Schüler eine andere Klasse.
public class Person {private String pid; privater Zeichenfolge Name; Privatstudent; öffentliche Person (String PID, Student Student) {this.pid = pid; this.student = Student; } public Person (String PID, String -Name) {this.pid = pid; this.name = name; }}Konfigurieren Sie applicationContext.xml. Wenn keine Parameterkonfiguration durchgeführt wird, wird ein Fehler gemeldet und der entsprechende Konstruktor kann nicht gefunden werden. Wenn die entsprechenden Parameter konfiguriert sind, sollte der entsprechende Konstruktor in der Klasse deklariert werden.
<? XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-Beans-2.5.xsd"> <Bean id = "Person. Ein Konstruktor persönlich ist die Winkelmarkierung des Parameters. Der Typwert des Parameters. Wenn es sich um eine grundlegende Eigenschaft handelt, verwenden Sie diesen Zuweisungs-Ref, um auf die Typ-Zuweisung-> <constructor-arg index = "0" type = "java.lang.String" value = "aaa"> </constructor-arg> <constructor-arg Index = "1" ref = "student"> </konstruktor-arg> </lean> </leer> </leer> </leer> </leer> </leer> </leeres </leeres. value = "1"> </property> </bean> <bean id = "student"> </bean> </beans>
Schreiben Sie die Testklasse DIXMLConstructOrTest und führen Sie Breakpoint -Debugging durch. Sie werden feststellen, dass der eingegebene Konstruktor gemäß den Konfigurationsparametern Person ist (String PID, Student)
public class dixmlConstructOrst {@test public void Test1 () {applicationContext context = new classPlaPlApplicationContext ("applicationContext.xml"); Person Person = (Person) context.getbean ("Person"); }}2 Injektion unter Verwendung der Eigenschaft Setter -Methode
Injektionsmethode unter Verwendung von XML:
A. Injektion einfacher Bohnen einfache Bohnen enthalten zwei Arten: Verpackungstyp und String
<bean id = "personSservice"> <!-Grundtyp, String-Typ-> <Eigenschaft name = "Alter" value = "20"> </property> <Eigenschaft name = "name" value = "zhang wuji"> </property> </bean>
B. andere Bohnen zitieren
<bean id = "person" /> <bean id = "personSservice"> <Eigenschaft name = "Person" Ref = "Person" /> < /bean>
1.1 Sammlung der Montageliste
<Eigenschaft name = "lists"> <list> <wert> list1 </value> <wert> list2 </value> <ref bean = "Person"/> </list> </Eigenschaft>
1.2 Montage -Set -Sammlung
<Eigenschaft name = "sets"> <set> <wert> list1 </value> <wert> list2 </value> <ref bean = "Person"/> </set> </Eigenschaft>
1.3 Montagekarte
<Eigenschaft name = "maps"> <map> <Eintragsetaste = "01"> <wert> MAP01 </value> </Eintrag
Der Wert von <eintrag> in der Karte entspricht dem von <List> und <Set>, was jedes gültige Attributelement erstellen kann. Es ist zu beachten, dass der Schlüsselwert String sein muss.
1.4 Montageeigenschaften
<Eigenschaft name = "props"> <props> <propet key = "01"> prop1 </prop> <propt key = "02"> prop2 </prop> </props> </property>
Spezifische Beispiele
1. Erstellen Sie zwei Objekte Person und Schüler
Paket xgp.spring.demo; import java.util.list; import Java.util.map; Import Java.util.Properties; import Java.util.set; public class Person {private String pid; privater Zeichenfolge Name; Privatstudent; private Listenlisten; private Sets; private Karte Karte; private Eigenschaften Eigenschaften; privates Objekt [] Objekte; public Person () {System.out.println ("neue Person"); } // Getter- und Setter -Methoden weglassen} Paket xgp.spring.demo; öffentliche Klasse Student {public student () {System.out.println ("neuer Student"); } public void sagt () {System.out.println ("Student"); }}Konfigurieren Sie die Datei applicationContext.xml
<? XSI: Schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-Beans-2.5.xsd"> <! Wenn die Eigenschaft ein Referenztyp ist, verwenden Sie Ref, um Wert zuzuweisen-> <bean id = "person" init-method = "init" Lazy-init = "true"> <Eigenschaft name = "pid" value = "1"> </Eigenschaft> <Eigenschaft name = "name" value = "wang ermazi"> </property> <Eigentum ". <value>list2</value> <ref bean="student"/> </property> <property name="sets"> <set> <value>set1</value> <value>set2</value> <ref bean="student"/> </set> </property> <property name="map"> <map> <entry key="entry1"> <value>map1</value> </entry> <entry key="entry2"> <ref bean="student"/> </entry> </map> </property> <property name="properties"> <props> <!-- No reference type required--> <prop key="prop1">prop1</prop> <prop key="prop2">prop2</prop> </props> </property> <property name="objects"> <list> <value>aa</value> <value>bb</value> </list> </Property> </bean> <bean id = "student"> </bean> </beans>
Schreiben Sie eine Testklasse DixMlSetterTest
Paket xgp.spring.test; import org.junit.test; import org.springframework.context.applicationContext; 1. Was macht Federbehälter? (1) Starten Sie den Federcontainer* (2) Erstellen Sie ein Objekt für die beiden Beans von Person und Student* (3) Analysieren Sie das Namensattribut der Eigenschaft, spleißen Sie die Setter -Methode an, analysieren Sie den Wert* Wert oder REF -Attribute der Eigenschaft, übergebenen Parameter an die Settermethode und verwenden Sie die Reflexionstechnologie, um Werte dem Objekt zuzuweisen. * (4) Extrahieren Sie das Objekt aus dem Federbehälter und rufen Sie die Methode des Objekts auf. * 2. Was ist die Ausführungsreihenfolge von Federbehältern? */ @Test public void test1 () {applicationContext context = new classSpathXmlApplicationContext ("ApplicationContext.xml"); Person Person = (Person) context.getbean ("Person"); System.out.println (person.getPID ()); System.out.println (person.getName ()); System.out.println (person.getLists ()); System.out.println (person.getsets ()); System.out.println (person.getMap ()); System.out.println (person.getObjects (). Länge); }}/*1 wang wu [list1, list2, xgp.spring.demo.student@76a9b9c] [set1, set2, xgp.spring.demo.student@76a9b9c] {Eintrag1 = MAP1, Eintrag2 = MAP2} 2*/////////////////////////////////////////////////Map2} 2*///////////////////MAP2} 2*///////////////////Map2} 2*///////////////////Map2} 2*////////////////////Map2} 2*///////////////////Jungen Die Ausführungsreihenfolge von Federbehältern
1. Alle sind Standardeinstellungen
2. Setzen Sie den Schüler (Lazy-init = true)
3.. Setzen Sie Person (Lazy-init = true)
Zusammenfassen
Es gibt zwei Methoden, um Parameter zu injizieren. Der Konstruktor muss den entsprechenden Konstruktor schreiben, der Setter muss die entsprechende Settermethode generieren und der Standardkonstruktor wird geschrieben.
2.5 Die Bedeutung von IOC und DI
Was bedeutet nach dem Erlernen dieser, es zu entdecken? Schreiben wir ein Beispiel für ein Dokumentverwaltungssystem, um die Anforderungen zu veranschaulichen. Siehe Abbildung unten
1. Schreiben Sie eine Dokumentoberfläche
public interface document {public void read (); public void write ();}2. Schreiben Sie Implementierungsklassen WordDocument, Exceldocument, PDFDocument
public class wordDocument implementiert dokument {public void read () {System.out.println ("Word Read"); } public void write () {System.out.println ("Word write"); }}3. Schreiben Sie ein Dokumentmanager -System
öffentliche Klasse DocumentManager {privates Dokument; public void setDocument (Dokument dokument) {this.document = document; } public documentManager () {} public documentManager (Dokumentdokument) {Super (); this.document = document; } public void read () {this.document.read (); } public void write () {this.document.write (); }}4. Schreiben Sie einen Testunterrichtsdokumenttest
/*** Mit IOC und DI können Sie eine vollständige interface-orientierte Programmierung erreichen * Diese Codezeile ist nicht vollständig interface-orientierte Programmierung, da eine bestimmte Klasse auf der rechten Seite des gleichen Vorzeichens erscheint DocumentManager documentManager = new DocumentManager (Dokument); documentManager.read (); documentManager.write (); } /*** Auf der Codeseite weiß ich nicht, wer das Dokument implementiert. This is determined by the spring configuration file* <bean id="documentManager" > <!-- document is an interface--> <property name="document"> <!-- wordDocument is an implementation class, assigned to the document interface--> <ref bean="pdfDocument"/> </property> </bean> */ @Test public void testDocument_Spring(){ ApplicationContext context = new ClassPathXmlApplicationContext ("ApplicationContext.xml"); DocumentManager documentManager = (documentManager) context.getbean ("documentManager"); documentManager.read (); documentManager.write (); }}Aus dem obigen können wir den Unterschied zwischen der Nichtanwendung der Feder und der Federinformation erkennen
<!-DocumentManager, WordDocument, Exceldocument, pdfdocument in Spring Container-> <bean id = "WordDocument"> </bean> <bean id = "exceldocument"> </bean> <bean id = "pdfdocument"> </bean> <bean id = "pdfdocument"> </bean> <Bean> <Bean> <Bean> "pdfdocument"> </bean> <Bean> <Bean> pdfdocument " <!-Dokument ist eine Schnittstelle-> <Eigenschaft name = "document"> <!-WordDocument ist eine Implementierungsklasse, die der Dokumentschnittstelle zugewiesen ist-> <ref bean = "pdfdocument"/> </property> </bean>
Die Verwendung von Spring erfordert nur das Konfigurieren des entsprechenden <ref bean = ""> Objekt im ApplicationContext, ohne auf bestimmte Implementierungsklassen zu achten und eine vollständige interface-orientierte Programmierung zu implementieren. Aus diesem Grund kann sich Spring in so viele Werkzeuge integrieren.
2.6 MVC -Instanzsimulationsstrukturen2
Anforderung Beschreibung
Erstellen Sie ein Projektverzeichnis
Codierung:
1. Erstellen Sie eine DAO -Ebene, um eine Persondao -Schnittstelle zu erstellen und eine PersondaoImpl -Klasse zu implementieren
public interface persondao {public void SavePerson ();} öffentliche Klasse PERONDAOIMPL implementiert PERONDAO {@Override public void savePerson () {System.out.println ("Save Person"); }}2. Erstellen Sie eine Serviceschicht, eine Personalservice -Schnittstelle und eine Implementierungsklasse von PersonenserviceImpl
public interface pensonservice {public void SavePerson ();} öffentliche Klasse personSserviceImpl implementiert personSservice {private persondao persondao; public void setpersondao (persondao persondao) {this.persondao = persondao; } @Override public void SavePerson () {this.Persondao.saveperson (); }}3.. Aktion erstellen, Personala -Klasse
Persönliche Klassenpersönlichkeit {private Personenservice personenservice; public void setpersonService (personSservice personSservice) {this.PersonService = personSservice; } public void SavePerson () {this.PersonService.saveperson (); }}4. Konfigurieren Sie applicationContext.xml
<!-Setzen Sie den Service, DAO, Aktionsklasse in den Frühlingscontainer-> <bean id = "persondao"> </bean> <bean id = "pelsonService"> <Property name = "persondao"> <ref bean </Property> </bean>
5. Testklassen testMVC schreiben
public class mvCtest {@test public void testMvc () {applicationContext context = new classPhodexMlApplicationContext ("applicationContext.xml"); Personalaction personaction = (personaction) context.getbean ("personalaction"); personaction.saveperson (); // Person retten}}Das obige Beispiel zeigt deutlich die interface-orientierte Programmierung von Frühling. Die Serviceschicht muss nur die Schnittstelle der DAO -Ebene aufrufen, muss jedoch nicht auf die Implementierungsklasse der DAO -Ebene achten, und die Aktion muss nur die Schnittstelle des Dienstes aufrufen, muss jedoch nicht auf die Implementierungsklasse des Dienstes achten.
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.