Spring中的@ComponentScan注解使用详解

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.8.RELEASE</version>
</dependency>

@ComponentScan(basePackages = "com.cxyxj.componentscan.app")
public class AppMain {
 
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppMain.class);
        // 打印 bean 名称
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String name : beanDefinitionNames){
            System.out.println(name);
        }
 
    }
}

<beans>
    <context:component-scan base-package="com.cxyxj"/>
</beans>

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
	// basePackages 的别名
    // 在没有其他属性的情况下可以如此写：@ComponentScan("com.cxyxj.componentscan")
    // 而不需要：@ComponentScan(basePackages = "com.cxyxj.componentscan")
	@AliasFor("basePackages")
	String[] value() default {};
    // 扫描带注解的包路径，默认是@Component
	@AliasFor("value")
	String[] basePackages() default {};
	// 扫描指定带注解的类，同时会扫描该类所在的包，默认是@Component
    //示例： @ComponentScan(basePackageClasses = {UserServiceImpl.class})
	Class<?>[] basePackageClasses() default {};
	// beanName 的生成器
	Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
	// 解析@Scope注解
	Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
	// 是否为扫描到的Bean生成代理
     /**
     * ScopedProxyMode有四个取值
     *  1.DEFAULT:默认值，默认情况下取no
     *  2.NO:不开启代理
     *  3.INTERFACES:使用jdk动态代理
     *  4.TARGET_CLASS:使用cglib代理
     *  假如有一个单例beanA，其中有一个属性B，B的Scope是session，此时，容器在启动时创建A的过程中需要注入B属性，
     *  但是B的scope是session,这种情况下是注入不了的（只有用户访问时才会创建），是会报错的
     *  但是如果将B的Scope的ProxyMode属性配置为INTERFACES或者TARGET_CLASS时，那么B就会生成一个ScopedProxyFactoryBean类型的BeanDefinitionHolder
     *  在A注入B时，就会注入一个ScopedProxyFactoryBean类型的Bean
     */
	ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
	// 控制符合组件检测条件的类文件，默认是包路径下的 **/*.class
	String resourcePattern() default ClassPathScanningCandidateComponentProvider.DEFAULT_RESOURCE_PATTERN;
	// 是否自动检测带有 @Component 注解的类，默认为 true
    // 像 @Repository、 @Controller、@Service、@Configuration 内部都包含了 @Component
	boolean useDefaultFilters() default true;
    /**
     * 如果扫描到的类符合 includeFilters 中的过滤条件
     * 这个类会被注册到容器中
     * 过滤类型与如下5种
     * 1、ANNOTATION：注解类型（默认）
     * 2、ASSIGNABLE_TYPE：指定类
     * 3、ASPECTJ：指定表达式
     * 4、REGEX：正则表达式
     * 5、CUSTOM：自定义类型
     */
	Filter[] includeFilters() default {};
	// 如果扫描到的类符合 excludeFilters 中的过滤条件
    // 这个类不会被注册
	Filter[] excludeFilters() default {};
	// 扫描到的类是否应延迟初始化，默认为 false
	boolean lazyInit() default false;
	// 声明要用作包含过滤器或排除过滤器的类型过滤器
	@Retention(RetentionPolicy.RUNTIME)
	@Target({})
	@interface Filter {
		// 要使用的过滤器类型，默认为 ANNOTATION
		FilterType type() default FilterType.ANNOTATION;
		// classes 的别名
		@AliasFor("classes")
		Class<?>[] value() default {};
    /**
     * 作用同上面的 value 相同
     * 过滤器的参数，参数必须为class数组
     * 只能用于 ANNOTATION 、ASSIGNABLE_TYPE 、CUSTOM 这三个类型
     * ANNOTATION：参数为注解类，比如：Controller.class
     * ASSIGNABLE_TYPE：参数为类，如 UserServiceImpl.class
     * CUSTOM：参数为实现 TypeFilter 接口的类 ，如 MyTypeFilter.class
     * 实现了TypeFilter 接口的类，还能实现 EnvironmentAware，BeanFactoryAware，		BeanClassLoaderAware，ResourceLoaderAware 这四个回调接口
     * 它们各自的方法将在 TypeFilter#match 之前被调用
     */
		@AliasFor("value")
		Class<?>[] classes() default {};
		//这个属性主要用于 ASPECTJ 类型和  REGEX 类型
		String[] pattern() default {};
	}
}

@Configuration
public class ProductServiceImpl {
}

public class UserServiceImpl {
}

@ComponentScan(basePackages = "com.cxyxj.componentscan.app",basePackageClasses = {UserServiceImpl.class})

@ComponentScan(basePackages = "com.cxyxj.componentscan.app",basePackageClasses = {UserServiceImpl.class},useDefaultFilters = false)

@ComponentScan(basePackages = "com.cxyxj.componentscan.app",
        basePackageClasses = {UserServiceImpl.class},
        useDefaultFilters = false,
        includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Configuration.class})
)

includeFilters = @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {UserServiceImpl.class})

includeFilters = @ComponentScan.Filter(type = FilterType.ASPECTJ,pattern = {"com.cxyxj.componentscan.impl.*"})

<!--aspectj 支持-->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.6</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

includeFilters = @ComponentScan.Filter(type = FilterType.REGEX,pattern = {"[A-Za-z.]+Impl$"})

public class CustomTypeFilter implements TypeFilter {
 
 
    /**
     *
     * @param metadataReader：可以获得当前正在扫描的类的信息
     * @param metadataReaderFactory：可以获得 MetadataReader。metadataReaderFactory.getMetadataReader(UserServiceImpl.class.getName());
     * @return match方法返回false 则表示不通过过滤规则，true 表示通过过滤规则
     * @throws IOException
     */
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        //Class元数据
        ClassMetadata classMetadata = metadataReader.getClassMetadata();
        //全限定名称
        String className = classMetadata.getClassName();
        //如果名称包含 User 则通过过滤
        if(className.contains("User")){
            return true;
        }
        return false;
    }
}

 includeFilters = @ComponentScan.Filter(type = FilterType.CUSTOM,value = {CustomTypeFilter.class})