SpringIoC se configura en función de anotaciones

Tabla de contenido

1. Marcado y escaneo de anotaciones de beans (IoC)

2. Alcance del componente (Bean) y anotaciones del método periódico

3. Asignación de atributos de frijol: ensamblaje automático de tipo de referencia (DI)

4. Asignación de atributos de frijol: asignación de atributos de tipo básico (DI)

---

1. Marcado y escaneo de anotaciones de beans (IoC)

1. Introducción a los métodos de anotación.

1. Introducción a las anotaciones

Al igual que el archivo de configuración XML, la anotación en sí no se puede ejecutar. La anotación en sí es solo una marca. La función específica es que el marco detecta la posición de la marca de anotación y luego realiza operaciones específicas basadas en la función de la marca de anotación en esta posición.

Esencialmente: todas las operaciones se realizan mediante código Java, y XML y las anotaciones simplemente le indican al código Java en el marco cómo ejecutar.

2. Escanear y comprender

Para saber dónde ha marcado el programador qué anotaciones, Spring necesita detectarlas mediante el escaneo. Luego realice operaciones posteriores basadas en las anotaciones.

 Paquetes de dependencia relacionados:

<dependencies>
    <!--spring context依赖-->
    <!--当你引入Spring Context依赖之后，表示将Spring的基础依赖引入了-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>6.0.6</version>
    </dependency>

    <!--junit5测试-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter-api</artifactId>
        <version>5.3.1</version>
    </dependency>
</dependencies>

método de anotación

Spring proporciona las siguientes anotaciones múltiples, que pueden anotarse directamente en clases Java y definirse como Spring Beans.

anotación	ilustrar
@Componente	Esta anotación se usa para describir Bean en Spring. Es un concepto general que solo representa un componente (Bean) en el contenedor y se puede usar en cualquier nivel de la aplicación, como capa de servicio, capa Dao, etc. Al usarlo, solo necesita marcar la anotación en la clase correspondiente.
@Repositorio	Esta anotación se utiliza para identificar la clase de la capa de acceso a datos (capa Dao) como Bean en Spring, y su función es la misma que @Component.
@Servicio	Esta anotación generalmente actúa en la capa empresarial (capa de servicio) y se utiliza para identificar las clases de la capa empresarial como beans en Spring, su función es la misma que @Component.
@Controlador	Esta anotación generalmente actúa en la capa de control (como el controlador de SpringMVC) y se usa para identificar la clase de la capa de control como Bean en Spring. Su función es la misma que @Component.

No hay diferencia entre Spring al usar el contenedor IOC para administrar estos componentes, es decir, no hay diferencia a nivel de sintaxis. Por lo tanto, las tres anotaciones @Controller, @Service y @Repository son solo para que las vean los desarrolladores, lo que nos permite distinguir fácilmente la función del componente.

Nota: Aunque son esencialmente iguales, ¡por razones de legibilidad del código y estructura rigurosa del programa! Ciertamente no podemos marcar cosas al azar.

Caso de uso (configuración xml omitida):

package com.alphamilk;

import org.springframework.stereotype.Component;

@Component(value = "common")
public class CommonComponent {

}

package com.alphamilk;

import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class test {
    @Test
    public void Test(){
//        创建Ioc容器
        ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("Spring.xml");
//       获取组件
        CommonComponent commonCompent = (CommonComponent) classPathXmlApplicationContext.getBean("common");
//        输出组件
        System.out.println(commonCompent);
    }
}

2. Introducción a los archivos de configuración.

Alcance del perfil

1. Paquete de escaneo de configuración comú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: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 https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 配置自动扫描的包 -->
    <!-- 1.包要精准,提高性能!
         2.会扫描指定的包和子包内容
         3.多个包可以使用,分割 例如: com.atguigu.controller,com.atguigu.service等
    -->
    <context:component-scan base-package="com.atguigu.components"/>

</beans>

2. Especifique el paquete, pero excluya las anotaciones.

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!-- context:exclude-filter标签：指定排除规则 -->
    <!-- type属性：指定根据什么来进行排除，annotation取值表示根据注解来排除 -->
    <!-- expression属性：指定排除规则的表达式，对于注解来说指定全类名即可 -->
    <context:component-scan base-package="com.alphamilk" >
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
</beans>

3. Especifique el paquete, incluidas las anotaciones.

<?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 https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 仅扫描 = 关闭默认规则 + 追加规则 -->
    <!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->
    <context:component-scan base-package="com.alphamilk" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/>
    </context:component-scan>
</beans>

Problema con el nombre del componente Bean

Cuando usamos XML para administrar beans, cada bean tiene un identificador único: el valor del atributo id, al que es fácil hacer referencia en otros lugares. Ahora, con las anotaciones, cada componente debería tener un identificador único.

Por defecto:

La primera letra del nombre de la clase en minúscula es la identificación del bean. Por ejemplo: el id del bean correspondiente a la clase SoldierController es soldadoController.

Especifique el nombre usando el atributo de valor

Resumir

1. La anotación IoC solo marca qué clases serán administradas por Spring
2. Finalmente, también necesitamos el método XML o el método de clase de configuración de Java que se explica más adelante para especificar el paquete en el que la anotación tiene efecto.
3. **El método de configuración actual es anotación (marca) + XML (escaneo)

---

2. Alcance del componente (Bean) y anotaciones del método periódico

1. Método periódico:

1.1 Concepto de método periódico

¡Podemos definir métodos en la clase de componente y luego llamarlos cuando el contenedor de IoC crea una instancia y destruye el objeto del componente! ¡Estos dos métodos nos convertimos en métodos del ciclo de vida!

De manera similar al método init/destroy de Servlet, podemos completar la inicialización y liberar recursos en el método periódico.

1.2 Declaración de método periódico

public class BeanOne {

  //周期方法要求： 方法命名随意，但是要求方法必须是 public void 无形参列表
  @PostConstruct  //注解制指定初始化方法
  public void init() {
    // 初始化逻辑
  }
}
public class BeanTwo {

  @PreDestroy //注解指定销毁方法
  public void cleanup() {
    // 释放资源逻辑
  }
}

2. Configuración del alcance del componente

1.1 Concepto de alcance del frijol

<bean¡La etiqueta declara el Bean y solo configura la información del Bean en el contenedor SpringIoC!

En el contenedor IoC, <beanla información correspondiente a estas etiquetas se convierte en BeanDefinitionobjetos internos de Spring, BeanDefinition¡que contienen información definida (id, clase, atributos, etc.)!

Esto significa que, BeanDefinitionigual 类de conceptualmente, el contenedor Spring IoC puede BeanDefinitioncrear múltiples instancias de objetos Bean basadas en la reflexión del objeto.

El número específico de objetos de instancia de Bean creados se especifica mediante la propiedad Scope del Bean!

1.2 Valores opcionales de alcance

valor	significado	Cuando crear un objeto	valor por defecto
único	En el contenedor IOC, el objeto de este bean es siempre una instancia única	Cuando se inicializa el contenedor IOC	Sí
prototipo	Este bean tiene varias instancias en el contenedor IOC	Al conseguir un frijol	No

Es especial en WebApplicationContext, su alcance tiene dos valores más.

valor	significado	Cuando crear un objeto	valor por defecto
pedido	Una instancia válida dentro del alcance de la solicitud.	por solicitud	No
sesión	Instancias válidas dentro del alcance de la sesión.	por sección	No

 Configuración del alcance

//以下二选一
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_SINGLETON)//默认单例模式
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)//多例模式
@Component(value = "common")
public class CommonComponent {

    @PostConstruct
    public void init(){
        System.out.println("通过注解@PostConstruct执行初始化阶段");
    }
    @PreDestroy
    public void destory(){
        System.out.println("通过注解@PreDestroy注解实现销毁阶段执行");
    };
}

Nota: En el modo de instancias múltiples, el componente solo llamará a @PostConstruct init para inicializar el ciclo de vida y no puede llamar al ciclo de vida de destrucción implementado por @PreDestroy.

---

3. Asignación de atributos de frijol: ensamblaje automático de tipo de referencia (DI)

 Establece la escena

• SoldierController y SoldierService

• SoldierService 需要 SoldierDao

• Al mismo tiempo, declare los métodos que se llamarán en cada componente.

Método de declaración en SoldierController

package com.alphamilk.Ioc3;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller(value = "tianDog")
public class SoldierController {
// 相当于xml配置中<property 对应组件的装配
    //自动装配注解(DI) :1.ioc容器中查找符合类型的组件对象 2.设置给当前属性（di）
    @Autowired
    private SoldierService soldierService;

    public void getMessage() {
        soldierService.getMessage();
    }

}

Implementación de ensamblaje automático

1. premisa

   Todos los componentes que participan en el ensamblaje automático (que requieren ensamblaje, que se están ensamblando) deben estar en el contenedor de IoC.

   Nota: ¡No distinga entre métodos de IoC! ¡Tanto XML como las anotaciones funcionan!

2. @Anotación Autowired

   Simplemente marque la anotación @Autowired directamente en la variable miembro y no es necesario proporcionar el método setXxx (). Este será nuestro uso oficial en el proyecto de ahora en adelante.

Proceso de montaje automático

asamblea budista

Establecer el atributo requerido = falso en la anotación @Autowired significa: instálelo si se puede instalar; de lo contrario, instálelo si no se puede instalar. Sin embargo, durante el desarrollo real, básicamente se deben ensamblar todos los lugares donde se deben ensamblar los componentes, y este atributo no se utiliza.

@Controller(value = "tianDog")
public class SoldierController {

    // 给@Autowired注解设置required = false属性表示：能装就装，装不上就不装
    @Autowired(required = false)
    private ISoldierService soldierService;

No se recomienda el ensamblaje budista. Si el ensamblaje budista no tiene contenido al llamar a un componente, se informará una excepción de puntero nulo.

Tres escenarios de montaje automático.

1. Cuando hay un objeto de clase de implementación correspondiente a una interfaz en el contenedor ioc, se puede llamar directa y normalmente.

2. Cuando no hay un tipo de bean predeterminado en el contenedor ioc, se puede ensamblar mediante la anotación @Autowired. De forma predeterminada, se requiere al menos un bean que coincida con el tipo inyectado; de lo contrario, se informará un error. Además, también puede utilizar la anotación @Qualifier para especificar beans específicos para el ensamblaje.

3. Cuando hay varios componentes correspondientes del mismo tipo, @Autowired también informará un error y no podrá determinar qué bean seleccionar.

• Solución 1: puede utilizar la anotación @Qualifier en las propiedades del miembro y especificar la identificación del bean que debe ensamblarse. En este momento, @Autowired buscará y ensamblará el bean correspondiente según el nombre de la propiedad del miembro.

• Solución 2: puede combinar el uso de las anotaciones @Autowired y @Qualifier, y especificar obtener beans específicos para ensamblar a través de @Qualifier(value = "beanId"). Tenga en cuenta que la anotación @Qualifier debe usarse junto con la anotación @Autowired.

Optimización: si le resulta muy problemático utilizar @AutoWired y @Qualifier juntos, también puede utilizar @Resource(nombre) para lograr el mismo efecto.

---

4. Asignación de atributos de frijol: asignación de atributos de tipo básico (DI)

Hay dos formas de asignar valores a atributos de tipo básico.

1. Asignación directa

2. Asigne valor mediante la etiqueta @Value

package ioc04;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class JavaBean {
//    方案1：直接赋值
    private String name = "黄飞宏";
    private  int age =19;
//    通过注解配置
    @Value("翻斗大街翻斗花园，翻斗小区一号")
    private String Adress;
}

---