Eine einfache Referenz für die Verwendung von Spring-IOC:
Analyse einfacher Fälle von Frühlings -IOC- und Scope -Attributen von Bohnen
1. Injizieren Sie verschiedene Datentypen durch die SET -Methode
Testklassencode (die in der festgelegten Methode injizierten Eigenschaften müssen mit der festgelegten Methode hinzugefügt werden)
/** Injektionsbeispiel über Set -Methode*/öffentliche Klasse ioc_by_set {/** Inject Injever -Typ Parameter*/private Integer id;/** String -Typ Parameter*/privater String -Name;/** Inject Entity Bean*/private Benutzer Benutzer;/** Inject Array*/private Object [] Array. einstellen;/** Kartenteilspaare injizieren*/private Karte <Objekt, Objekt> MAP;/** Injecteigenschaften Typ*/private Eigenschaften Eigenschaften;/** leere Zeichenfolge injizieren*/private Zeichenfolge leere Value;/** Inject Nullwert*/private String nullValue = ";/** Erkenntnis, ob alle injected the-Injected-Fitnerties sind. null) {return false;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Array) {System.out.println (Object.toString ());}} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ {System.out.println ("set:"); für (Objektobjekt: set) {System.out.println (Object.toString ());}} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ {System.out.println (Eintrag.getkey () + "|" + + Eintrag.getValue ());}} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Eintrag. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- setName (String name) {this.name = name;} public void setUser (Benutzerbenutzer) {this.user = user;} public void setArray (Objekt [] Array) {this.array = array;} public void setlist (list <eloct> {this.list = list;} öffentliches void void void set (set <eloction> set) {thisset = list; setMap(Map<Object, Object> map) {this.map = map;}public void setProperties(Properties properties) {this.properties = properties;}public void setEmptyValue(String emptyValue) {this.emptyValue = emptyValue;}public void setNullValue(String nullValue) {this.nullValue = nullValue;}}applicationContext.xml Konfiguration
<!-Injection-> <bean id = "ioc_by_set"> <!-Injektions-ID-Attribut-> <Eigenschaft name = "id" value = "1"/> <!-Verwenden <!-mit XML-Spezialzeichen mit <!-mit <! [[CDATA)> Tags --- <wert> <! [cdata [p & g]]> </value> </property> <!-Definieren der internen Bean-Injektion-> <Eigenschaft name = "Benutzer"> <bean> <Eigenschaft name = "id" value = "1"/> <Eigenschaft name = "Benutzername" value = "interne bean"/> </> </> -Stype "Passwart". name = "array"> <array> <!-Array-Elemente definieren-> <wert> array01 </value> <wert> array02 </value> <wert> array03 </value> </array> </Property> <!-Inject List Type-> <Eigentumsname "-Liste"> <! <wert> list03 </value> </list> </property> <!-Inject-Set-Typ-> <Eigentum> <Eigenschaft --- Definieren Sie Elemente in der Liste-> <wert> list02 </value> <Wert> list03 </value> </list> </property> <!-Inject-Set-Typ-> <property = "set"> </set> <! <value>set02</value> <value>set03</value> </set> </property> <!-- Inject Map type--> <property name="map"> <map> <!-- Define key-value pairs in map --> <entry> <key> <value>mapKey01</value> </key> <value>mapValue01</value> </entry> <entry> <key> <wert> MACKKEY02 </value> </key> <wert> mapValue02 </value> </Eintrag> </map> </property> <!-Injecteigenschaften Typen-> <Eigenschaftsname = "Eigenschaften"> <Props> <!-Define Key-Value-Paare in Eigenschaften-> <propKey = "propKey1"> KEY = "PropKey2"> propValue2 </prop> </props> </property> <!-Inject Leere String-> <Eigenschaft name = "leerValue"> <value> </value> </property> <!-Inject null Value-> <Eigentum name = "nullValue"> <null/> </> </</mection>
Testcode
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classPathXmlApplicationContext ("applicationContext.xml");}@test public void settie () {ioc_by_set ioc = (ioc_set ioc_set ioc = (ioc_set ic_set ic_set ctx.getbean ("ioc_by_set"); ioc.checkattr ();}}Konsolenergebnisse:
ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 3 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------/ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
2. Injizieren Sie verschiedene Arten von Attributen mit Baumethoden
Hinweis: Wenn Sie die JDK1.8-Version verwenden, aktualisieren Sie das Feder-JAR-Paket auf Version 4.x oder höher, ansonsten werden inkompatible Konstruktoren injiziert.
Testklassencode
/** Beispiel für die Injektion durch Konstruktor*/öffentliche Klasse ioc_by_constructor {private Integer id; privater String -Name; private Benutzer Benutzer; private Liste <Objekt> Liste; public ioc_by_constructor () {} public ioc_by_constructor (integer id, user user. Liste;}/** Überprüfen Sie, ob die Injektion erfolgreich ist. id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + "|" + user.getUserName () + | " + user.getPassword ());} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- WAHR;}}applicationContext.xml Konfiguration
<!-Konstruktor-Arg value = "p & g"/> <!-Injektionsobjekt-> <bean id = "ioc_by_constructor"> <!-Injektionsobjekt-> <bean> <constructor-arg value = "1" type = "java.lang.Integer"/> <!-Injection String-> <Constructor-ARGOR-Wert-> <-> <constructor-arr-value = "p & g"/> <--> <constructor-arr-value = "p & gr. <constructor-arg> <!-integriertes Objekt-> <bean> <constructor-arg value = "1"/> <constructor-arg value = "Konstruktionsinnere Bean"/> <constructor-arg value = "666"/> </bean> </constructor-arg> <! <wert> list02 </value> <wert> list03 </value> </list> </constructor-arg> </bean>
Testcode:
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classPathXmlApplicationContext ("ApplicationContext.xml"); ctx.getbean ("ioc_by_constructor"); ioc.checkattr ();}}Konsolenergebnisse:
ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ! !
3. Automatische Injektion (automatische Montage)
Obwohl die automatische Montage einen Code sparen kann, wird nicht empfohlen, ihn zu verwenden
Testklassencode:
/** Auto -Assembly -Injektion*/öffentliche Klasse ioc_by_auto {privater Benutzer Benutzer;/** Überprüfen Sie, ob die Injektion erfolgreich ist user.getPassword ());} system.out.println ("Richtig !!!"); true;}/** Das automatische Assembly -Attribut erfordert das Einstellen der festgelegten Methode*/public void setUser (Benutzerbenutzer) {this.user = user;}}applicationContext.xml Konfiguration
<!-Bohnen, die von automatischer Assemblierung erhalten wurden-> <bean id = "user"> <Eigenschaft name = "id" value = "1"/> <Eigenschaft name = "userername" value = "auto-assembly"/> <Eigenschaftsname = "Passwort" value = "233"/> </> </bean> <! Eigenschaftstyp der Klasse. Wenn mehrere Bohnen übereinstimmen, werfen Sie einen Ausnahmekonstruktor entsprechend dem Konstruktorparametertyp der Klasse mit der entsprechenden Bean. Nein. Standardend, bedeutet, dass die automatische Montage-Standardeinstellung nicht verwendet wird: Bestimmt durch die Standardeigenschaft des oberen Etiketts <Beans>-> <bean id = "ioc_by_auto" autoWire = "byname"> </bean>
Testcode
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classPathXmlApplicationContext ("ApplicationContext.xml");}@test public void autotest () {IOC_By_By_By_By_By_By_By_By_By_By_By_By_By_By_By_By_Auto ioc = (IOC_BY_BY_BY_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO_AUTO. ctx.getbean ("ioc_by_auto"); ioc.checkattr ();}}Konsolenergebnisse
Benutzer: 1 | Automatische Montage | 233 ist korrekt! ! !
Das obige wird im ByName -Modus verwendet. Der Konfigurationscode anderer Modi wurde angegeben und es werden keine Tests durchgeführt.
4. Inject Attribute mit dem P -Namespace injizieren
Testklassencode
/** Injektion mit P -Namespace*/public class ioc_by_p {private Integer id; privater String -Name; privater Benutzerbenutzer;/** Überprüfen Sie, ob die Injektion erfolgreich ist id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ id) {this.id = id;} public void setName (String -Name) {this.name = name;} public void setUser (Benutzer Benutzer) {this.user = user;}}applicationContext.xml Konfiguration
<!-Injizieren Sie verschiedene Arten von Eigenschaften mit dem P-Namespace-> <bean id = "user2"> <Eigenschaft name = "id" value = "1"/> <Eigenschaft name = "userername" value = "p"/> <Eigenschaft name = "password" value = "233"/> </bean> <bean id = "ioc_By_p" p: id P: user-ref = "user2"> </bean>
Testcode
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classPathXmlApplicationContext ("ApplicationContext.xml"); ctx.getbean ("ioc_by_p"); ioc.checkattr ();}}Konsolenergebnisse
ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ! !
5. Injektion mit Annotationsmethode
Spring hat nach 3.0 Annotations-basierte Injektion bereitgestellt.
1.@AutoWired-Annotation von Mitgliedsvariablen, Methoden und Konstruktoren, um die automatischen Baugruppenarbeit zu vervollständigen. Es wird nicht empfohlen, es zu verwenden.
2. @qualifier-combiniert mit @autowired, um die Montage mehrerer Bohnen desselben Typs zu lösen
3. Die Funktion @Resource-JSR-2550 Standard-Annotation entspricht @autowired, aber @Autowired wird automatisch nach Bytype injiziert, während @Resource standardmäßig nach ByName automatisch nach ByName injiziert wird.
4. @postconstruct - Annotation @Postconstruct in die Methode hinzufügen, und diese Methode wird vom Federbehälter nach der Initialisierung der Bean ausgeführt.
5. @prädestroy-add Annotation @Predestroy Auf der Methode wird diese Methode nach der Initialisierung der Bean ausgeführt.
6. @-Komponenten nur eine @Component-Annotation zur entsprechenden Klasse hinzufügen, die Klasse ist als Bohne definiert. Es wird nicht empfohlen, es zu verwenden. Es wird empfohlen, drei weitere raffinierte Typen zu verwenden: @Repository, @Service, @Controller
@Repository Storage Layer Bean
@Service Business Layer Bean
@Controller Display Layer Bean
7.@scope definieren Sie den Umfang der Bohne
Konfigurieren Sie zuerst applicationContext.xml, um Annotation zu aktivieren
<!-scannen Sie die kommentierte Klasse im Paket-> <Kontext: Komponenten-scan-Basis-Package = "com.bc.ioc.demo05"/>
Entitätsbean Annotation
@RepositoryPublic Class User {private Integer id = 1; private String username = "Annotationsinjektion"; private String password = "233"; public user () {super ();} public user (Integer id, String username, String Passwort) {Super (); this.id = id; String getUnername () {return username;} public String getPassword () {zurückgegebenes Passwort;} public void setId (Integer id) {this.id = id;} public void setUnername (String -Benutzername) {thisername = username;} public void setword (String Password) {this.password = Passwort;Annotation der Klassencode testen
/** Inject Attribute mit Annotationen injizieren*/@service ("ioc_by_annotation") public class ioc_by_annotation {@resource privater Benutzer. {System.out.println ("Benutzer:" + user.getId () + "|" + user.getUnername () + "|" + user.getPassword ();} System.out.println ("Richtig !!!"); Return;}}Testcode
public class IoC_Test {private ApplicationContext ctx;@Before public void load() {//Read applicationContext.xml configuration file ctx = new ClassPathXmlApplicationContext("applicationContext.xml");}@Test public void annotationTest() {IoC_By_Annotation ioc = (IoC_By_Annotation) ctx.getbean ("ioc_by_annotation"); ioc.checkattr ();}}Konsolenausgabe
Nach dem Testen mit Annotationsinjektion. Wenn die applicationContext.xml mit anderen Injektionsmethoden konfiguriert ist, wird ein Fehler gemeldet, wodurch auch andere Injektionsmethoden abnormal sind.
Benutzer: 1 | Annotationsinjektion | 233 ist korrekt! ! !
6. Bean -Injektion durch Konfiguration der statischen Fabrikmethode
Statischer Fabrikcode
/** statische Fabrik*/public class staticFactory {public static Integer getId () {return 1;} public static String getName () {return "statische Fabrik";} public static user getUser () {neuer Benutzer zurückgeben (1, "Factory User", "666");Testklassencode
/** Injektion durch statische Fabrik*/öffentliche Klasse ioc_by_staticFactory {private Integer id; privater String -Name; privater Benutzer Benutzer;/** Überprüfen Sie, ob die Injektion erfolgreich ist. id);}System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ id) {this.id = id;} public void setName (String -Name) {this.name = name;} public void setUser (Benutzer Benutzer) {this.user = user;}}applicationContext.xml Konfiguration
<!-- Configuring the static factory method Bean is actually configuring the value returned by the factory method as a bean --> <bean id="factory_id" factory-method="getId"/> <bean id="factory_name" factory-method="getName"/> <bean id="factory_user" factory-method="getUser"/> <bean id = "ioc_by_staticFactory"> <Eigenschaft name = "id" ref = "factory_id"/> <Eigenschaft name = "name" ref = "factory_name"/> <Eigenschaft name = "user" ref = "factory_user"/> </bean>
Testcode
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classPathXmlApplicationContext ("applicationContext.xml");}@test Public staticfactorytoryt () {ioc_byfactoryfactory iocfactory_bactory_bym_bym_staticfactory ctx.getbean ("ioc_by_staticFactory"); ioc.checkattr ();}}Konsolenausgabeergebnisse
ID: 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ! !
7. Injektion durch die Beispielfabrikmethode
Der Unterschied zu einer statischen Fabrik besteht darin, dass die Instanzfabrik nicht statisch ist. Sie müssen das erste neue Instanzfabrikobjekt benötigen, bevor Sie seine Methode konfigurieren können. Das neue Objekt wird auch vom Frühling verwaltet.
Fabrikcode
/** Instance Factory*/Public Class Factory {public Integer getId () {return 1;} public String getName () {return "Instance Factory";} public User getUser () {neuer Benutzer zurückgeben (1, "Instance Factory User", "233");}}}}}}}}Testklassencode
/** Instance Factory Injection*/public class ioc_by_factory {private Integer id; privater String -Name; privater Benutzer Benutzer;/** Überprüfen Sie, ob die Injektion erfolgreich ist id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ id) {this.id = id;} public void setName (String -Name) {this.name = name;} public void setUser (Benutzer Benutzer) {this.user = user;}}applicationContext.xml Konfiguration
<!-Konfigurieren Sie die Instanzfabrik-Bean-> <bean id = "factory"/> <!-Konfigurieren Sie die Instanz-Factory-Methode Bean-> <bean id = "f_id" factory-bean factory-bean = "factory" factory-method = "getUser"/> <!-Inject die entsprechende Instanz-Factory-Methode Bean-> <bean id = "ioc_by_factory"> <Eigenschaft name = "id" ref = "f_id"/> <Eigenschaft name = "name" rebell
Testklassencode
public class ioc_test {private applicationContext ctx; @before public void load () {// applicationContext.xml Konfigurationsdatei ctx = new classpatHxMlApplicationContext ("applicationContext.xml");}@test Public void FactoryTest () {ioc_by_bactory ioc = factory ioc_factory ioc_factory ioc_factory ioc_factory ioc_factory ctx.getbean ("ioc_by_factory"); ioc.checkattr ();}}Konsolenausgabe
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ! !
Zusammenfassen
In dem oben genannten Artikel geht es um diesen Artikel, in dem die Injektionsmethode des Spring -IOC und die Injektion verschiedener Datentypen erörtert wird. Ich hoffe, es wird für alle hilfreich sein. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!