1. Inyección de bean basada en XML 1. Inyección de
constructor 2.
Inyección de método establecido
2. Inyección automática de Bean [Estrategia de autoensamblaje de primavera]
Inyección automática [Autoensamblaje] -El contenedor de resorte dependerá automáticamente de los elementos configurados en el archivo de configuración Los objetos se inyectan en variables miembro en la clase de llamada.
Para utilizar el ensamblaje automático, debe configurar el atributo autowire del elemento.
Por ejemplo: test byName [el valor del atributo id del elemento de bean total del archivo de configuración de Spring es el mismo que el nombre de la variable miembro del objeto dependiente en la clase de llamada]
Nota: el objeto dependiente debe proporcionarse con setXX ()
package com.wangxing.spring.byname;
//被调用者类
public class PersonDao {
public void select(){
System.out.println("查询所有用户信息");
}
}
package com.wangxing.spring.byname;
//调用者类
public class PersonService {
//定义依赖对象
private PersonDao personDao;
public void setPersonDao(PersonDao personDao) {
this.personDao = personDao;
}
public void testPersonService(){
personDao.select();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- 测试byname自动注入方式-->
<bean id="personDao" class="com.wangxing.spring.byname.PersonDao"></bean>
<bean id="personService" class="com.wangxing.spring.byname.PersonService" autowire="byName"></bean>
</beans>
Por ejemplo: test byType [el valor del atributo de clase del elemento bean en el archivo de configuración de Spring es el mismo que el tipo de la variable miembro del objeto dependiente en la clase del llamador]
Nota: Debe proporcionar setXX () para el objeto dependiente
package com.wangxing.spring.bytype;
//被调用者
public class StudentDao {
public void selectStudent(){
System.out.println("查询所有学生信息");
}
}
package com.wangxing.spring.bytype;
//调用者
public class StudentService {
//定义依赖对象
private StudentDao studentDao;
public void setStudentDao(StudentDao studentDao) {
this.studentDao = studentDao;
}
public void testStudentService(){
studentDao.selectStudent();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--测试bytype自动注入方式-->
<bean id="stuDao" class="com.wangxing.spring.bytype.StudentDao"></bean>
<bean id="studentService" class="com.wangxing.spring.bytype.StudentService" autowire="byType"></bean>
</beans>
Por ejemplo: constructor de prueba [el valor del atributo de clase del elemento bean en el archivo de configuración de Spring es el mismo que el tipo de parámetro del constructor en la clase de llamada {byType}]
package com.wangxing.spring.constructor;
//被调用者
public class UserDao {
public void selectUser(){
System.out.println("查询所有用户信息");
}
}
package com.wangxing.spring.constructor;
//调用者类
public class UserService {
private UserDao userDao;
public UserService(UserDao userDao){
this.userDao=userDao;
}
public void testUserService(){
userDao.selectUser();
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--测试constructor自动注入方式-->
<bean id="uDao" class="com.wangxing.spring.constructor.UserDao"></bean>
<bean id="userService" class="com.wangxing.spring.constructor.UserService" autowire="constructor"></bean>
</beans>
3. Inyección de Bean basada en anotaciones
En Spring, aunque el uso de archivos de configuración XML puede lograr el ensamblaje de Beans, si el número de Beans en la aplicación es grande, los archivos de configuración XML estarán demasiado inflados, lo que traerá ciertas dificultades a mantenimiento y actualizaciones.
Java ha proporcionado la función de anotación (anotación) desde JDK 5.0, y Spring también proporciona un soporte completo para la tecnología de anotación. Una serie de anotaciones (anotaciones) se definen en Spring3.
1) @Component crea una anotación para un objeto. Al usarlo, solo necesita marcar la anotación en la clase correspondiente.
Antes de @Component
public class Student{
}
Spring配置文件
<bean id=”student” class=”com.wangxing.spring.bean.Student”></bean>
有@Component之后
@Component----使用默认的对象名称【类名,首字母小写】
public class Student{
}
@Component(“stu”)---使用指定的对象名称
public class Student{
}
P.ej:
package com.wangxing.spring.annotation;
import org.springframework.stereotype.Component;
@Component("user")
public class UserBean {
public void testUserBean(){
System.out.println("UseerBean类的是实例方法");
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!--使用context命名空间，通知spring扫描指定目录，进行注解的解析-->
<context:component-scan base-package="com.wangxing.spring.annotation"></context:component-scan>
</beans>
2) @Repository anota la clase de implementación de la interfaz de acceso a datos, y su función es la misma que @Component.
3) @Service marca la clase de implementación de la interfaz de acceso empresarial y su función es la misma que @Component.
4) @Controller anota la clase de implementación de la capa de control, y su función es la misma que @Component.
5) @Autowired completa la inyección automática de Bean. El valor predeterminado es bytype.
package com.wangxing.spring.annotation;
import org.springframework.stereotype.Component;
@Component("user")
public class UserBean {
public void testUserBean(){
System.out.println("UseerBean类的是实例方法");
}
}
package com.wangxing.spring.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository("userDao")
public class UserDao {
//定义依赖对象UserBean
@Autowired
private UserBean userBean;
public void testUserDao(){
System.out.println("数据访问层接口实现类");
userBean.testUserBean();
}
}
6) @Resource completa la inyección automática de Bean. El valor predeterminado es según el nombre.
package com.wangxing.spring.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
@Repository("uDao")
public class UserDao {
//定义依赖对象UserBean
@Autowired
private UserBean user;
public void testUserDao(){
System.out.println("数据访问层接口实现类");
user.testUserBean();
}
}
package com.wangxing.spring.annotation.service;
import com.wangxing.spring.annotation.UserDao;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
@Service("userService")
public class UserService {
//定义依赖对象UserDao
@Resource
private UserDao userDao;
public void testUserService(){
System.out.println("业务层接口实现类");
userDao.testUserDao();
}
}
¿Cuál es la diferencia entre las anotaciones @autowired y @resource?
(1) Tanto @Autowired como @Resource se pueden usar para ensamblar beans, y ambos se pueden escribir en campos o métodos de establecimiento.
(2) @Autowired se ensambla por tipo de forma predeterminada , y los objetos dependientes deben ser obligatorios de forma predeterminada Exist, si desea permitir un valor nulo, puede establecer su atributo obligatorio en falso. Si desea usar el ensamblado de nombre, puede usarlo junto con la anotación @Qualifier.
(3) @Resource, el valor predeterminado es ensamblar de acuerdo con el nombre, el nombre se puede especificar mediante el atributo de nombre, si no se especifica el atributo de nombre, cuando la anotación se escribe en el campo, el nombre del campo se usa por defecto para la búsqueda de nombres. Si la anotación está escrita en el método de establecimiento, el nombre del atributo se usa para el ensamblaje de forma predeterminada. Cuando no se encuentra ningún bean que coincida con el nombre, el ensamblaje se realiza de acuerdo con el tipo. Pero debe tenerse en cuenta que si se especifica el atributo de nombre, solo se ensamblará de acuerdo con el nombre.
Se recomienda usar la anotación @Resource en el campo, para que no sea necesario escribir métodos de establecimiento, y esta anotación pertenece a J2EE, lo que reduce el acoplamiento con Spring.
7) El uso de las anotaciones @Qualifier y @Autowired modificará el ensamblado predeterminado por tipo de Bean a ensamblado por el nombre de instancia del Bean.El nombre de instancia del Bean se especifica mediante el parámetro de la anotación @Qualifier.
public interfase UserDao{
}
@Repository(“studentUsetDao”)
public class StudentUserDao implements UserDao{
}
@Repository(“personUsetDao”)
public class PersonUserDao implements UserDao{
}
//业务类
public class UserServiceImple{
@Autowired
@Qualifier(“personUsetDao”)
private UserDao userDao;
}