El uso de estas cinco anotaciones de clase simplifica el almacenamiento y la recuperación de beans. De hecho, no se limita a los cinco tipos principales de anotaciones.Otras anotaciones y métodos de inyección utilizan el mismo principio para simplificar las operaciones.Los frijoles se pueden almacenar directamente en el contenedor Spring.

En el artículo anterior, debemos agregar una nueva línea de etiquetas <bean><bean> en el archivo de configuración spring-config.xml cada vez que almacenamos un nuevo bean, lo que obviamente es muy problemático, por lo que en este artículo presentamos principalmente Método único: configure la ruta del archivo de escaneo;

Configurar archivos de escaneo:

La configuración de los archivos de escaneo es imprescindible;

1. Configure la ruta de escaneo:

Primero construya el proyecto Spring y luego comprenda lo siguiente:

① Cree un archivo de configuración en el paquete de recursos, llamado: spring-config.xml;

② Agregue el contenido de configuración de Spring en el archivo de configuración:

<?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:content="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 https://www.springframework.org/schema/context/spring-context.xsd">
    <content:component-scan base-package="com.java.demo"></content:component-scan>
</beans>

Cabe señalar que la etiqueta <content:component-scan><content:component-scan>, la más importante dentro de ella es la ruta del paquete base, el significado de esta ruta se muestra en la siguiente figura:

Desde otra perspectiva: para una clase u objeto que no está bajo la ruta final, incluso si está anotado, no se puede almacenar como Bean en el contenedor Spring;

---------------------------------------------- Trabajo previo completado --------------------------------------------------

1. Cinco categorías de anotaciones:

¿Cuáles son las cinco categorías de anotaciones?

@Controller (almacenamiento del controlador): puede verificar la exactitud de los datos solicitados por el usuario;

@Service (servicio de almacenamiento): Sirve para la ejecución de métodos específicos de orquestación y programación;

@Repository (almacenamiento en almacén): interactuar con la base de datos;

@Component (almacenamiento de componentes): gestión de componentes, clases de herramientas, etc.;

@Configuration (almacenamiento de configuración): administrar elementos de configuración, ajustes, etc.;

1.1 @Controlador:

Para adaptarse a las capas estándar de javaEE, cree un paquete de nivel de respuesta antes de demostrar el código y cree clases en el paquete (lo mismo se aplica más adelante, y las capas estándar se describen a continuación);

1.1.1 Frijol de almacenamiento:

Así, escriba una clase PersonController y agregue la anotación de clase @Controller para escanear el bean a través de la ruta de configuración y colocarlo en el contenedor Spring;

@Controller
public class PersonController {
    public void myHobby() {
        System.out.println("psController -> 我爱敲代码");
    }
}

1.1.2 Leer frijol:

Cree una clase de inicio bajo el paquete java inicial: clase de aplicación, obtener objeto Spring, objeto Bean;

El resultado de la operación muestra que no agregamos una línea de inyección manual como <bean id="" class=""></bean> en el archivo de configuración como el original, y podemos leer con éxito el objeto Bean - personController, que es Los beneficios de la inyección automática de anotaciones @Controller;

// 启动类
public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        PersonController personController =
                context.getBean("personController",PersonController.class);
        personController.myHobby();
    }
}

-------------------------------------------------- -------------------------------------------------- --

1.2 @Servicio:

1.2.1 Frijol de almacenamiento:

@Service
public class PersonService {
    public void myHobby() {
        System.out.println("psService -> 我爱敲代码");
    }
}

1.2.2 Leer frijol:

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        PersonService personService = context.getBean("personService",PersonService.class);
        personService.myHobby();
    }
}

-------------------------------------------------- -------------------------------------------------- --

1.3 @Repositorio:

1.3.1 Frijol de almacenamiento:

Cree un paquete llamado repositorio y cree la clase PersonRepository debajo del paquete:

@Repository
public class PersonRepository {
    public void myHobby() {
        System.out.println("psRepository -> 我爱敲代码");
    }
}

1.3.2 Leer frijol:

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        PersonRepository personRepository =
                context.getBean("personRepository",PersonRepository.class);
        personRepository.myHobby();
    }
}

1.4 @Componente:

1.4.1 Frijol de almacenamiento:

Cree un paquete llamado Componente y cree una clase PersonComponent bajo el paquete:

@Component
public class PersonComponent {
    public void myHobby() {
        System.out.println("psComponent -> 我爱敲代码");
    }
}

1.4.2 Leer frijol:

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        PersonComponent personComponent =
                (PersonComponent) context.getBean("personComponent", PersonComponent.class);
        personComponent.myHobby();
    }
}

1.5 @Configuración:

1.5.1 Frijol de almacenamiento:

Cree un paquete llamado configuración y cree la clase PersonConfiguration en el paquete:

@Configuration
public class PersonConfiguration {
    public void myHobby() {
        System.out.println("psConfiguration -> 我爱敲代码");
    }
}

1.5.2 Leer frijol:

public class App {
    public static void main(String[] args) {
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring-config.xml");
        PersonConfiguration personConfiguration =
                context.getBean("personConfiguration",PersonConfiguration.class);
        personConfiguration.myHobby();
    }
}

Las reglas de nomenclatura de ID predeterminadas para cinco tipos de anotaciones que coinciden con Bean:

Lo anterior almacena directamente el Bean en el contenedor Spring a través de anotaciones. No hemos establecido manualmente su id, entonces, ¿cómo escribir la id al leer?

id tiene reglas predeterminadas: haga doble clic en shift, busque el método AnnotationBeanNameGenerator, alt + 7 para ver directamente el método buildDefaultBeanName:

Luego ingrese su método interno de descapitalización():

La conclusión se puede sacar a través del código fuente: bajo la anotación @Controller, se estipula por defecto:

La primera letra de la clase está en mayúscula y la segunda letra en minúscula, luego el id es el nombre de la clase con la primera letra en minúscula;

La primera letra de la clase está en mayúscula, y la segunda letra también está en mayúscula, entonces id es el nombre de la clase original;

Ilustración:

¿Por qué hay tantas anotaciones?

1. La relación entre las cinco categorías de anotaciones:

También puede ver a través del código fuente de las cinco anotaciones: @Controller, @Service, @Repository, @Configuration. La implementación de estas cuatro anotaciones depende de la anotación @Component, por lo que se puede entender que las primeras cuatro anotaciones son las "hijos" de la clase de anotación @Component", que es una extensión de la misma .

2. ¿Por qué usar tantas anotaciones?

Esto tiene que mencionar el estándar de capas javaEE. Dado que Spring Framework está dirigido al desarrollo empresarial, estas anotaciones también están diseñadas para adaptarse a las reglas de desarrollo y la lógica comercial hasta cierto punto.

La estratificación estándar de JavaEE es un modelo de estructura jerárquica lógica diseñado por las principales empresas para un desarrollo eficiente, dividido principalmente en: capa de presentación—> capa de control—> capa de servicio—> capa de persistencia de datos;

Escribir código no es solo para el diseño del programa, sino también para que lo vean los programadores. Aunque las funciones de las cinco anotaciones son las mismas, cada una representa una capa de diseño. En el proceso de desarrollo, qué clases se usan y dónde En el primer nivel, con Con la ayuda de las anotaciones correspondientes, la función de identificación se puede realizar de manera intuitiva, lo cual es conveniente para la programación de procesos.

2. Anotación del método @Bean:

Además de los cinco tipos de anotaciones presentados anteriormente, también hay una "anotación de método" que se usa especialmente en los métodos: @Bean;

La función de la anotación @Bean: decirle al método que genere un objeto Bean y entregar este objeto al contenedor Spring IoC para su administración, de modo que este método devuelva el objeto creado;

2.1 Frijol de almacenamiento:

Primero cree un paquete de bean en el paquete de demostración y cree una clase PersonBean en el paquete:

2.2 Obtener el objeto Bean:

Los objetos almacenados a través de la anotación @Bean no se pueden obtener como antes, porque las reglas de nomenclatura de id de esta anotación son diferentes de las de las cinco anotaciones principales;

Como se muestra en la imagen:

¡Aviso! Hay dos razones para el error anterior:

Las reglas de nomenclatura de @Bean, por defecto, el nombre del objeto Bean almacenado y el nombre del método son consistentes;

Las anotaciones @Bean deben usarse en combinación con cinco tipos de anotaciones; esto es necesario para garantizar el rendimiento de Spring;

Modificar el código anterior:

2.3 Estrategia de cambio de nombre de @Bean:

Por defecto, el id del objeto almacenado en la anotación @Bean es el mismo que el nombre del método, además, también se puede renombrar según las necesidades del programador;

Escribiendo:

Agregue corchetes () después de @Bean, use { } para los corchetes, y se pueden configurar múltiples nombres de identificación dentro;

Los atributos dentro de { } pueden ser nombre o valor, como se muestra en la siguiente figura;

Después de la modificación:

También puede omitir y escribir:

Después de renombrar de esta manera, el nombre o valor generado se usa como una matriz para almacenar múltiples nombres del Bean;

Después de usar el cambio de nombre, la adquisición del nombre del método predeterminado ya no es factible;

3. Ensamblaje de objetos (más fácil de obtener el objeto Bean):

La lectura del objeto Bean del contenedor también se denomina "ensamblaje de objetos" , que consiste en sacar el objeto y colocarlo en una clase determinada, a veces denominada "inyección de objetos" ;

Los tres nuevos métodos de inyección descritos a continuación:

inyección de atributos;
Setter inyección;
inyección de constructor;

3.1 Inyección de propiedad:

La inyección de atributos debe anotarse con @Autowired;

Ejemplo: ahora hay una tabla de datos personDao, que almacena la instancia de PersonBean creada anteriormente, por lo que la idea es: crear una clase de entidad PersonDao e inyectar directamente el objeto Bean de la clase PersonBean en la clase PersonDao mediante la inyección de propiedad en esta clase;

3.1.1 Análisis de ventajas y desventajas:

ventaja:

Fácil de escribir y fácil de usar;

defecto:

Los objetos modificados por final no se pueden inyectar;

Aplica solo para contenedores IoC;

NPE (Excepción de puntero nulo) ocurre solo cuando se usa;

Es fácil violar el principio de diseño único;

3.2 Inyección Setter:

La inyección de setter también usa la anotación @Autowired, pero usa el método setter();

Ejemplo: Todavía inyecte el objeto PersonBean en la clase PersonDao, modifique ligeramente el código y agregue la anotación al método Setter() esta vez;

3.2.1 Análisis de ventajas y desventajas:

ventaja:

Dado que el método Setter() solo pasa un objeto a la vez, se ajusta al principio de diseño único y es el método de inyección recomendado oficialmente por Spring en la etapa inicial;

Asegúrese de que el objeto inyectado en la clase antes de su uso no esté vacío;

defecto:

Los objetos modificados por final no se pueden inyectar;

El objeto inyectado puede ser modificado por otros métodos dentro de la clase;

3.3 Inyección de constructor:

La inyección del método de construcción todavía necesita usar la anotación @Autowired, pero aquí se usa en el método de construcción;

Precauciones:

Si solo hay un constructor, se puede omitir la anotación @Autowired;
Si hay varios constructores, debe usar la anotación @Autowired para indicar qué constructor usar;

Ejemplo: todavía inyecte el objeto PersonBean en la clase PersonDao, modifique ligeramente el código y agregue la anotación al constructor esta vez;

3.3.1 Análisis de ventajas y desventajas:

ventaja:

Puede inyectar objetos modificados finales, porque los objetos modificados finales en Java se asignan directamente o se asignan en el constructor, por lo que están disponibles;

El objeto inyectado no se cambiará;

Asegúrese de que el objeto inyectado esté correctamente inicializado y no vacío;

Buena versatilidad;

El método de inyección oficial de Spring es actualmente el más recomendado;

4. Anotación @Resource:

Esta anotación también se usa para la inyección de objetos, vea primero la demostración:

4.1 La diferencia entre @Resource y @AutoWired:

Diferentes fuentes: @Autowired proviene de Spring, @Resource proviene del mismo JDK;

Diferencias funcionales: @Resource admite más configuraciones de parámetros que @Autowired;

Diferencia de alcance: @Resource no se puede usar para inyección de constructor, mientras que @Autowired se puede usar para los tres métodos de inyección anteriores;

Diferentes métodos de búsqueda: si se almacenan varias copias del mismo tipo de Bean, los dos métodos de búsqueda son diferentes. @Resource primero verifica por nombre y luego verifica por tipo; mientras que @Autowired primero verifica por tipo, luego verifica según el nombre ; entonces @Resource es más adecuado para encontrar múltiples beans del mismo tipo;

4.1.1 Resuelva el mismo tipo de problema de informe de errores de @Bean:

Cuando se almacenan varias copias del mismo tipo de Bean, si solo usa la anotación @Autowired de Spring para inyectar en la clase, puede haber un error de que no se puede encontrar un objetivo coincidente único.

Ejemplo: dos cachorros con diferentes colores se almacenan en la clase DogsBean usando la anotación @Bean, y ahora quiero inyectar un cachorro específico en la clase DogController;

Se produce un error al ejecutar: no puede coincidir con un valor único.

Solución:

Método 1: Use @Resource(name= ""): Debido a que los parámetros de la anotación @Autowired solo pueden ser valores de tipo booleano, no puede especificar un nombre, pero @Resource sí;

Método 2: Use la anotación @Qualifier(value=""): Algunas personas pueden querer usar la anotación @Autowired, está bien, luego úsela junto con la anotación @Qualifieer;

Los cinco tipos principales de anotaciones, anotaciones de métodos e inyección de objetos de Spring simplifican las operaciones de Bean

Por qué usar anotaciones