Una referencia simple para usar Spring-IOC:
Análisis de instancias simples de los atributos del COI y el alcance de la primavera de los frijoles
1. Inyectar diferentes tipos de datos a través del método establecido
Código de clase de prueba (las propiedades inyectadas en el método establecido deben agregarse con el método establecido)
/** Ejemplo de inyección a través del método de establecimiento*/public class IOC_BY_SET {/** Inyect Interger Tipo Parámetro*/privado ID entero;/** Inyect String Type Parameter*/private String Name;/** Inject Entity Bean*/private User User;/** Inject Achual Array*/Private Object [] Object [] Inyect Collection <1t ARRAGE> ARRAGE> RECULSE <ARRAGA DE LA COLLACIÓN>/RECULACIÓN DE COLLACIÓN DE ACTUALIZA set;/** Inyect Map-Key-Value Pars*/private Map <Object, Object> Map;/** Inyect Inyect Tipo de propiedades*/Propiedades privadas Propiedades;/** Inyect String vacía*/privado String vacío Vacaca;/** Inyect NULL NULL Value*/private String nullvalue = "" ";/** detección si las propiedades inyectadas son correctas*/public boolean checkatt () falso;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nombre);} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- formación) {System.out.println(object.toString());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- {System.out.println ("set:"); for (objeto objeto: 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 <object, object> map) {this.map = map;} public void setProperties (propiedades de propiedades) {this.properties = propiedadies;} public void setEmptyValue (string vacíaValue) {this.emptyvalue = vacíaValue;} public void setNullvalue (String nullvalue) {this. NullValue;}}Configuración de ApplicationContext.xml
< </property> <!-Definición de inyección interna de frijol-> <propiedad name = "user"> <rean> <propiedad name = "id" valor = "1"/> <propiedad name = "username" value = "internal bean"/> <propiedad name = "contraseña" valor = "233"/> </bean> </sperties> <!-inyect type de array-> <name de propiedad = "array"> <bray> <! <value>array01</value> <value>array02</value> <value>array03</value> </array> </property> <!-- Inject List type--> <property name="list"> <list> <!-- Define elements in list--> <value>list01</value> <value>list02</value> <value>list03</value> </list> </property> <!-- Inject Set Tipo-> <Protey> <Propiedad --- Defina elementos en la lista-> <valor> list02 </value> <value> list03 </valor> </list> </property> <!-inyect set type-> <name de propiedad = "set"> <set> <!-Define losements en set-> <valor> set01 </valor> <valor> set02 </value> <valon> set03 </value> </value> set> set01/stery> settin Tipo de mapa de inyección-> <propiedad name = "map"> <s map> <!-Define Key-Value Pars en MAP-> <Entry> <Key> <valor> MAPKEY01 </value> </Key> <valor> MapValue01 </value> </eting> <Entrada> <Key> <Value> MAPKEY02 </value> </ key> <valor> mapvalue02 </putin> </putin> </Enter < <!-Valor nulo de inyección-> <propiedad name = "nullValue"> <null/> </property> </bean>
Código de prueba
public class IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApPlicationContext ("applicationContext.xml");}@Test public void settest () {ioc_by_set ioc = (ioc_by_set) ctx.getBean ("ioc_by_set"); ioc.checkattr ();}}Resultados de la consola:
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- 3 ----------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- ! !
2. Inyectar varios tipos de atributos a través de métodos de construcción
Nota: Cuando se use la versión JDK1.8, actualice el paquete JAR relacionado con el resorte a la versión 4.x o arriba, de lo contrario, se inyectarán constructores incompatibles.
Código de clase de prueba
/** Ejemplo de inyección a través de constructor*/public class IOC_BY_Constructor {private Integer ID; private String Name; private User User; private List <S Object> List; public IOC_BY_Constructor () {} public IOC_BY_Constructor (ID de Integer, nombre de cadena, usuario de usuario, Lista <Object> LIST) {this.id = id; este.name = name; list;}/** Compruebe si la inyección es exitosa*/public boolean checkattr () {if (id == null) {return false;} else {System.out.println ("id:" + id);} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- + "|" + user.getusername () + "| user.getPassword ());} System.out.println ("----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- verdadero;}}Configuración de ApplicationContext.xml
< <constructor-arg> <!-objeto incorporado-> <bean> <constructor-arg value = "1"/> <constructor-arg value = "Construction internal bean"/> <constructor-arg value = "666"/> </bean> </constructor-arg> <!-colección de inyectos-> <constructor-arg> <list> <sal value> list01 </value value> <value> list03 </value> </list> </constructor-arg> </bean>
Código de prueba:
public class IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApPlicationContext ("ApplicationContext.xml");}@test Void Constructortester ctx.getBean ("ioc_by_constructor"); ioc.checkattr ();}}Resultados de la consola:
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- ! !
3. Inyección automática (ensamblaje automático)
Aunque el ensamblaje automático puede guardar algún código, no se recomienda usarlo
Código de clase de prueba:
/** Inyección de ensamblaje automático*/public class IOC_BY_AUTO {user de usuario privado;/** Compruebe si la inyección es exitosa*/public boolean checkattr () {if (user == null) {return false;} else {system.out.println ("user:" + user.getid () + " + user.getusername () +" | " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" user.getPassword ());} system.out.println ("correcto !!!"); return true;}/** El atributo de ensamblaje automático requiere establecer el método establecido*/public void setUser (usuario de usuario) {this.user = user;}}Configuración de ApplicationContext.xml
< clase. Si se coinciden con múltiples frijoles, lanza un constructor de excepción coincide con el bean correspondiente de acuerdo con el tipo de parámetro del constructor de la clase. No. predeterminado, significa que no se usa el valor predeterminado del ensamblaje automático: determinado por la propiedad predeterminada-autowire de la etiqueta superior <Beans>-> <bean id = "ioc_by_auto" autowire = "byname"> </ beon>
Código de prueba
public class IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApplicationContext ("applicationContext.xml");}@Test public void void () {ioc_by_auto IOC = (iOC_BY_AUTO) ctx.getBean ("ioc_by_auto"); ioc.checkattr ();}}Resultados de la consola
Usuario: 1 | Asamblea automática | 233 es correcto! ! !
Lo anterior está usando el modo byname. Se ha indicado el código de configuración de otros modos y no se realizan pruebas.
4. Inyectar atributos usando el espacio de nombres P
Código de clase de prueba
/** inyección usando el espacio de nombres P*/public class IOC_BY_P {ID de Integer Private; Nombre de cadena privada; usuario privado Usuario;/** Compruebe si la inyección es exitosa*/public Boolean checkattr () {if (id == null) {return false;} else {System.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nombre);} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nombre de cadena) {this.name = name;} public void setUser (usuario de usuario) {this.user = user;}}Configuración de ApplicationContext.xml
<!-inyecte varios tipos de propiedades utilizando el espacio de nombres P-> <bean id = "user2"> <propiedad name = "id" valor = "1"/> <propiedad name = "username" valor = "p"/> <propiedad name = "contraseña" valor = "233"/> </bean> <bean id = "ioc_by_p" p: id = "1" p: name = "namespace" "namespace" " P: user-ref = "user2"> </reme>
Código de prueba
public class IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApplicationContext ("applicationContext.xml");}@Test public void ptest () {ioc_by_p ioc = (ioc_by_p) ctx.getBean ("ioc_by_p"); ioc.checkattr ();}}Resultados de la consola
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- ! !
5. Inyectar utilizando el método de anotación
La primavera ha proporcionado inyección basada en anotaciones después de 3.0.
1.@Annotación automática de variables, métodos y constructores de miembros para completar el trabajo de ensamblaje automático. No se recomienda usarlo.
2. @calificador combinado con @autowired para resolver el ensamblaje de múltiples frijoles del mismo tipo
3. @Resource-JSR-250 Annotation estándar, la función es equivalente a @aUtowired, pero @aUtowired se inyecta automáticamente de acuerdo con Bytype, mientras que @Resource se inyecta automáticamente de acuerdo con Byname por defecto.
4. @Postconstruct: agregue anotación @PostConstruct al método, y este método será ejecutado por el contenedor de resorte después de que Bean se inicialice.
5. @Annotación de predestrOy-Add @Predestroy En el método, este método será ejecutado por el contenedor de resorte después de que se inicialice Bean.
6. @componente solo agregue una anotación @Component a la clase correspondiente, la clase se define como un bean. No se recomienda usarlo. Se recomienda usar tres tipos más refinados: @Repository, @service, @Controller
@Repository Storage Capa Bean
@Service Business Layer Bean
@Controller Pantniple Capa Bean
7.@Scope-Define el alcance del frijol
Primero configurar ApplicationContext.xml para habilitar la anotación
<
Anotación de la entidad
@RepositoryPublic Class User {private Integer id = 1; private String username = "Annotation Inyection"; private String Password = "233"; public User () {super ();} Public User (Integer ID, String UserName, String Password) {super (); this.id = id; este.UserName = usame; this.passpass = contraseña;} Public InteGerger () (); getUsername () {return UserName;} public String getPassword () {return Password;} public void setid (ID de Integer) {this.id = id;} public void setUsername (string username) {this.username = username;} public void setPassword (string contraseña) {this.password = contraseña;}}Anotación del código de clase de prueba
/** Atributos de inyección utilizando anotaciones*/@Service ("ioc_by_annotation") public class IOC_BY_Annotation {@Resource Private User User; public void setUser (usuario user) {this.user = user;}/** verifique si la inyección es exitosa*/public boolean checkattr () {if (user == null) {retorno falso;};}; {System.out.println ("User:" + user.getID () + "|" + user.getUsername () + "|" + user.getPassword ());} system.out.println ("correcto !!!"); return true;}}Código de prueba
public class IOC_TEST {private ApplicationContext ctx; @bebore public void load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApPlicationContext ("ApplicationContext.xml");}@Test public void annotationTest () {ioc_by_annotation ioc = (iOc_by_by_by_by_by_by_notation) ctx.getBean ("ioc_by_annotation"); ioc.checkattr ();}}Salida de consola
Después de la prueba, utilizando la inyección de anotación. Si el ApplicationContext.xml está configurado con otros métodos de inyección, se informará un error, lo que también causará que otros métodos de inyección sean anormales.
Usuario: 1 | Inyección de anotación | 233 es correcta! ! !
6. Inyección de frijoles configurando el método de fábrica estática
Código de fábrica estática
/** Factory Static*/public class StaticFactory {public static entero getId () {return 1;} public static string getName () {return "static fábrica";} usuario estático público getUser () {return nuevo usuario (1, "usuario de fábrica", "666");}}Código de clase de prueba
/** inyección a través de la fábrica estática*/public class IOC_BY_STATICATY {ID de Integer privado; Nombre de cadena privada; usuario privado user;/** Compruebe si la inyección es exitosa*/public boolean checkattr () {if (id == null) {return false;} else {System.out.println ("id:" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" + " +" id);}System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nombre);} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nombre de cadena) {this.name = name;} public void setUser (usuario de usuario) {this.user = user;}}Configuración de ApplicationContext.xml
< name = "id" ref = "factory_id"/> <propiedad name = "name" ref = "factory_name"/> <propiedad name = "user" ref = "factory_user"/> </bean>
Código de prueba
clase pública IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración CTX = new ClassPathXMLApPlicationContext ("ApplicationContext.xml");}@Test Public Void STATICORYTTEST () {IOC_BY_BY_STATICORY IIOC = (IOC = (IOC_BY) ctx.getBean ("ioc_by_staticfactory"); ioc.checkattr ();}}Resultados de la salida de la consola
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- ! !
7. Inyección a través del método de fábrica de ejemplo
La diferencia de una fábrica estática es que la fábrica de instancias no es estática. Debe primero un nuevo objeto de fábrica de instancias antes de poder configurar su método. El nuevo objeto también es administrado por Spring.
Código de fábrica
/** Instance Factory*/public class Factory {public Integer getId () {return 1;} public String getName () {return "Instance Factory";} public user getUser () {return New User (1, "Usuario de fábrica de instancia", "233");}}}}}Código de clase de prueba
/** Inyección de fábrica de instancia*/public class IOC_BY_Factory {ID de Integer Private; Nombre de cadena privada; usuario privado user;/** Compruebe si la inyección es exitosa*/public boolean checkattr () {if (id == null) {return false;} else {System.Println ("id:" + + id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- nombre);} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nombre de cadena) {this.name = name;} public void setUser (usuario de usuario) {this.user = user;}}Configuración de ApplicationContext.xml
< factory-method = "getUser"/> <!-inyecting el método de fábrica de instancia correspondiente bean-> <bean id = "ioc_by_factory"> <propiedad name = "id" ref = "f_id"/> <Property name = "name" ref = "f_name"/> <name de propiedad = "usuarios" ref = "f_user"/> </ bean>
Código de clase de prueba
public class IOC_TEST {private ApplicationContext ctx; @bebore public void Load () {// Leer ApplicationContext.xml Archivo de configuración ctx = new ClassPathXMLApPlicationContext ("ApplicationContext.xml");}@Test Public Void FactoryTest () {IOC_BY_BY_BY_FACTORY IOC = (IOC_BY_BY_FACTORY) ctx.getBean ("ioc_by_factory"); ioc.checkattr ();}}Salida de consola
ID: 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- ! !
Resumir
Lo anterior se trata de la breve discusión de este artículo sobre el método de inyección del COI Spring y la inyección de diferentes tipos de datos. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!