IoC en Spring opera la gestión de frijoles basada en anotaciones

Prefacio:

• La anotación es una marca especial de código, formato: @note nombre (nombre de atributo = valor de atributo, nombre de atributo = valor de atributo ...)
• Utilice anotaciones, las anotaciones se aplican a clases, métodos y atributos.
• Propósito del uso de anotaciones: simplificar la configuración xml

1. Las anotaciones proporcionadas en Spring para objetos de creación de administración de Bean

Las siguientes cuatro funciones de anotación son las mismas y se pueden usar para crear instancias de bean

• @Componente
• @Servicio
• @Controlador
• @Repositorio

Pasos:
1. Encienda el escaneo de componentes

<?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.如果扫描多个包，多个包使用逗号隔开
    -->
    <context:component-scan base-package="iocbean.byannotation"></context:component-scan>
</beans>

2. Cree una clase, agregue anotaciones que puedan crear objetos en la clase

//在注解里面 value 属性值可以省略不写， 
// 如果不写默认值是类名称的首字母小写 例如：Person --> person
@Component(value = "person") //相当于xml配置<bean id="person" class="iocbean.byannotation.Person"></bean>
public class Person {
    
    
    private String name;
    private String age;
    private String gender;

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

Código de prueba:

public class DemoTest {
    
    
    @Test
    public void test1(){
    
    
        ApplicationContext context = new ClassPathXmlApplicationContext("iocbean/byannotation/bean.xml");

        Person person = context.getBean("person", Person.class);

        System.out.println(person);
    }
}

Resultado de salida:

Person{name='null', age='null', gender='null'}

Process finished with exit code 0

2. Configuración de los detalles del análisis de componentes

• use-default-filters = "false" significa que el filtro predeterminado no se usa ahora, configure el filtro usted mismo; context: include-filter, establezca qué contenido escanear
• context: exclude-filter: establece qué contenido no se analizará

Entre ellos, hay varios tipos de tipo: anotación, aspectoj, asignable, personalizado y regex.
Su significado es el siguiente:

• anotación: tipo de anotación
• assignable_type: annotation: el tipo especificado
• Aspectj: Según la expresión de Aspectj, básicamente no se usa
• regex: según expresiones regulares
• personalizado: regla personalizada

Archivo de configuración de ejemplo:

<?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.如果扫描多个包，多个包使用逗号隔开
    -->
    <context:component-scan base-package="iocbean.byannotation"></context:component-scan>


    <!--示例 1
        use-default-filters="false" 表示现在不使用默认 filter，
        自己配置 filter context:include-filter ，设置扫描哪些内容
    -->
    <context:component-scan base-package="iocbean.byannotation" use-default-filters="false">
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Service"></context:include-filter>
    </context:component-scan>

    <!--示例 2
        下面配置扫描包所有内容 context:exclude-filter: 设置哪些内容不进行扫描
    -->
    <context:component-scan base-package="iocbean.byannotation">
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"></context:exclude-filter>
    </context:component-scan>
</beans>

Tres. Anotación para lograr la inyección de atributos

1. @Autowired: Montaje automático según tipo de atributo

@Component
public class Student {
    
    
    
    // 添加注入属性注解
    @Autowired
    //定义 Person 类型属性 
    // 不需要添加 set 方法 
    private Person person;

    @Override
    public String toString() {
    
    
        return "Student{" +
                "person=" + person +
                '}';
    }
}

2. @ Qualifier: inyectar según el nombre

La anotación @Qualifier debe usarse con @Autowired arriba

    //添加注入属性注解
    @Autowired //根据类型进行注入
    @Qualifier(value = "person")//根据名称进行注入
    //定义 Person 类型属性
    // 不需要添加 set 方法
    private Person person1;

3. @ Recurso: se puede inyectar según el tipo, se puede inyectar según el nombre

De hecho, @Resource no es una anotación de Spring. Su paquete es javax.annotation.Resource, que debe importarse, pero Spring admite la inyección de esta anotación.
La anotación @Resource pertenece a J2EE y se ensambla por nombre de forma predeterminada. 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 utiliza para la búsqueda de nombres de forma predeterminada.
• Si no se especifica el atributo de nombre, cuando la anotación se escribe en el método de establecimiento, el nombre del atributo se utiliza para el ensamblaje de forma predeterminada.
• Si no se especifica el atributo de nombre, el ensamblaje se realiza de acuerdo con el tipo cuando no se encuentra ningún bean que coincida con el nombre.
• Cabe señalar que si se especifica el atributo de nombre, solo se ensamblará de acuerdo con el nombre.

Uso recomendado: la anotación @Resource está en el campo, y esta anotación pertenece a J2EE, lo que reduce el acoplamiento con el resorte. Lo más importante es que el código se ve más elegante.
Cabe señalar que el ensamblaje de la versión superior de JDK falla cuando se usa la anotación @Resource, y el ensamblaje del bean es exitoso después de usar @Autowired () y @Qualifier ("") en su lugar. En el desarrollo del uso de anotaciones Spring, existen dos soluciones cuando se usa @Resource para informar una excepción de puntero nulo:

1. Utilice jdk8
2. Importar un nuevo paquete jar de javax.annotation

. Por ejemplo, el contenido de la javax.annotation * paquete en mi versión jdk12 es el siguiente:

se puede ver que no hay ninguna clase de anotación de recursos, y luego vuelve a importar javax.annotation-api-1.3.2.jar, y tras la finalización, la siguiente es la siguiente:

para que podamos usar anotaciones @Resource El
ejemplo de código:

    @Resource//根据类型进行注入
    private Person person;

    @Resource(name = "person1") //根据名称进行注入
    private Person person3;

4. @ Value: inyectar atributos de tipo común

    @Value(value = "19")
    private String age;

5. @ Autowired (obligatorio = falso)

De forma predeterminada, el objeto dependiente debe existir. Si desea permitir un valor nulo, puede establecer su atributo obligatorio en falso.
Es decir, a veces el objeto dependiente no existe y la inyección fallará. Cuando no agregamos required = false, se producirá una excepción. Cuando agregamos el parámetro (obligatorio = falso), si la inyección falla, el valor nulo se inyectará automáticamente en este momento y no se informará ningún error.
Ejemplo de código:

    @Autowired(required = false)
    private Person person;
    
    
    @Autowired(required = false) //根据类型进行注入
    @Qualifier(value = "person1")//根据名称进行注入
    private Person person1;

Cuatro. Configuración

Cree una clase de configuración en lugar de un archivo de configuración xml

//作为配置类，替代xml配置文件
@Configuration
//定义扫描的路径，从中找出标识了需要装配的类自动装配到spring的bean容器中
@ComponentScan("iocbean.byannotation/complete_annotation")
public class SpringIocConfig {
    
    
}

Clase de persona:

@Component
public class Person {
    
    
    @Value("Mr.Yu")
    private String name;
    @Value("21")
    private String age;
    @Value("男")
    private String gender;

    public Person() {
    
    
        System.out.println("Person类构造器");
    }

    @Override
    public String toString() {
    
    
        return "Person{" +
                "name='" + name + '\'' +
                ", age='" + age + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

Clase de estudiante:

@Component
public class Student {
    
    
    @Autowired(required = false)
    private Person person;

    @Autowired(required = false)
    @Qualifier("person")
    private Person person1;

    @Resource
    private Person person2;

    public Student() {
    
    
        System.out.println("Student类构造器");
    }

    @Override
    public String toString() {
    
    
        return "Student{" +
                "person=" + person +
                ", person1=" + person1 +
                ", person2=" + person2 +
                '}';
    }
}

Código de prueba:

public class DemoTest {
    
    
    @Test
    public void test1(){
    
    
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringIocConfig.class);

        Student student = context.getBean("student", Student.class);

        System.out.println(student);
    }
}

Resultado de salida:

Person类构造器
Student类构造器
Student{person=Person{name='Mr.Yu', age='21', gender='男'}, person1=Person{name='Mr.Yu', age='21', gender='男'}, person2=Person{name='Mr.Yu', age='21', gender='男'}}

Process finished with exit code 0