@ComponentScan注解 -【Spring底层原理】

深藏阁楼爱情的钟 2021-09-21 15:38 496阅读 0赞

一、注解用法

1. 背景知识

2. @ComponentScan注解作用

二、实例分析

1. excludeFilters=Filter\[ \]

2. includeFilters=filter\[ \]

3. \`FilterType.CUSTOM\`

三、源码追踪

--------------------

## @ComponentScan注解 -【Spring底层原理】 ##

> 案例已上传GitHub，欢迎star：https://github.com/oneStarLR/spring-annotation

## 一、注解用法 ##

### 1. 背景知识 ###

> 什么是组件？
> 
> 组件也是抽象的概念，可以理解为一些符合某种规范的类组合在一起就构成了组件，他可以提供某些特定的功能，但实际他们都是类，只不过有他们特殊的规定。组件和类的关系:符合某种规范的类的组合构成组件。

### 2. @ComponentScan注解作用 ###

1. 将组件自动加载到容器

加了包扫描@ComponentScan注解后，只要标注了@Controller、@Service、@Repository、@Component注解中的任何一个，其组件都会被自动扫描，加入到容器中。

2. 通过属性指定扫描

【1】`value`：指定要扫描的包

【2】`excludeFilters=Filter[ ]`：设置排除的过滤条件，指定扫描的时候按照什么规则排除哪些组件，不扫描哪些包

【3】`includeFilters=filter[ ]`：设置扫描过滤条件，指定扫描的时候按照什么规则包含哪些组件，满足该条件才进行扫描

【4】`自定义过滤规则`：通过实现TypeFilter接口，自定义过滤规则

下面咱们通过实例来分析一下@ComponentScan注解的作用

## 二、实例分析 ##

以maven项目为例，通过@ComponentScan、@Controller、@Service、@Repository注解获取容器中的对象：

// 启动类
    @Test
    public void TestMain(){
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);
        String[] beanNames = applicationContext.getBeanDefinitionNames();
        for(String beanName : beanNames){
            System.out.println("容器中对象名称："+beanName);
        }
    }
    
    // 配置类
    @Configuration
    @ComponentScan(value = "com.onestar")
    public class AppConfig {
    }
    
    // 控制层
    @Controller
    public class UserController {
    }
    
    // 业务层
    @Service
    public class UserService {
    }
    
    // 持久层
    @Repository
    public class UserDao {
    }

运行测试类，可以看到如下打印信息，除了spring启动时注入到容器的对象外，还有我们自己加了注解，被spring扫描，加入到容器中

*  `@ComponentScan(value = "com.onestar")`：value表示指定要扫描的包

![image-20210120110132056][]

点进@ComponentScan注解源码，我们可以看到，使用value可以指定要扫描的包，我们还可以排除要扫描的包，包含要扫描的包，甚至还可以自定义过滤规则

*  `excludeFilters=Filter[ ]`：指定扫描的时候按照什么规则排除哪些包
 *  `includeFilters=filter[ ]`：指定扫描的时候是需要包含哪些包

【@ComponentScan源码】

@Retention(RetentionPolicy.RUNTIME)
    @Target({ElementType.TYPE})
    @Documented
    @Repeatable(ComponentScans.class)
    public @interface ComponentScan {
        // 扫描路径
        @AliasFor("basePackages")
        String[] value() default {};
    
        // 扫描路径
        @AliasFor("value")
        String[] basePackages() default {};
    
        // 指定扫描类
        Class<?>[] basePackageClasses() default {};
    
        /**
        * 命名注册的Bean，可以自定义实现命名Bean，
        * 1、@ComponentScan(value = "spring.annotation.componentscan",nameGenerator = MyBeanNameGenerator.class)
        * MyBeanNameGenerator.class 需要实现 BeanNameGenerator 接口，所有实现BeanNameGenerator 接口的实现类都会被调用
        * 2、使用 AnnotationConfigApplicationContext 的 setBeanNameGenerator方法注入一个BeanNameGenerator
        * BeanNameGenerator beanNameGenerator = (definition,registry)-> String.valueOf(new Random().nextInt(1000));
        * AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        * annotationConfigApplicationContext.setBeanNameGenerator(beanNameGenerator);
        * annotationConfigApplicationContext.register(MainConfig2.class);
        * annotationConfigApplicationContext.refresh();
        * 第一种方式只会重命名@ComponentScan扫描到的注解类
        * 第二种只有是初始化的注解类就会被重命名
        * 列如第一种方式不会重命名 @Configuration 注解的bean名称，而第二种就会重命名 @Configuration 注解的Bean名称
        */
        Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
    
        /**
        * 用于解析@Scope注解，可通过 AnnotationConfigApplicationContext 的 setScopeMetadataResolver 方法重新设定处理类
        * ScopeMetadataResolver scopeMetadataResolver = definition -> new ScopeMetadata();  这里只是new了一个对象作为演示，没有做实际的逻辑操作
        * AnnotationConfigApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext();
        * annotationConfigApplicationContext.setScopeMetadataResolver(scopeMetadataResolver);
    
        * annotationConfigApplicationContext.register(MainConfig2.class);
        * annotationConfigApplicationContext.refresh();
        * 也可以通过@ComponentScan 的 scopeResolver 属性设置
        *@ComponentScan(value = "spring.annotation.componentscan",scopeResolver = MyAnnotationScopeMetadataResolver.class)
        */
        Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
    
        // 设置类的代理模式
        ScopedProxyMode scopedProxy() default ScopedProxyMode.DEFAULT;
    
        /**
        * 扫描路径 如 resourcePattern = "**/*.class"
        * 使用  includeFilters 和 excludeFilters 会更灵活
        */
        String resourcePattern() default "**/*.class";
    
        /**
        * 指示是否应启用对带有{@code @Component}，{@ code @Repository}，
        * {@ code @Service}或{@code @Controller}注释的类的自动检测。
        */
        boolean useDefaultFilters() default true;
    
        /**
        * 对被扫描的包或类进行过滤，若符合条件，不论组件上是否有注解，Bean对象都将被创建
        * @ComponentScan(value = "com.onestar",includeFilters = {
        *     @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class}),
        *     @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {UserDao.class}),
        *     @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class}),
        *     @ComponentScan.Filter(type = FilterType.ASPECTJ, pattern = "spring.annotation..*"),
        *     @ComponentScan.Filter(type = FilterType.REGEX, pattern = "^[A-Za-z.]+Dao$")
        * },useDefaultFilters = false)
        * useDefaultFilters 必须设为 false
        */
        ComponentScan.Filter[] includeFilters() default {};
    
        // 设置排除的过滤条件，指定扫描的时候按照什么规则排除哪些组件，排除要扫描的包，用法参考includeFilters
        ComponentScan.Filter[] excludeFilters() default {};
    
        /**
        * 指定是否应注册扫描的Bean以进行延迟初始化。
        * @ComponentScan(value = "com.onestar",lazyInit = true)
        */
        boolean lazyInit() default false;
    
        // @Filter注解，用于 includeFilters 或 excludeFilters 的类型筛选器
        @Retention(RetentionPolicy.RUNTIME)
        @Target({})
        public @interface Filter {
           /**
           * 要使用的过滤器类型，默认为 ANNOTATION 注解类型
           * @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = {Controller.class, Service.class})
           */
            FilterType type() default FilterType.ANNOTATION;
    
           /**
           * 过滤器的参数，参数必须为class数组，单个参数可以不加大括号
           * 只能用于 ANNOTATION 、ASSIGNABLE_TYPE 、CUSTOM 这三个类型
           * @ComponentScan.Filter(type = FilterType.ANNOTATION, value = {Controller.class, Service.class})
           * @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE, classes = {UserDao.class})
           * @ComponentScan.Filter(type = FilterType.CUSTOM, classes = {MyTypeFilter.class})
           */
            @AliasFor("classes")
            Class<?>[] value() default {};
    
           /**
           * 作用同上面的 value 相同
           * ANNOTATION 参数为注解类，如  Controller.class, Service.class, Repository.class
           * ASSIGNABLE_TYPE 参数为类，如 UserDao.class
           * CUSTOM  参数为实现 TypeFilter 接口的类 ，如 MyTypeFilter.class
           * MyTypeFilter 同时还能实现 EnvironmentAware，BeanFactoryAware，BeanClassLoaderAware，ResourceLoaderAware 
           * 这四个接口
           * EnvironmentAware
           * 此方法用来接收 Environment 数据 ，主要为程序的运行环境，Environment 接口继承自 PropertyResolver 接口，
           * 详细内容在下方
           * @Override
           * public void setEnvironment(Environment environment) {
           *    String property = environment.getProperty("os.name");
           * }
           * 
           * BeanFactoryAware
           * BeanFactory Bean容器的根接口，用于操作容器，如获取bean的别名、类型、实例、是否单例的数据
           * @Override
           * public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
           *     Object bean = beanFactory.getBean("BeanName")
           * }
           * 
           * BeanClassLoaderAware
           * ClassLoader 是类加载器，在此方法里只能获取资源和设置加载器状态
           * @Override
           * public void setBeanClassLoader(ClassLoader classLoader) {
           *     ClassLoader parent = classLoader.getParent();
           * }
           * 
           * ResourceLoaderAware
           * ResourceLoader 用于获取类加载器和根据路径获取资源
           * public void setResourceLoader(ResourceLoader resourceLoader) {
           *     ClassLoader classLoader = resourceLoader.getClassLoader();
           * }
           */
            @AliasFor("value")
            Class<?>[] classes() default {};
    
           /**
           * 这个参数是 classes 或 value 的替代参数，主要用于 ASPECTJ 类型和  REGEX 类型
           * ASPECTJ  为 ASPECTJ 表达式
           * @ComponentScan.Filter(type = FilterType.ASPECTJ, pattern = "com.onestar..*")
           * REGEX  参数为 正则表达式
           * @ComponentScan.Filter(type = FilterType.REGEX, pattern = "^[A-Za-z.]+Dao$")
           */
            String[] pattern() default {};
        }
    }

### 1. excludeFilters=Filter\[ \] ###

通过`excludeFilters=Filter[ ]`来排除要扫描的包，在配置类注解中修改：

@Configuration
    @ComponentScan(value = "com.onestar",excludeFilters = {
        @Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})})
    public class AppConfig {
    }

*  type：表示过滤类型，这里是按照注解进行过滤
 *  classes：表示过滤器参数，这里是过滤掉有@Controller和@Service注解的组件

> 查看源码我们可以得知，通过实现Filter接口的type属性用于设置过滤类型，默认值为`FilterType.ANNOTATION`，提供了这几个过滤类型：
> 
>  *  `FilterType.ANNOTATION`：按照注解过滤
>  *  `FilterType.ASSIGNABLE_TYPE`：按照给定的类型过滤
>  *  `FilterType.ASPECTJ`：按照ASPECTJ表达式过滤
>  *  `FilterType.REGEX`：按照正则表达式过滤
>  *  `FilterType.CUSTOM`：按照自定义规则过滤
> 
> classes和value属性为过滤器的参数，必须为class数组，类只能为以下三种类型：
> 
>  *  ANNOTATION 参数为注解类，如 `Controller.class, Service.class, Repository.class`
>  *  ASSIGNABLE\_TYPE 参数为类，如 UserDao.class
>  *  CUSTOM 参数为实现 TypeFilter 接口的类 ，如 MyTypeFilter.class

通过上面的`excludeFilters`注解配置，咱们再来运行一下测试类，打印信息如下，可以看到，标有@Controller和@Service注解的组件不被扫描：

![image-20210120115812025][]

### 2. includeFilters=filter\[ \] ###

通过`includeFilters=Filter[ ]`只需要包含要扫描的包，在配置类注解中修改，默认的规则是扫描value下所有的包，所以我们要禁用这个规则：

@Configuration
    @ComponentScan(value = "com.onestar",includeFilters = {
        @Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})},useDefaultFilters = false)
    public class AppConfig {
    }

*  `useDefaultFilters = false`：禁用默认扫描规则

通过上面的`includeFilters`注解配置，咱们再来运行一下测试类，打印信息如下，可以看到，标有@Controller和@Service注解的组件才被扫描：

![image-20210120133305643][]

### 3. \`FilterType.CUSTOM\` ###

上面提到，可以使用`FilterType.CUSTOM`按照自定义规则进行过滤，通过源码，我们知道，可以实现TypeFilter的实现类来进行自定义过滤

public class MyTypeFilter implements TypeFilter {
        /**
         * @description TODO
         * @author ONESTAR
         * @date 2021/1/20 14:29
         * @param metadataReader:读取到当前正在扫描的类的信息
         * @param metadataReaderFactory：可以获取到其他任何类的信息
         * @throws
         * @return boolean
         */
        @Override
        public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
            // 获取当前类注解的信息
            AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
            // 获取当前正在扫描的类的信息
            ClassMetadata classMetadata = metadataReader.getClassMetadata();
            // 获取当前类资源
            Resource resource = metadataReader.getResource();
            String className = classMetadata.getClassName();
            // 指定包含“serv”的组件进行扫描
            if(className.contains("serv")){
                return true;
            }
            return false;
        }
    }

该实现类通过获取当前所有资源组件，并进行指定扫描，这里包含“serv”的组件进行扫描，然后修改配置类指定自定义扫描规则：

@Configuration
    @ComponentScan(value = "com.onestar",includeFilters = {
        @Filter(type = FilterType.CUSTOM,classes = {MyTypeFilter.class})},useDefaultFilters = false)
    public class AppConfig {
    }

*  `MyTypeFilter.class`：指定自定义过滤参数

运行测试类，可以看到打印信息，包含“serv”的组件进行扫描：

![image-20210120150558862][]

## 三、源码追踪 ##

同样，咱们以`AnnotationConfigApplicationContext`类为入口，点进去跟踪源码：

![image-20210120153916014][]

> 通过refresh()跟踪Bean 工厂的后置处理器调用：

![image-20210120154049710][]

> 继续跟踪，查看源码，这里实例化并调用所有已注册的`BeanFactoryPostProcessor`：

![image-20210120154529999][]

> 继续跟踪，主方法中有一些加载顺序之类的，找到invokeBeanDefinitionRegistryPostProcessors，查看调用Bean的注册定义的后置处理器的方法，进入源码查看：

![image-20210120154800082][]

> 继续跟踪，这里有个循环，会把所有的处理器拿出来进行处理：

![image-20210120154908717][]

> 继续跟踪，可以看到是一个接口，进入查看实现类，我们可以看到一个配置Bean的定义，就是指我们Configuration配置的里面的一些Bean的定义：

![image-20210120155028837][]

> 继续跟踪，`processConfigBeanDefinitions`类中可以看到`Configuration`类的解析器，通过`parser.parse(candidates);`把要扫描的东西进行解析

![image-20210120155811376][]

> 继续跟踪，判断我们声明的是否是一个注解Bean，是的话，再进行解析

![image-20210120155951900][]

> 继续跟踪：

![image-20210120160043671][]

> 继续跟踪，在`processConfigurationClass`方法中找到和配置相关的方法：

![image-20210120160159810][]

> 继续跟踪，可以看到和@ComponentScan注解注解相关的东西了，我们进入`componentScanParser.parse`看其具体的解析方法：

![image-20210120160559967][]

> 继续跟踪，查看构造方法：

![image-20210120160754435][]

> 继续跟踪，前面我们讲到`useDefaultFilters`表示默认扫描规则，默认是true：

![image-20210120160857561][]

> 跟踪到这就可以了，就是在这里将所有标有@Component注解的组件都添加到我们的includeFiltes里面去，而`@Controller、@Service、@Repository`注解都标有`@Component`注解，所以只要标注了@Controller、@Service、@Repository、@Component注解中的任何一个，其组件都会被自动扫描，加入到容器中

![image-20210120161124699][]

[image-20210120110132056]: /images/20210920/24df095246a44726b22036bc0190056a.png
[image-20210120115812025]: /images/20210920/947a8d4f2bc6495ab87098a9e4f60dcd.png
[image-20210120133305643]: /images/20210920/e326dcad8ae84ddab93ed2bd3182d869.png
[image-20210120150558862]: /images/20210920/8eb2b3fd84fa4dcdbaa0f41d8a9fe381.png
[image-20210120153916014]: /images/20210920/f4207ba68a4b4c75812a40fe72bf4bfb.png
[image-20210120154049710]: /images/20210920/9f0dbe5dd698402e92aec8b4f12e5738.png
[image-20210120154529999]: /images/20210920/6979f62631be437abd705abfc84c78db.png
[image-20210120154800082]: /images/20210920/3c5df6b2761840049ccb063c1d098f35.png
[image-20210120154908717]: /images/20210920/52de2db25eb54f40800ebddf609078dd.png
[image-20210120155028837]: /images/20210920/25bf257d61984c0b9be38c89f381583e.png
[image-20210120155811376]: /images/20210920/7a5ba70ca92d413f9796ebdc0a701100.png
[image-20210120155951900]: /images/20210920/e5ba265bfdd44fc8b587be3e43ec41e9.png
[image-20210120160043671]: /images/20210920/96f180fc1e83499cb8a0f0a83d466296.png
[image-20210120160159810]: /images/20210920/8056346a54e141dfbf111f90467cf4e8.png
[image-20210120160559967]: /images/20210920/f2ef53e8aef5478fb8e28886207cb1c4.png
[image-20210120160754435]: /images/20210920/dd552c2ad85542bd8ea7975efaf2117f.png
[image-20210120160857561]: /images/20210920/f712b2593bb6405490378da810e58811.png
[image-20210120161124699]: /images/20210920/ec59045e975d4384957d6aca29be2cb2.png