Configuración de anotaciones Spring IOC
(1) Breve descripción
Como se mencionó la última vez, podemos usar la forma de escribir archivos de configuración XML para permitir que Spring genere los objetos Bean que necesitamos y los coloque en el contenedor. Sin embargo, escribir archivos de configuración es una tarea muy engorrosa, y una vez que el archivo de configuración contiene mucho contenido, también es un dolor de cabeza leerlo, por lo que necesitamos urgentemente un método de configuración que elimine total o parcialmente los archivos de configuración.
Echemos un vistazo al método de configuración de anotaciones de Spring. La configuración de la anotación se compara con la configuración del archivo de configuración, solo la forma de configuración es diferente y el objetivo final es básicamente el mismo. Es como ir a Beijing en avión e ir a Beijing en tren de alta velocidad, aunque los medios de transporte son diferentes, ambos logran el objetivo de ir a Beijing.
(Dos) clasificación de anotaciones
Las anotaciones utilizadas para la configuración pueden clasificarse aproximadamente de la siguiente manera: las que se utilizan para crear objetos, las que se utilizan para inyectar datos, las que se utilizan para cambiar el alcance y las que se utilizan para agregar lógica al ciclo de vida. Estas anotaciones reemplazarán parte del contenido de la configuración en el archivo XML, pero no pueden deshacerse completamente del archivo XML (cómo deshacerse del archivo XML completamente más adelante).
En primer lugar, tenemos que introducir el espacio de nombres de contexto en XML:
Dar directamente una plantilla en el documento oficial:
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
</beans>
Luego, necesitamos agregar un escáner para que Spring pueda encontrar clases con anotaciones para crear objetos antes de que se puedan instanciar e incluir en el contenedor IOC de Spring:
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.demo" />
</beans>
El paquete base aquí se refiere al paquete donde se encuentran todos los beans que deben agregarse al contenedor. Con el escáner, echemos un vistazo a cómo usar estos cuatro tipos de anotaciones.
1. Se usa para crear objetos
Hay un total de cuatro de estas anotaciones, a saber: @Component, @Controller, @Service y @Repository. Su función es equivalente a escribir la etiqueta <bean /> en el archivo de configuración XML.
Primero, veamos la anotación @Component, cuya función es almacenar el objeto actual en el contenedor IOC de primavera. @Component es un nombre genérico, que generalmente se refiere a cualquier componente que pueda ser administrado por Spring. @Controller, @Service, @Repository son extensiones de @Component, que generalmente se usan para representar componentes en una situación específica, y el marco de Spring lo hará Realice alguna personalización de acuerdo con este escenario de aplicación, por ejemplo, @Repository también tiene conversión automática de excepciones. @Repository se usa para representar los componentes de la capa de Dao, @Service se usa para representar los componentes de la capa de servicio y @Controller se usa para representar los componentes de la capa del controlador.
Por lo tanto, cuando no se considera la personalización especial, estas cuatro anotaciones son exactamente iguales y se pueden mezclar. Pero generalmente seguimos eligiendo según la naturaleza del componente. Escribamos un vistazo:
package com.demo;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
public void getUser(){
System.out.println("getUser被调用了");
}
}
Estas cuatro anotaciones tienen un parámetro para especificar el nombre del objeto Bean. Si no lo escribe (no lo escribí aquí), el valor predeterminado es el nombre de la clase y la primera letra se cambia a minúscula. Esta anotación es equivalente a lo que configuramos en XML:
<bean id="userDao" class="com.demo.UserDao" />
2. Se usa para inyectar datos
Con los objetos, también podemos inyectar datos. Las anotaciones de este tipo más utilizadas son: @Value, @Autowired, @Resource. Las funciones de estas tres anotaciones son equivalentes a la etiqueta <property /> en la etiqueta <bean />, @Value es responsable de Se inyectan tipos básicos, mientras que los otros dos se encargan de inyectar tipos de objeto (inyección de dependencia).
@Value no tiene nada que decir, solo escribe el valor a inyectar en el atributo de anotación, los otros dos pueden ser un poco complicados.
@Autowired se inyecta por defecto de acuerdo con el método de coincidencia de tipos, que se puede usar para variables miembro, métodos de establecimiento, funciones de constructor, etc., usando @Autowired las anotaciones deben tener y solo un objeto Bean que coincida con el tipo, si hay varios Beans coincidentes En ese momento, coincidirá de acuerdo con el nombre. Si no se encuentra el objeto coincidente, el contenedor Spring arrojará una excepción (si no desea lanzar una excepción, puede agregar atributos a la anotación: required = false). También podemos especificar el nombre del objeto Bean inyectado a través de la anotación @Qualifier. Cuando @Autowired y @Qualifier se usan en combinación, la estrategia de inyección automática cambia de emparejar por tipo a emparejar por nombre.
Después de usar la anotación @Resource, Spring determina si el atributo de nombre de la anotación está vacío. Si está vacío, coincidirá con el nombre del atributo actual con el nombre del objeto Bean en el contenedor IOC de Spring. Si la coincidencia es exitosa, se asignará. Si la coincidencia no es exitosa, Coincidirá de acuerdo con el tipo de clase del archivo de configuración de Spring. Si la coincidencia aún no tiene éxito, se informará un error. Si hay un atributo de nombre, se comparará de acuerdo con el valor del atributo de nombre y el nombre del objeto Bean en el contenedor IOC de primavera. Si la coincidencia es exitosa, se asignará, y si no lo es, se informará un error.
3. Se usa para cambiar el alcance de la acción.
Solo hay una anotación de este tipo, a saber, @Scope, que es equivalente al atributo de alcance en la etiqueta <bean />.
@Scope se usa para cambiar el alcance del objeto Bean. Los atributos se pueden completar con los siguientes valores, que son los mismos que en la configuración XML:
- singleton: modo singleton
- prototipo: modo de casos múltiples
- solicitud: dominio de solicitud, debe estar en el entorno web
- sesión: dominio de sesión, debe estar en el entorno web
- aplicación: dominio de contexto, debe estar en el entorno web
- El dominio de sesión del entorno del clúster de sesión global debe estar en el entorno web
4. Se usa para agregar lógica al ciclo de vida.
Hay dos tipos principales de anotaciones, @PostConstruct y @PreDestroy, que se usan en métodos, que son equivalentes a los atributos init-method y destroy-method en la etiqueta <bean />.
@PostConstruct
public void init() {
System.out.println("初始化方法......");
}
@PreDestroy
public void destroy() {
System.out.println("销毁方法......");
}
Después de leer tantas anotaciones, resumamos, de hecho, cada anotación aquí corresponde a una función de configuración en el XML anterior, por lo que es fácil corresponder a la memoria.
| Tipos de | anotación | Elemento XML correspondiente |
|---|---|---|
| Se usa para crear objetos | @ Componente 、 @ Controlador 、 @ Servicio 、 @ Repositorio | etiqueta <bean /> |
| Se usa para inyectar datos | @ Valor 、 @ Autowired 、 @ Recurso | La etiqueta <propiedad /> en la etiqueta <bean /> |
| Se usa para cambiar el ámbito de acción | @Alcance | El atributo de alcance en la etiqueta <bean /> |
| Se usa para agregar lógica en el ciclo de vida | @ PostConstruct 、 @ PreDestroy | El atributo init-method y el atributo destroy-method en la etiqueta <bean /> |
(3) Configuración de anotación pura
La configuración de la anotación pura nos permite abandonar finalmente el archivo XML, pero necesitamos escribir una clase de configuración para reemplazar su función.
Pensemos en lo que podría haber en esta clase de configuración Primero, ¿cómo sabe Spring que es una clase de configuración? Tenemos que agregar una anotación especial para la clase de configuración. Esta anotación es @Configuration. Con él, esta clase será tratada como una clase de configuración.
Luego, también hablamos de que previamente hemos configurado un escáner en XML, esto también se ha convertido en una anotación en la clase de configuración, él es @ComponentScan, solo necesitamos completar el paquete que necesitamos el escaneo de primavera. Tenga en cuenta que si desea completar varios paquetes aquí, debemos escribirlos en forma de matriz. Veamos un ejemplo:
package com.demo;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan("com.demo")
public class Config {
}
package com.demo;
import org.springframework.stereotype.Repository;
@Repository
public class UserDao {
public void getUser(){
System.out.println("getUser被调用了");
}
}
package com.demo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.stereotype.Service;
@Service
public class UserService {
@Autowired
private UserDao userDao;
public void get(){
userDao.getUser();
}
Este ejemplo es muy conciso y el propósito principal es mostrar el modo de configuración de anotación pura. Obviamente, no faltaba ninguna de las cosas que configuramos previamente en XML. Esto también confirma lo que dije antes: configuración XML y configuración de anotaciones, pero la forma es diferente, el objetivo final es básicamente el mismo. ¿Qué? ¿Puede guardar la clase de configuración? ¿Hay alguien más vago que yo? Por supuesto, es posible, pero debe salir y girar a la derecha para ver Springboot, apreciar que la convención es mayor que la configuración y experimentar cuán inteligente se puede ejecutar una aplicación sin escribir una línea de código.
Sin embargo, no se recomienda que los principiantes vayan a ver springboot directamente. La razón es muy simple. Si no entiendes el principio de la primavera, dudarás de tu vida al depurar. Aprendemos primavera, además de aprender a usar el marco, más es aprender qué es un proyecto Java superior, qué se llama una especificación y qué es un patrón de diseño. Solo cuando puedas entenderlos podrás aprender realmente la primavera en casa Para entonces, no es imposible escribir un marco de primavera por ti mismo.
13 de mayo de 2020