Une référence simple pour l'utilisation de Spring-IOC:
Analyse des instances simples de Spring IOC et des attributs de portée des haricots
1. Injecter différents types de données via la méthode définie
Code de classe de test (les propriétés injectées dans la méthode SET doivent être ajoutées avec la méthode SET)
/ ** Exemple d'injection via la méthode définie * / classe publique IOC_BY_SET {/ ** Inject Integer Type Paramètre * / ID privé entier; / ** Inject Type de chaîne Paramètre * / Nom de chaîne privée; / ** Inject Entity Bean * / Utilisateur privé User; / ** inject Array set; / ** injecter les paires de valeurs de clés de cartes * / mappe privée <objet, objet> map; / ** injecter les propriétés Type * / Propriétés privées Propriétés; / ** Inject String vide * / private String videValue; / ** Inject Null Value * / Private String NullValue = ""; / ** Detection {if (id == Les propriétés injectées sont correctes * / Public BoolaRt () null) {return false;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- tableau) {System.out.println(object.toString());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println ("set:"); pour (objet objet: set) {System.out.println(object.toString());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println (entry.getKey () + "|" + entry.getValue());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Entry.getValue ());}} System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- setName(String name) {this.name = name;}public void setUser(User user) {this.user = user;}public void setArray(Object[] array) {this.array = array;}public void setList(List<Object> list) {this.list = list;}public void setSet(Set<Object> set) {this.set = set;}public void setMap (map <objet, objet> map) {this.map = map;} public void SetProperties (Properties Properties) {this.properties = propriétés;} public void SetEmptyValue (String videValue) {this.emptyValue = videValue;} public vide SetNullValue (string nullvalue) {this.nul nullvalue;}}Configuration d'applicationContext.xml
<! - Définissez l'injection -> <bean id = "ioc_by_set"> <! - Attribut ID d'injection -> <propriété name = "id" value = "1" /> <! - Utilisation de <! - Gestion des caractères spéciaux xml avec <! - en utilisant <! [CDATA []]> Tags ---> <propriété name = "name"> <! - Vous pouvez également utiliser p & g -> <value> <! [cdata [p & g]]> </value> </ propriété> <! - Définition de l'injection de bean interne -> <propriété name = "user"> <ean> <propriété name = "id" value = "1" /> <propriété name = "username" value = "Internal bean" /> <propriété name = "word" value -> </prewetwater> <wetwetwetweft name = "Array"> <Barray> <! - Définir les éléments de la table -> <value> array01 </value> </value> array02 </value> <value> array03 </value> </ray> </ propriété> <! - injecter la liste -> <propriété name = "list"> <list> <! - Define Elements in list -> <value> list01 </value> <! <value> list03 </value> </ list> </ propriété> <! - Inject Set Type -> <propriété> <propriété --- Définissez les éléments dans List -> <Value> List02 </ Value> <value> List03 </ Value> </sist> </ Property <value> set02 </value> <value> set03 </value> </ set> </ propriété> <! - Injecter le type de carte -> <propriété name = "map"> <map> <! - Définir les paires de valeurs clés dans MAP -> <preny> <ey <value> mapkey02 </value> </ key> <value> mapValue02 </value> </ntry> </aph> </ propriété> <! - Inject Properties Types -> <propriété name = "Properties"> <props> <! - Définir des paires de valeurs de clé dans les propriétés -> <prop key = "propke1"> proPvalue1 </p> <prop> key = "propKey2"> PropValue2 </prop> </props> </ propriété> <! - Injecter la chaîne vide -> <propriété name = "videValue"> <value> </value> </ propriété> <! - Inject Null Value -> <propriété name = "nullValue"> <null /> </prewet> </Eple>
Code de test
classe publique IOC_TEST {private applicationContext ctx; @Before public void lody () {// read applicationContext.xml File de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void Settest () {ioc_by_set ioc = (ioc_by_set) ctx.getBean ("ioc_by_set"); ioc.checkattr ();}}Résultats de la console:
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
2. Injecter différents types d'attributs par le biais de méthodes de construction
Remarque: Lorsque vous utilisez la version JDK1.8, veuillez mettre à niveau le package JAR lié à Spring vers la version 4.x ou supérieure, sinon les constructeurs incompatibles seront injectés.
Code de classe de test
/ ** Exemple d'injection via le constructeur * / classe publique IOC_BY_CONSTRUCTOR {ID privé entier; nom de chaîne privée; utilisateur privé User; Liste privée <objet> liste; public ioc_by_constructor () {} public ioc_by_constructor (INTER ID, String name, utilisateur, list <object> list) {this.id = id; this.name = nom; list;} / ** Vérifiez si l'injection est réussie * / public boolean checkAttr () {if (id == null) {return false;} else {System.out.println ("id:" + id);} System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + "|" user.getPassWord());}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- vrai;}}Configuration d'applicationContext.xml
<! - Constructor-arg value = "p & g" /> <! - objet d'injection -> <bean id = "ioc_by_constructor"> <! - Objet d'injection -> <ean> <constructor-arg value = "1" type = "java.lang.integer" /> <! <! - Objet intégré -> <an Bean> <Constructor-Arg Value = "1" /> <Constructor-Arg Value = "Construction Internal Bean" /> <Constructor-Arg Value = "666" /> </anEn> </ Constructor-Arg> <! - Inject Collection -> <constructor-arg> <lish </sist> </ Constructor-Arg> </bEAN>
Code de test:
public class ioc_test {private applicationContext ctx; @Before public void load () {// read applicationContext.xml Fichier de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void ConstructOrest () {ioc_by_constructor ioc = (ioc_by_constructor) ctx.getBean ("ioc_by_constructor"); ioc.checkattr ();}}Résultats de la console:
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
3. Injection automatique (assemblage automatique)
Bien que l'assemblage automatique puisse enregistrer du code, il n'est pas recommandé de l'utiliser
Code de classe de test:
/ ** Assemblée automatique injection * / classe publique IOC_BY_AUTO {Uservy User; / ** Vérifiez si l'injection est réussie * / public boolean checkAttr () {if (user == null) {return false;} else {System.out.println ("user:" + user.getid () + "|" + user.getunerame () + "|" | user.getPassword ());} System.out.println ("correct !!!"); return true;} / ** L'attribut d'assemblage automatique nécessite de définir la méthode set * / public void SetUser (utilisateur utilisateur) {this.user = user;}}Configuration d'applicationContext.xml
<! - Beans obtenus par assemblage automatique -> <bean id = "user"> <propriété name = "id" value = "1" /> <propriété name = "username" value = "auto-assembly" /> <propriété name = "mot de passe" value = "233" /> </ bee classe. Si plusieurs haricots correspondent, lancez un constructeur d'exception correspond au bean correspondant en fonction du type de paramètre du constructeur de la classe. Non. Par défaut, signifie que l'assemblage automatique par défaut n'est pas utilisé: déterminé par la propriété par défaut-Autowire de l'étiquette supérieure <bans> -> <bean id = "ioc_by_auto" Autowire = "byname"> </ank>
Code de test
public class ioc_test {private applicationContext ctx; @Before public void lost () {// read applicationContext.xml Fichier de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void autotest () {ioc_by_auto ioc = (ioc_by_auto) ctx.getBean ("ioc_by_auto"); ioc.checkattr ();}}Résultats de la console
Utilisateur: 1 | Assemblage automatique | 233 est correct! ! !
Ce qui précède utilise le mode byname. Le code de configuration des autres modes a été indiqué et aucun test n'est effectué.
4. Injecter les attributs à l'aide de l'espace de noms P
Code de classe de test
/ ** Injection Utilisation de P namespace * / public class ioc_by_p {private Integer id; name de chaîne privée; utilisateur d'utilisateur privé; / ** Vérifiez si l'injection est réussie * / public boolean checkAttr () {if (id == null) {return false;} else {system.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (String name) {this.name = name;} public void setter (utilisateur utilisateur) {this.user = user;}}Configuration d'applicationContext.xml
<! - Injectez différents types de propriétés à l'aide de l'espace de noms p -> <bean id = "user2"> <propriété name = "id" value = "1" /> <propriété name = "username" value = "p" /> <propriété name = "mot de passe" value = "233" /> </ bean> <bean id = "ioc_by_p" p: id = "1" p: nom = " p: user-ref = "user2"> </ank>
Code de test
public class ioc_test {private applicationContext ctx; @before public void load () {// read applicationContext.xml File de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void ptest () {ioc_by_p ioc = (ioc_by_p) ctx.getBean ("ioc_by_p"); ioc.checkattr ();}}Résultats de la console
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
5. Injecter en utilisant la méthode d'annotation
Le printemps a fourni une injection basée sur l'annotation après 3,0.
1. @ ANNOTATION AUTOWIRED des variables, méthodes et constructeurs des membres pour terminer les travaux d'assemblage automatique. Il n'est pas recommandé de l'utiliser.
2. @ qualificatif de qualification avec @Autowired pour résoudre l'assemblage de plusieurs haricots du même type
3. @ Resource-JSR-250 Annotation standard, la fonction est équivalente à @Autowired, mais @Autowired est automatiquement injecté selon ByType, tandis que @Resource est automatiquement injecté selon ByName par défaut.
4. @ PostConstruct - Ajouter une annotation @postConstruct à la méthode, et cette méthode sera exécutée par le conteneur de ressort après l'initialisation du bean.
5. @ ANNOTATION ADD-ADD @predestroy sur la méthode, cette méthode sera exécutée par le conteneur de ressort après l'initialisation de Bean.
6. @ Composant uniquement Ajouter une annotation @component à la classe correspondante, la classe est définie comme un bean. Il n'est pas recommandé de l'utiliser. Il est recommandé d'utiliser trois autres types raffinés: @Repository, @Service, @Controller
@Repository Storage Cose Bean
@Service Business Layer Bean
@Controller Affichage de la couche Affichage Bean
7. @ Définir la portée du haricot
Configurer d'abord ApplicationContext.xml pour activer l'annotation
<! - Scannez la classe annotée dans le package -> <Context: Component-Scan Base-Package = "com.bc.ioc.demo05" />
Annotation des haricots d'entité
@RepositoryPublic class utilisateur {private Integer id = 1; private String username = "Annotation injection"; private String password = "233"; public user () {super ();} public utilisateur (id id, string userName, string password) {super (); this.id = id; this.Username = username; this.password = mot de passe; id;} public String getUserName () {return username;} public String getPassword () {return password;} public void setid (INTERN id) {this.id = username;} public seserername (String username) {this.userName = username;} public Void SetPassword (String password) {this.password = mot de passe;}}Annotation du code de la classe de test
/ ** Inject Attributes Utilisation d'annotations * / @ service ("ioc_by_annotation") classe publique IOC_BY_Annotation {@Resource Private User User; public void SetUser (utilisateur utilisateur) {this.user = user;} / ** Vérifiez si l'injection est réussie * / public booléen checkArTr () {if (user == null) {return false;} {System.out.println ("user:" + user.getId () + "|" + user.getUsername () + "|" + user.getPassword ());} System.out.println ("correct !!!"); return true;}}Code de test
public class ioc_test {private applicationContext ctx; @Before public void load () {// read applicationContext.xml Fichier de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void annotationtest () {ioc_by_annotation ioc = (ioc_by_annotation) ctx.getBean ("ioc_by_annotation"); ioc.checkattr ();}}Sortie de la console
Après les tests, en utilisant l'injection d'annotation. Si l'applicationContext.xml est configuré avec d'autres méthodes d'injection, une erreur sera signalée, ce qui entraînera également une autre méthode d'injection.
Utilisateur: 1 | Injection d'annotation | 233 est correct! ! !
6. Injection de bean en configurant la méthode d'usine statique
Code d'usine statique
/ ** Static Factory * / public class staticfactory {public static Integer getID () {return 1;} public static string getName () {return "static factory";} public static utilisateur getuser () {return nouvel utilisateur (1, "user", "666");}}}Code de classe de test
/ ** Injection via Static Factory * / public class IOC_BY_STATICFACTORY {ID entier privé; Nom de la chaîne privée; utilisateur privé User; / ** Vérifiez si l'injection est réussie * / public boolean checkAttr () {if (id == null) {return false;} else {System.out.println ("id:" + id);}System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (String name) {this.name = name;} public void setter (utilisateur utilisateur) {this.user = user;}}Configuration d'applicationContext.xml
<! - Configuration de la méthode d'usine statique Le bean est en réalité la configuration de la valeur renvoyée par la méthode d'usine en tant que bean -> <bean id = "factory_id" factory-méthod = "getID" /> <bean id = "factory_name" factory-méthod = "getName" <propriété name = "id" ref = "factory_id" /> <propriété name = "name" ref = "factory_name" /> <propriété name = "user" ref = "factory_user" /> </ bean>
Code de test
classe publique IOC_TEST {private applicationContext ctx; @Before public void charge () {// read applicationContext.xml Fichier de configuration ctx = new ClassPathXmlApplicationContext ("applicationContext.xml");} @ test public void staticfactorytest () {ioc_by_staticfactory ioc = (ioc_by_by ctx.getBean ("ioc_by_staticfactory"); ioc.checkattr ();}}Résultats de la sortie de la console
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
7. Injection à travers l'exemple de méthode d'usine
La différence par rapport à une usine statique est que l'usine d'instance n'est pas statique. Vous devez d'abord d'abord l'objet d'usine d'instance avant de pouvoir configurer sa méthode. Le nouvel objet est également géré par le printemps.
Code d'usine
/ ** Instance Factory * / public class Factory {public Integer getID () {return 1;} public String getName () {return "instance factory";} public utilisateur getuser () {return nouvel utilisateur (1, "Instance Factory User", "233");}}Code de classe de test
/ ** Injection Injection d'usine * / classe publique IOC_BY_FACTORY {ID entier privé; nom de chaîne privée; utilisateur d'utilisateur privé; / ** Vérifiez si l'injection est réussie * / public booléen checkAttr () {if (id == null) {return false;} else {system.out.println ("id:" + id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (String name) {this.name = name;} public void setter (utilisateur utilisateur) {this.user = user;}}Configuration d'applicationContext.xml
<! - Configurez l'instance factory bean -> <bean id = "factory" /> <! - Configurez la méthode d'usine d'instance bean -> <bean id = "f_id" factory Bean = "Factory" Factory-Method = "getID" /> <bean id = "f_name" Factory Bean = "factory" factory-méthod = "getname" /> <ean id = "f_user" factory berean = "getname" /> <ean Factory-Method = "GetUser" /> <! - Injectez la méthode d'usine d'instance correspondante bean -> <bean id = "ioc_by_factory"> <propriété name = "id" ref = "f_id" /> <propriété name = "name" ref = "f_name" /> <propriété name = "user" Ref = "f_user" /> </ bean>
Code de classe de test
public class ioc_test {private applicationContext ctx; @Before public void load () {// read applicationContext.xml Fichier de configuration ctx = new classpathxmlapplicationContext ("applicationContext.xml");} @ test public void factorytest () {ioc_by_factory ioc = (ioc_by_factory) ctx.getBean ("ioc_by_factory"); ioc.checkattr ();}}Sortie de la console
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ! !
Résumer
Ce qui précède concerne cet article en discutant de la méthode d'injection du Spring IOC et en injectant différents types de données. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!