IoC in Spring opera gerenciamento de bean baseado em anotações

Prefácio:

• A anotação é uma marca especial de código, formato: @nome da nota (nome do atributo = valor do atributo, nome do atributo = valor do atributo ...)
• Use anotações, as anotações são aplicadas a classes, métodos e atributos
• Objetivo de usar anotações: simplificar a configuração do xml

1. As anotações fornecidas no Spring para objetos de criação de gerenciamento de Bean

As quatro funções de anotação a seguir são iguais e podem ser usadas para criar instâncias de bean

• @Componente
• @Serviço
• @Controlador
• @Repositório

Passos:
1. Ligue a varredura de componente

<?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. Crie uma classe, adicione anotações que podem criar objetos na classe

//在注解里面 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 teste:

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 saída:

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

Process finished with exit code 0

2. Configuração de detalhes de varredura de componentes

• use-default-filters = "false" significa que o filtro padrão não é usado agora, configure o filtro você mesmo; contexto: incluir-filtro, definir qual conteúdo verificar
• context: exclude-filter: defina qual conteúdo não será verificado

Entre eles, existem vários tipos de tipo: anotação, aspectoj, atribuível, personalizado e regex.
Seu significado é o seguinte:

• anotação: tipo de anotação
• assignable_type: anotação: o tipo especificado
• aspectj: De acordo com a expressão de Aspectj, basicamente não usado
• regex: de acordo com expressões regulares
• custom: regra customizada

Arquivo de configuração de exemplo:

<?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>

Três. Anotação para obter injeção de atributo

1. @Autowired: Montagem automática de acordo com o tipo de atributo

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

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

2. @ Qualificador: injete de acordo com o nome

A anotação @Qualifier precisa ser usada com @Autowired acima

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

3. @ Resource: pode ser injetado de acordo com o tipo, pode ser injetado de acordo com o nome

Na verdade, @Resource não é uma anotação do Spring. Seu pacote é javax.annotation.Resource, que precisa ser importado, mas o Spring suporta a injeção dessa anotação.
A anotação @Resource pertence ao J2EE e é montada por nome por padrão.O nome pode ser especificado por meio do atributo name.

• Se o atributo de nome não for especificado, quando a anotação for gravada no campo, o nome do campo será usado para pesquisa de nome por padrão.
• Se o atributo name não for especificado, quando a anotação for gravada no método setter, o nome do atributo será usado para montagem por padrão.
• Se o atributo name não for especificado, a montagem será executada de acordo com o tipo, quando nenhum bean correspondente ao nome for encontrado.
• Deve-se observar que se o atributo name for especificado, ele somente será montado de acordo com o nome.

Uso recomendado: a anotação @Resource está em campo, e esta anotação pertence ao J2EE, o que reduz o acoplamento com mola. O mais importante é que o código tenha uma aparência mais elegante.
Deve-se notar que a versão superior do JDK falha na montagem ao usar a anotação @Resource, e a montagem do bean é bem-sucedida após usar @Autowired () e @Qualifier (""). No desenvolvimento do uso de anotações Spring, existem duas soluções ao usar @Resource para relatar uma exceção de ponteiro nulo:

1. Use jdk8
2. Importe um novo pacote jar de javax.annotation

Por exemplo, o conteúdo do pacote javax.annotation. * Na minha versão JDK12 é o seguinte:

você pode ver que não há classe de anotação de recurso e, em seguida, reimporto javax.annotation-api-1.3.2.jar e, após a conclusão, o seguinte é o seguinte:

para que possamos usar anotações @Resource O
exemplo de código:

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

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

4. @ Value: injetar atributos de tipo comum

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

5. @ Autowired (obrigatório = falso)

Por padrão, o objeto dependente deve existir. Se você quiser permitir um valor nulo, pode definir seu atributo obrigatório como falso.
Ou seja, às vezes o objeto dependente não existe e a injeção falhará. Quando não adicionarmos required = false, ocorrerá uma exceção. Quando adicionamos o parâmetro (obrigatório = falso), se a injeção falhar, o valor nulo será injetado automaticamente neste momento e nenhum erro será relatado.
Exemplo de código:

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

Quatro. Configuração

Crie uma classe de configuração para substituir o arquivo de configuração xml

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

Classe pessoal:

@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 + '\'' +
                '}';
    }
}

Aula do aluno:

@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 teste:

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 saída:

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