Algunas anotaciones de uso común en springboot

@Configuración

La clase marcada por la anotación es javaconfig, y la clase se colocará en el contenedor de ioc,
que es la clase marcada con nuestra anotación, que es equivalente a nuestro archivo de configuración anterior.

@Frijol

Si desea introducir componentes en el contenedor ioc, generalmente se escribe en la clase de configuración. El valor predeterminado es una instancia única.
La identificación del componente es el nombre del método y el tipo de componente es el tipo de valor de retorno.

@Lazy: configurado para carga diferida, usar con @Bean, esta clase solo se cargará cuando se use el objeto

@Scope ("prototype"): establece el alcance de la clase, el valor predeterminado es no escribir una sola instancia

Valor del parámetro de alcance:
singleton: // instancia única;
prototipo: // instancia múltiple;
solicitud: // una solicitud para crear una instancia;
sesión: // una sesión para crear una instancia;

@Configuration y @Bean testing:

/**
 * 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 、 @ Controlador 、 @ Servicio 、 @ Repositorio

Funciona de la misma manera que solíamos

@ComponenteScan

Es lo mismo que configuramos la ruta de escaneo en xml antes, siempre que haya una anotación de inyección de resorte en la ruta de escaneo, entonces se puede inyectar.
Esta anotación tiene algunos otros atributos: excluya esas clases, no escanee y cargue esas clases, y cárguelas siempre que se cumplan las condiciones

prueba:

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

1. includeFilters: Deje que los cargados en el contenedor ioc, si desea usar esto, debe agregar useDefaultFilters = false a continuación para que surta efecto
2. excludeFilters: No permita que los cargados en el contenedor ioc
3. El valor de tipo:

La clase genérica FilterType del valor de tipo tiene los siguientes valores:
ANNOTATION: usa filtrado de anotaciones;
ASSIGNABLE_TYPE: usa el tipo dado;
ASPECTJ: usa la expresión
ASPECTJ ; REGEX: usa expresión regular;
CUSTOM: usa reglas personalizadas, Necesita proporcionar una implementación de TypeFilter clase;

Filtro personalizado:

//要实现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 (): determina si el componente cumple con las condiciones, cumple con la creación y no cumple con la creación

public @interface Condicional { Clase <? extiende Condición> [] valor (); } Este parámetro de anotación puede poner muchos de nuestros jueces personalizados, solo es necesario escribir una clase para integrar la clase Condición e implementar el 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 anotación también deriva muchas subanotaciones:

@ConditionalOnBean: cuando hay un bean especificado en el contenedor @ConditionalOnClass: cuando hay una
clase especificada en la ruta de clases
@ConditionalOnExpression: basado en la expresión SpEL como condición de juicio
@ConditionalOnJava: basado en la versión JVM como condición de juicio
@ ConditionalOnJndi: en búsqueda JNDI bajo las condiciones especificadas ubicación existente
@ConditionalOnMissingBean: en el caso donde el contenedor no está especificado en el Bean
@ConditionalOnMissingClass: bajo condiciones cuando la ruta de clase no está especificada clase de
@ConditionalOnNotWebApplication: el proyecto actual no está bajo el condiciones del proyecto web
@ConditionalOnProperty: especificado si hay un valor de atributo especificado
@ConditionalOnResource: hay una ruta de clase de recurso especificada
@ConditionalOnSingleCandidate: Bean solo cuando se especifica en un contenedor, o en el caso donde una pluralidad de Bean para especificar el preferido Frijol

Podemos juzgar qué clases se pueden inyectar en función de estas anotaciones y qué clases no se pueden inyectar.

@Import: importe rápidamente componentes al contenedor

@Import: el componente se registrará automáticamente en el contenedor, y el id es el nombre completo de la clase por defecto;
parámetros de anotación:
class array: importar todas las clases al contenedor ioc.
ImportSelector: Devuelve una matriz de los nombres de clase completos de los componentes que se van a importar, los nombres de los componentes son nombres de clase completos;
ImportBeanDefinitionRegistrar: registra manualmente el Bean en el contenedor y puede personalizar los nombres de los componentes.

ImportSelector: Necesita escribir una clase para implementar la interfaz ImportSelector e implementar métodos

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

ImportBeanDefinitionRegistrar: puede personalizar el nombre del componente registrado en el contenedor 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));
        }
    }
}

@Importación

A través de esta anotación, podemos importar el archivo Spring xml que escribimos en javaconfig y luego analizarlo de acuerdo con el formato javaconfig.
Adecuado para usar cuando el proyecto xml se convierte en un proyecto de anotación

@ConfigurationProperties (profix = "xxx")

Puede asignar valores a JavaBeans mediante archivos de configuración. Siempre que haya una configuración que comience con xxx en nuestro archivo de configuración, los nombres de atributo con los mismos nombres en este JavaBeans se vincularán y asignarán automáticamente.
El archivo de configuración de enlace solo puede ser el archivo application.properties
. El Javabean que se asignará debe existir en el contenedor ioc

archivo de propiedades:

person.name=张三
person.age=19

clase javaBean:

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

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

Resultado:

Esto vinculará automáticamente el archivo de configuración. Tenga cuidado, este javabean debe existir en el contenedor ioc para ser vinculado.


También se puede usar con:
@EnableConfigurationProperties () + anotación @ConfigurationProperties.

@EnableConfigurationProperties (xxx.class): Función:
1. Cargue xxx.class en el contenedor ioc
2. Active la función de enlace de datos de xxx