Algumas anotações comumente usadas em springboot

@Configuração

A classe marcada pela anotação é javaconfig, e a classe será colocada no container do ioc,
que é a classe marcada com nossa anotação, que é equivalente ao nosso arquivo de configuração anterior

@Feijão

Se você deseja introduzir componentes no contêiner ioc, geralmente é escrito na classe de configuração. O padrão é uma única instância.
O id do componente é o nome do método e o tipo do componente é o tipo de valor de retorno.

@Lazy: Definido para carregamento lento, use com @Bean, esta classe só será carregada quando o objeto for usado

@Scope ("prototype"): Defina o escopo da classe, o padrão é não escrever uma única instância

Valor do parâmetro do escopo:
singleton: // instância única;
protótipo: // multi-instância;
solicitação: // uma solicitação para criar uma instância;
sessão: // uma sessão para criar uma instância;

@Configuration e teste @Bean:

/**
 * proxyBeanMethods参数：
 *          是否代理bean的方法
 *          Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
 *          Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
 *          组件依赖必须使用Full模式默认。其他默认是否Lite模式
 */
@Configuration(proxyBeanMethods = true)    //--标注这个类就是一个配置类，相当于我们以前编写的xml文件
public class MyConfig {
    
    


    @Bean    //向ioc工厂注入一个bean，默认单实例，id为方法名：person/ 类型为返回值类型:Person
    public Person person(){
    
    
        return new Person("张三",18);
    }

    @Bean   //作用同上
    public Pet pet(){
    
    
        return new Pet("大黄",3);
    }
}

resultado:

@ Componente 、 @ Controller 、 @ Serviço 、 @ Repositório

Funciona da mesma maneira que costumávamos

@ComponentScan

É o mesmo que configuramos o caminho de varredura em xml antes, contanto que haja uma anotação de injeção de mola no caminho de varredura, então ele pode ser injetado.
Esta anotação tem alguns outros atributos: exclua essas classes, não faça a varredura e carregue essas classes e carregue-as contanto que as condições sejam atendidas

teste:

@Configuration
@ComponentScan(
        includeFilters ={
    
    
                @ComponentScan.Filter(type= FilterType.ANNOTATION,classes = {
    
    Controller.class})
        },
        useDefaultFilters = false
        //excludeFilters用法同上，不演示
)
public class MyConfig01 {
    
    
}

1. includeFilters: Deixe aqueles carregados no contêiner ioc, se você quiser usar isso, você deve adicionar useDefaultFilters = false abaixo para ter efeito
2. excludeFilters: Não deixe aqueles carregados no contêiner ioc
3. O valor do tipo:

A classe genérica FilterType do valor de tipo tem os seguintes valores:
ANNOTATION: usa filtragem de anotação;
ASSIGNABLE_TYPE: usa o tipo fornecido;
ASPECTJ: usa expressão ASPECTJ;
REGEX: usa expressão regular;
CUSTOM: usa regras personalizadas, É necessário fornecer uma implementação TypeFilter classe;

Filtro customizado:

//要实现TypeFilter接口，重写match方法
public class MyFilter implements TypeFilter {
    
    

    /**
     * metadataReader：读取当前正在扫描的类的信元数据；
     * metadataReaderFactory：可以获取其他任何类的元数据。
     * @return 是否加载进ioc的容器中
     * @throws IOException
     */
    @Override
    public boolean match(MetadataReader metadataReader,
                         MetadataReaderFactory metadataReaderFactory) throws IOException {
    
    
        //===================metadataReader的常用方法==============================
        // 获取当前类的注解元数据
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        // 获取当前正在扫描的类的元数据
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        // 获取当前类资源(类的路径)
        Resource resource = metadataReader.getResource();
        //=====================================================
        //测试：只要包含er的类，就不加在进ioc容器
        // 获取当前正在扫描的类的元数据
        ClassMetadata classMetadata1 = metadataReader.getClassMetadata();
        //获取名称
        String className = classMetadata1.getClassName();
        //判断并返回
        return className.contains("er");
    }
}

@Conditional (): determine se o componente atende às condições, atende à criação e não atende à criação

public @interface Conditional { Class <? extends Condition> [] value (); } Este parâmetro de anotação pode colocar muitos de nossos juízes customizados, só precisa escrever uma classe para integrar a classe Condition e implementar o método.

public class aaa implements Condition {
    
    
    /**
     *
     * @param conditionContext   当前应用的上下文环境。
     * @param annotatedTypeMetadata 标注了该注解的类的信息
     * @return true：符合条件。false：不符合条件
     */
    @Override
    public boolean matches(ConditionContext conditionContext,
                           AnnotatedTypeMetadata annotatedTypeMetadata) {
    
    
        return false;
    }
}
//======================================
@Conditional({
    
    xxx.class})
public class MyConfig01 {
    
    
}

Esta anotação também deriva muitas subnotações:

@ConditionalOnBean: quando há um bean especificado no contêiner @ConditionalOnClass: quando há uma
classe especificada no caminho da classe
@ConditionalOnExpression: com base na expressão SpEL como a condição de julgamento
@ConditionalOnJava: com base na versão JVM como a condição de julgamento
@ ConditionalOnJndi: na pesquisa JNDI sob as condições especificadas local existente
@ConditionalOnMissingBean: no caso em que o contêiner não está especificado no Bean
@ConditionalOnMissingClass: sob condições em que o caminho da classe não é especificado classe de
@ConditionalOnNotWebApplication: o projeto atual não está sob o condições do projeto da Web
@ConditionalOnProperty: especifique se há um valor de atributo especificado
@ConditionalOnResource: há um caminho de classe de recurso especificado
@ConditionalOnSingleCandidate: Bean apenas quando especificado em um contêiner ou no caso em que uma pluralidade de Bean para especificar o preferido Feijão

Podemos julgar quais classes podem ser injetadas com base nessas anotações e quais classes não podem ser injetadas.

@Import: importar componentes rapidamente para o contêiner

@Import: O componente será registrado automaticamente no container, e o id é o nome completo da classe por padrão;
parâmetros de anotação:
array da classe: importa todas as classes para o container ioc.
ImportSelector: Retorna uma matriz dos nomes completos das classes dos componentes a serem importados, os nomes dos componentes são nomes completos das classes;
ImportBeanDefinitionRegistrar: Registra manualmente o Bean para o contêiner e pode personalizar os nomes dos componentes.

ImportSelector: necessidade de escrever uma classe para implementar a interface ImportSelector e implementar métodos

public class MyImportSelector implements ImportSelector {
    
    
	/**
	*AnnotationMetadata :可以获取到标注了 @Import 注解类的所有注解信息；
	*/
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
    
    
        return new String[0];
    }
}

ImportBeanDefinitionRegistrar: pode personalizar o nome do componente registrado no contêiner ioc

public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    
    

    /**
     * @param importingClassMetadata 获取到标注了@Import注解的所有信息
     * @param registry               BeanDefinition 注册类: 调用它的 registerBeanDefinition 方法将需要添加到容器中的 Bean 手工注册进来;
     * RootBeanDefinition：跟容器
     */
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    
    
            registry.registerBeanDefinition("id", new RootBeanDefinition(xxx.class));
        }
    }
}

@ImportResource

Por meio dessa anotação, podemos importar o arquivo xml do spring que gravamos no javaconfig e, em seguida, analisá-lo de acordo com o formato javaconfig.
Adequado para uso quando o projeto xml é convertido em projeto de anotação

@ConfigurationProperties (profix = “xxx”)

Você pode atribuir valores a JavaBeans por meio de arquivos de configuração.Contanto que haja uma configuração começando com xxx em nosso arquivo de configuração, os nomes de atributos com os mesmos nomes neste JavaBean serão automaticamente vinculados e atribuídos.
O arquivo de configuração de ligação só pode ser o arquivo application.properties
. O javabean a ser atribuído deve existir no contêiner ioc

arquivo de propriedades:

person.name=张三
person.age=19

classe javaBean:

@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    
    
    private String name;

    private Integer age;
	//...省略getset等方法
}

Resultado:

Isso irá vincular automaticamente o arquivo de configuração.Tenha cuidado, este javabean deve existir no contêiner ioc para ser vinculado.


Também pode ser usado com a
anotação @EnableConfigurationProperties () + @ConfigurationProperties.

@EnableConfigurationProperties (xxx.class): Função:
1. Carregar xxx.class no contêiner ioc
2. Ative a função de vinculação de dados de xxx