Explicación de uso del nivel de niñera @CompentScan

• j3_liuliang
• El desarrollo de Spring basado en anotaciones que aprendí antes, ahora revisaré y escribiré la serie de anotaciones de Spring. Si lo encuentra útil, ¡puede prestar atención al seguimiento que se seguirá publicando!

Uno, @CompentScan

Registro de @ComponentScancomponentes: escanee componentes automáticamente y especifique reglas de escaneo

1) En la forma de configuración del archivo xml, podemos configurarlo así:

<!-- 包扫描、只要标注了@Controller、@Service、@Repository，@Component -->
<context:component-scan base-package="cn.liuliang"/>

2) Anteriormente, el escaneo de paquetes se escribía en el archivo de configuración xml. Ahora podemos escribir el escaneo de paquetes en la clase de configuración:

@Configuration //声明该类是配置类
@ComponentScan("cn.liuliang.studysoundcodespring") //包扫描
public class SpringConfig {
    
    
    /**
     * 向容器中主入一个bean组件
     * @return
     */
    @Bean
    public User user(){
    
    
        // 通过new创建对象，放入容器中
        return new User("j3-liuliang",28);
    }
}

3) Resultados

A partir de los resultados de las pruebas anteriores, podemos encontrar que la clase de configuración principal SpringConfig también es un componente en el contenedor IOC y también se incluye en la gestión del contenedor IOC:

Desde nuestro @Configurationpunto en el interior puede encontrar este comentario también marcado la anotación @Componentde este comentario, también se incorpora al contenedor IOC como un componente:

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    
    

	/**
	 * Explicitly specify the name of the Spring bean definition associated
	 * with this Configuration class. If left unspecified (the common case),
	 * a bean name will be automatically generated.
	 * <p>The custom name applies only if the Configuration class is picked up via
	 * component scanning or supplied directly to a {@link AnnotationConfigApplicationContext}.
	 * If the Configuration class is registered as a traditional XML bean definition,
	 * the name/id of the bean element will take precedence.
	 * @return the specified bean name, if any
	 * @see org.springframework.beans.factory.support.DefaultBeanNameGenerator
	 */
	String value() default "";

}

En @ComponentScanesta anotación, también puede especificar qué paquetes excluir o incluir solo los paquetes que se administran: hay una matriz de filtro de paso []

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    
    

    // 忽略其他源代码
    
    /**
	 * Indicates whether automatic detection of classes annotated with {@code @Component}
	 * {@code @Repository}, {@code @Service}, or {@code @Controller} should be enabled.
	 */
    // 默认扫描规则，默认值true
	boolean useDefaultFilters() default true;
    
	/**
	 * Specifies which types are eligible for component scanning.
	 * <p>Further narrows the set of candidate components from everything in {@link #basePackages}
	 * to everything in the base packages that matches the given filter or filters.
	 * <p>Note that these filters will be applied in addition to the default filters, if specified.
	 * Any type under the specified base packages which matches a given filter will be included,
	 * even if it does not match the default filters (i.e. is not annotated with {@code @Component}).
	 * @see #resourcePattern()
	 * @see #useDefaultFilters()
	 */
    // 只扫描指定路径包，不过要将默认扫描规则关闭
	Filter[] includeFilters() default {
    
    };

	/**
	 * Specifies which types are not eligible for component scanning.
	 * @see #resourcePattern
	 */
    // 排除一些包不扫描
	Filter[] excludeFilters() default {
    
    };
}

1.1 excludeFilters

Entonces podemos operar de la siguiente manera:

excludeFilters：排除某某不扫描

@Configuration //声明该类是配置类
//@ComponentScan("cn.liuliang.studysoundcodespring") //包扫描
@ComponentScan(value = "cn.liuliang.studysoundcodespring",excludeFilters = {
    
    
        //这里面是一个@Filter注解数组，FilterType.ANNOTATION表示的排除的规则 ：按照注解的方式来进行排除
        //classes = {Controller.class,Service.class}表示的是标有这些注解的类给排除掉
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {
    
    Controller.class, Service.class})
})
public class SpringConfig {
    
    
    /**
     * 向容器中主入一个bean组件
     * @return
     */
    @Bean
    public User user(){
    
    
        // 通过new创建对象，放入容器中
        return new User("j3-liuliang",28);
    }
}

1.2 includeFilters

includeFilters：指定在扫描的时候，只需要包含哪些组件

Cuando se utiliza el método de configuración del archivo xml para configurar, las reglas de configuración predeterminadas deben estar deshabilitadas y solo la configuración de qué componentes puede tener efecto

<context:component-scan base-package=“cn.liuliang.springannotationdemo” use-default-filters=“false”/>

@Configuration //声明该类是配置类
//@ComponentScan("cn.liuliang.studysoundcodespring") //包扫描
@ComponentScan(value = "cn.liuliang.studysoundcodespring",includeFilters = {
    
    
    //这里面是一个@Filter注解数组，FilterType.ANNOTATION表示的排除的规则 ：按照注解的方式来进行扫描
    //classes = {Repository.class}表示的是只扫描标有这些注解的类
    @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
    
    Repository.class})
  // 禁用掉默认的配置规则
},useDefaultFilters = false)
public class SpringConfig {
    
    
    /**
     * 向容器中主入一个bean组件
     * @return
     */
    @Bean
    public User user(){
    
    
        // 通过new创建对象，放入容器中
        return new User("j3-liuliang",28);
    }
}

@ComponentScanEsta anotación se puede definir repetidamente: para especificar diferentes estrategias de exploración

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class) //可重复定义
public @interface ComponentScan {
    
    
}

Entonces podemos configurarlo de la siguiente manera: Pero si escribe de esta manera, debe admitir java8 y superior

@Configuration //声明该类是配置类
//@ComponentScan("cn.liuliang.studysoundcodespring") //包扫描，如下两个扫描配置相当于这一个配置
@ComponentScan(value = "cn.liuliang.studysoundcodespring",includeFilters = {
    
    
    //这里面是一个@Filter注解数组，FilterType.ANNOTATION表示的排除的规则 ：按照注解的方式来进行扫描
    //classes = {Repository.class}表示的是只扫描标有这些注解的类
    @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
    
    Repository.class})
},useDefaultFilters = false)
@ComponentScan(value = "cn.liuliang.studysoundcodespring",excludeFilters = {
    
    
    //这里面是一个@Filter注解数组，FilterType.ANNOTATION表示的排除的规则 ：按照注解的方式来进行扫描
    //classes = {Repository.class}表示的是不扫描标有这些注解的类
    @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
    
    Repository.class})
})
public class SpringConfig {
    
    
    /**
     * 向容器中主入一个bean组件
     * @return
     */
    @Bean
    public User user(){
    
    
        // 通过new创建对象，放入容器中
        return new User("j3-liuliang",28);
    }
}

二 、 ComponentScans

También se pueden utilizar @ComponentScanspara definir varias reglas de escaneo: hay @ComponentScanuna serie de reglas

//告诉Spring这是一个配置类
@Configuration
@ComponentScans(
        value = {
    
    
                @ComponentScan(value = "cn.liuliang.springannotationdemo",includeFilters = {
    
    
                        //这里面是一个@Filter注解数组，FilterType.ANNOTATION表示的排除的规则 ：按照注解的方式来进行扫描
                        //classes = {Controller.class}表示的是只扫描标有这些注解的类
                        @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {
    
    Controller.class})
                },useDefaultFilters = false)
                ,@ComponentScan(value = "cn.liuliang.springannotationdemo")
        }
)
public class PersionConfig {
    
    

}

2.1 Tipo de filtro

Registro de componentes: TypeFilter personalizado para especificar reglas de filtrado

Podemos echar un vistazo a los tipos de reglas de filtrado:

public enum FilterType {
    
    

    // 按照注解类型 比如@Controller @Service @Repository @Compent
	ANNOTATION,

    // 按照给定的类型来进行匹配
	ASSIGNABLE_TYPE,

    // 表达式来进行匹配，这个不常用
	ASPECTJ,

    // 按照正则表达式的方式来进行匹配
	REGEX,

    // 我们可以自己来写一个匹配规则的类：MyTypeFilter，这个类要实现TypeFilter这个接口
	CUSTOM

}

Hablemos del último: reglas de coincidencia personalizadasFilterType.CUSTOM

Podemos escribir una clase de regla coincidente por nosotros mismos: MyTypeFilter, esta clase debe implementar la interfaz TypeFilter

public class MyTypeFilter implements TypeFilter {
    
    
    /**
     *
     * @param metadataReader  the metadata reader for the target class 读取到当前正在扫描的类的信息
     * @param metadataReaderFactory a factory for obtaining metadata readers 可以获取到其他任何类的信息
     * @return
     * @throws IOException
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
    
    
        //获取到当前类注解的信息
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
        //获取当前类的资源的信息（比如类的路径）
        Resource resource = metadataReader.getResource();

        //获取到当前正在扫描的类的信息
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        String className = classMetadata.getClassName();
        System.out.println("通过自定义的匹配规则--->"+className);
        // false表示不扫描该组件
        return false;
    }
}

En este momento, podemos usarlo así: useFilterType.CUSTOM

//告诉Spring这是一个配置类
@Configuration
@ComponentScan(value = "cn.liuliang.springannotationdemo",includeFilters = {
    
    
        //自定义匹配的规则
        @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {
    
    MyTypeFilter.class}),
},useDefaultFilters = false)
public class SpringConfig {
    
    
    
}

Observaciones finales

• Debido a que los bloggers no tienen mucho conocimiento, inevitablemente habrá errores. Si encuentra un error o prejuicio, por favor deje un mensaje para señalarlo y lo corregiré.
• Si cree que el artículo no es malo, su reenvío, intercambio, me gusta y comentarios son su mayor aliento.
• Gracias por leer, bienvenidos y gracias por su atención.