1. Ensamblaje basado en XML
Dos métodos de ensamblaje basados en XML
El ensamblado basado en XML es para leer la información en el archivo de configuración XML para completar la inyección de dependencia.El contenedor Spring proporciona dos métodos de ensamblado basados en XML, inyección de método de establecimiento de propiedades e inyección de método de construcción. Los dos métodos de montaje se presentan respectivamente a continuación.
A. Inyección del método de establecimiento de propiedades
La inyección del método de establecimiento de propiedades requiere que un Bean cumpla con los siguientes dos requisitos.
(1) La clase Bean debe proporcionar un constructor predeterminado sin argumentos.
(2) La clase Bean debe proporcionar los métodos de establecimiento correspondientes para las propiedades que deben inyectarse.
B. Inyección de constructor
Al usar la inyección de constructor, en el archivo de configuración, debe usar el subelemento <constructor-arg> del elemento <bean> para definir los parámetros del método de construcción. Por ejemplo, puede usar su atributo de valor (o subelemento) para establecer el valor del parámetro.
2. Ensamblaje basado en anotaciones
Comparación de XML y ensamblado de anotaciones
En Spring, el ensamblaje de beans se puede realizar utilizando archivos de configuración XML, pero en el desarrollo real, si la cantidad de beans es grande, los archivos de configuración XML estarán demasiado inflados, lo que traerá ciertas dificultades para el mantenimiento y las actualizaciones posteriores. Para resolver este problema, Spring proporciona anotaciones y el ensamblaje de Bean también se puede realizar a través de anotaciones.
Anotaciones comunes de Spring
| anotación |
describir |
| @Componente |
Especifique un Bean común, que se puede usar en cualquier nivel. |
| @Controlador |
Especifique un bean de componente de controlador para identificar la clase de la capa de control como un bean en Spring, Funcionalmente equivalente a @Component. |
| @Servicio |
Especifique un bean de componente de lógica de negocios para identificar la clase de la capa de lógica de negocios como un bean en Spring, Funcionalmente equivalente a @Component. |
| @Repositorio |
Especifique un bean de componente de acceso a datos para identificar la clase de la capa de acceso a datos como un bean en Spring, Funcionalmente equivalente a @Component. |
| @Alcance |
Especifica el alcance de la instancia de Bean. |
| @Valor |
Especifica el valor inyectado de la instancia de Bean. |
| anotación |
describir |
| @autocableado |
Especifica los objetos para autoconectar. |
| @Recurso |
Especifica el objeto a inyectar. |
| @Calificatorio |
Especifica el nombre del objeto que se conectará automáticamente, generalmente se usa junto con @Autowired. |
| @PostConstruct |
Especifica el método a invocar después de que la instancia de Bean haya completado la inicialización. |
| @PreDestroy |
Especifica el método para llamar antes de que se destruya la instancia de Bean. |
El siguiente ejemplo demuestra cómo usar anotaciones para ensamblar beans.Los pasos de implementación específicos son los siguientes.
1. Importar dependencias: importe el paquete de dependencias spring-aop-5.2.8.RELEASE.jar en el archivo pom.xml del proyecto chapter07, y el código de importación es el siguiente.
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>5.2.8.RELEASE</version>
</dependency>
2. Archivo de configuración XML: cree applicationContext.xml, introduzca restricciones de contexto en este archivo e inicie la función de exploración automática de Bean.
<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:component-scan base-package="com.mac" />
</beans>
3. Defina la clase de entidad: cree un nuevo paquete de entidad y cree una clase de entidad de usuario en el paquete de entidad.
@Component("user")
@Scope("singleton")
public class User {
@Value("1")
private int id;
@Value("张三")
private String name;
@Value("123")
private String password;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String toString(){
return "id="+id+",name="+name+",password="+password;
}
}4. Defina la capa dao: cree la interfaz UserDao como la interfaz de la capa de acceso a datos y declare el método save() en la interfaz UserDao para consultar la información del objeto de la entidad Usuario.
package com.mac.dao;
public interface UserDao {
public void save();
}
5. Implemente la capa dao: cree UserDaoImpl como la clase de implementación de UserDao e implemente el método save() en la interfaz UserDao en la clase UserDaoImpl.
@Repository("userDao")
public class UserDaoImpl implements UserDao {
public void save(){
ApplicationContext applicationContext=new
ClassPathXmlApplicationContext("applicationContext.xml");
User user=(User) applicationContext.getBean("user");
System.out.println(user);
System.out.println("执行UserDaoImpl.save()");
}
}
6. Defina la capa de servicio: cree la interfaz UserService como la interfaz de la capa de lógica empresarial y defina el método save() en la interfaz UserService.
package com.mac.service;
public interface UserService {
public void save();
}
7. Implemente la capa de servicio: cree UserServiceImpl como la clase de implementación de UserService e implemente el método save() en la interfaz de UserService en la clase UserServiceImpl.
@Service("userService")
public class UserServiceImpl implements UserService {
//使用@Resource注解注入UserDao
@Resource(name="userDao")
private UserDao userDao;
public void save(){
this.userDao.save();
System.out.println("执行UserServiceImpl.save()");
}
}
8. Defina la capa del controlador: cree la clase UserController como la capa de control.
@Controller
public class UserController {
//使用@Resource注解注入UserService
@Resource(name="userService")
private UserService userService;
public void save(){
this.userService.save();
System.out.println("执行UserController.save()");
}
}
9. Defina la clase de prueba: cree la clase de prueba AnnotationTest, escriba el código de prueba en esta clase, cargue el archivo de configuración a través del contenedor Spring y obtenga la instancia de UserController, y luego llame al método save() en la instancia.
public class AnnotationTest {
public static void main(String[] args){
ApplicationContext applicationContext=new
ClassPathXmlApplicationContext("applicationContext.xml");
UserController usercontroller=(UserController)
applicationContext.getBean("userController");
usercontroller.save();
}
}
10. Vea los resultados en ejecución: inicie la clase AnnotationTest en IDEA y la consola generará los resultados.
3. Montaje automático
El elemento <bean> de Spring contiene un atributo de conexión automática, que puede realizar el ensamblaje automático de beans al establecer el valor del atributo de conexión automática.
El valor del atributo autowire
| valor de atributo |
describir |
| predeterminado (valor predeterminado) |
Determinado por el valor del atributo default-autowire del elemento superior <beans> de <bean>. |
| por nombre |
Conectado automáticamente en función del valor del atributo id del elemento <bean>. |
| por tipo |
Autoconexión según el tipo de datos (Tipo) del elemento <bean>, si es un tipo de datos de Bean, Compatible con el tipo de datos en otro bean, se cablea automáticamente. |
| constructor |
Según el tipo de datos del parámetro constructor, se realiza el ensamblaje automático del modo byType. |
| No |
De forma predeterminada, no se utiliza cableado automático y las dependencias de los beans deben definirse a través de elementos <ref> o atributos de referencia. |