转载

曹工说Spring Boot源码（28）-- Spring的component-scan机制，让你自己来进行简单实现，怎么办

写在前面的话

概要

本讲相对独立，我们也不爱说废话，直接说本讲要做啥。

大家知道，@Component-scan注解，在注解时代，最主要的用法就是指定一个package的名称，然后spring就会去对应的包下面，扫描注解了@Controller、@Service、@Repository等注解的类，然后注册为bean。

spring boot时代，这个注解则站到了幕后，如下：

@Target({ElementType.TYPE})
  @Retention(RetentionPolicy.RUNTIME)
  @Documented
  @Inherited
  @SpringBootConfiguration
  @EnableAutoConfiguration
  @ComponentScan(
      excludeFilters = {
        @Filter(type = FilterType.CUSTOM,classes = {TypeExcludeFilter.class}),    
        @Filter( type = FilterType.CUSTOM,classes = {AutoConfigurationExcludeFilter.class})
      }
  )
  public @interface SpringBootApplication {
}

总之，这个注解大家再熟悉不过了。我们本讲，最核心的目标是，让大家更懂spring，方法呢，就是让我们自己来实现以下目标：

定义main类

@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
    public static void main(String[] args) {
         ...
}

这个上面定义了2个自定义的注解，都加了个前缀"My"。下面简单看看。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyConfiguration {
	
}

这个的效果，类似于@configuration，表示我们是一个配置类，配置类上一般会有一堆其他注解，来引入其他bean definition。

然后是MyComponentScan 注解：

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

    /*
     * 要扫描的包名
     */
    String value();

}

我们的target包下，有一个需要我们扫描的bean，如下：
```
package org.springframework.test;

@MyComponent
@MyComponentScan(value = "org.springframework.test1")
public class PersonService {
    private String personname1;
}
```
这里使用MyComponent注解，这个注解，用来注解我们要扫描为bean的那些类。比如这里，我们希望PersonService这个类，被扫描为bean。

其次，我们还定义了一个 @MyComponentScan(value = "org.springframework.test1") ，这个主要是：我们要能够支持递归处理。

当然，现在可以先忽略，权且当它不存在。

最终的测试效果如下：

import org.springframework.beans.factory.annotation.AnnotatedGenericBeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.custom.MyConfigurationClassPostProcessor;
import org.springframework.custom.annotation.MyComponentScan;
import org.springframework.custom.annotation.MyConfiguration;
import org.springframework.test1.AnotherPersonService;

@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class);
        context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition);

        /**
         * 注册一个beanFactoryPostProcessor,用来处理MyComponentScan注解
         */
        RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class);
        def.setSource(null);
        context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(),
                def);

        context.refresh();

        PersonService bean = context.getBean(PersonService.class);
        System.out.println(bean);
    }
}

输出如下：

12:39:27.259 [main] DEBUG o.s.b.f.s.DefaultListableBeanFactory - Returning cached instance of singleton bean 'personService'  org.springframework.test.PersonService@71ba5790

可以看到，我们的目标就是以上这样。为了实现这个目标，其实我们是仿照spring的实现，自己ctrl c/v了一把，其中进行了大量的简化。

实现思路

思路基本等同于spring的实现，因为本系列教程的目的就是让大家更懂Spring，所以没必要另辟蹊径。

用@MyConfiguration注解一个起点配置类

指定一个用 @MyConfiguration 注解的类，这个类一开始就会被注册为bean definition，类似于spring boot中的启动类，大家知道，spring boot中，启动类也是间接注解了 @SpringBootConfiguration，而 @SpringBootConfiguration呢，大家看看：

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

}

该注解，是注解了@configuration。

其实就是手动指定一个配置类，这个配置类，源码里好像是叫做startUp config，作为一个起点，通过这个起点，我们能发现在这个起点类上的，更多的元注解，比如，在我们公司的真实项目中，启动类就配置了一堆东西：

@SpringBootApplication
@EnableTransactionManagement
@EnableAspectJAutoProxy(exposeProxy = true)
@MapperScan("com.xxx.cad.mapper")
@ComponentScan("com.xxx")
@EnableFeignClients
//@Slf4j
@Controller
@EnableScheduling
public class CadWebService {

这个类，就是我们这里的起点类。这个起点类，然后被注册为一个bean。

注册一个BeanDefinitionRegistryPostProcessor，用来处理配置类上的@MyComponentScan，以发现更多bean

大家知道@configuration配置类，是怎么被处理的呢？就是通过 org.springframework.context.annotation.ConfigurationClassPostProcessor 。

这个类呢，实现了如下接口：

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {

	/**
	 * Modify the application context's internal bean definition registry after its
	 * standard initialization. All regular bean definitions will have been loaded,
	 * but no beans will have been instantiated yet. This allows for adding further
	 * bean definitions before the next post-processing phase kicks in.
	 * @param registry the bean definition registry used by the application context
	 * @throws org.springframework.beans.BeansException in case of errors
	 */
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

}

这个接口的这个方法的调用时机，是在：截止目前，通过配置(不论是xml，还是像上面第一步这样，去手动注册bean definition)的方式，能够找到的bean definition都已经找到了；本来，下一步就是找出其中的要eager-init的单例bean，去初始化了。

但是呢，在这之前，我们还有一个步骤，也算是一个扩展点吧，可以让我们去修改目前的bean definition集合。

如果举个通俗的例子，大概是这样的，比如，一个公司，组织大家出去玩，大家自愿报名，一开始假设报了10个人，预定周六出发；在此之前呢，公司再让大家确认一下，大家可以

增，带家属，带男女朋友；
删，自己不去了
改，我周六好像还要写bug，但我另一个同事没啥事，他可以去

而要实现这些，只要你实现前面我们提到的那个接口的方法即可，大家可以再观察下这个方法：

void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

入参是registry，也就是当前的报名表，报名表都给你了，你还有啥不能干的？

public interface BeanDefinitionRegistry extends AliasRegistry {
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	...
}

就拿上面那几个方法举例：

registerBeanDefinition，这个就是往名单上加人
removeBeanDefinition，这个就是自己不去了
BeanDefinition getBeanDefinition(String beanName)，这个可以用自己名字查到报名信息，改个名字，没问题吧？

@Configuration注解的处理，就是依赖于一个实现了 BeanDefinitionRegistry 接口的类，在这个类里，它干了很多事：

假如现在的名单里，只有我们的启动类，对吧，上面标了一坨注解，什么各种Enable，什么Component-scan啦，都有。但我们标注这些，比如component-scan，不是摆着玩的，是要去对应的package下，帮我们扫描bean的；这就是相当于说，要往名单上加人。

大致的逻辑可以理解为：

拿到初始名单，这里就是启动类的bean definition，以及一些其他手动弄进去的bean definition
通过实现了 BeanDefinitionRegistry 的 ConfigurationClassPostProcessor ，来看看第一步的初始名单中，有没有注解@Component-scan，如果没注解，直接返回；如果注解了，进入第三步；
拿到@component-scan里配置的要扫描的package名，然后获取这个package下的全部class，然后看看这些class满不满足条件（比如，只认注解了controller、service等注解的）
第三步筛出来的，满足条件的class，它们本身合格了，可以作为bean了；然后看看它们有没有作为配置类的资格，我拿下面的举例：
```
@Component
@ComponentScan(value = "xxxx.xxxx")
public class PersonService {
    private String personname1;
}
```
本身，上面这个例子中，PersonService因为component-scan的功劳，已经被收为bean了，但是，这不是结束，因为它自己上面还注解了@ComponentScan注解，而这，就需要去递归处理。

有些同学会觉得有点极端，maybe，但是，下面的例子极端吗：
```
@Component
@Import({MainClassForTestAnnotationConfig.class})
public class PersonService {
    private String personname1;
```
如果觉得@Import极端，那么@ImportResource去导入xml文件里的bean，这个场景，有些时候还是会遇到吧，比如，要兼容老程序的时候。

而我要说的就是，在 ConfigurationClassPostProcessor 处理@configuration注解的过程中，如果发现这个类上有以下行为，都会递归处理：
```
PropertySource
ComponentScan
Import
ImportResource
Bean
```
总体来说，这个类还是比较难的，而且会递归处理。

我们今天的demo，为了聚焦，也为了实现简单，先只处理了@component-scan本身的递归。

接下来，就来看看具体实现。

具体实现

测试类，主逻辑，驱动整体流程

@MyConfiguration
@MyComponentScan(value = "org.springframework.test")
public class BootStrap {
    public static void main(String[] args) {
        // 1
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        AnnotatedGenericBeanDefinition beanDefinition = new AnnotatedGenericBeanDefinition(BootStrap.class);
        context.registerBeanDefinition(BootStrap.class.getName(), beanDefinition);

        /**
         * 2 注册一个beanFactoryPostProcessor
         */
        RootBeanDefinition def = new RootBeanDefinition(MyConfigurationClassPostProcessor.class);
        def.setSource(null);
        context.registerBeanDefinition(MyConfigurationClassPostProcessor.class.getName(),
                def);
		// 3 
        context.refresh();
		// 4
        PersonService bean = context.getBean(PersonService.class);
        System.out.println(bean);
        
        AnotherPersonService anotherPersonService = context.getBean(AnotherPersonService.class);
        System.out.println(anotherPersonService);
    }
}

1处，使用spring默认的注解驱动上下文，设置：config的起点类为当前类，注册到spring容器
2处，注册一个 MyConfigurationClassPostProcessor 到spring 容器，这个和前面讲的ConfigurationClassPostProcessor 效果类似，用于解析我们自己的@MyComponentScan
3处，加载上下文
4处，获取bean，检测效果。

MyConfigurationClassPostProcessor，解析@MyComponentScan

@Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        log.info("postProcessBeanDefinitionRegistry...");
        
        /**
         * 1: 找到标注了{@link org.springframework.custom.annotation.MyConfiguration}注解的类
         * 这些类就是我们的配置类
         * 我们通过这些类，可以发现更多的bean definition
         */
        Set<BeanDefinitionHolder> beanDefinitionHolders = new LinkedHashSet<BeanDefinitionHolder>();
        for (String beanName : registry.getBeanDefinitionNames()) {
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            if (MyConfigurationUtils.checkConfigurationClassCandidate(beanDef)) {
                beanDefinitionHolders.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }
		// 2
        if (CollectionUtils.isEmpty(beanDefinitionHolders)) {
            return;
        }
		// 3
        MyConfigurationClassParser parser = new MyConfigurationClassParser(environment,registry);
        parser.parse(beanDefinitionHolders);
    }

1处，找到目前的，标注了 MyConfiguration注解的全部bean definition
2处，如果不存在，返回
3处，对第一步找到的集合，进行下一步处理

具体解析的工作，落在了第三步的身上，具体说，是MyConfigurationClassParser类的身上。

MyConfigurationClassParser具体执行者

public void parse(Set<BeanDefinitionHolder> configCandidates) {
        for (BeanDefinitionHolder holder : configCandidates) {
            BeanDefinition bd = holder.getBeanDefinition();
            String className = bd.getBeanClassName();

            try {
                processConfigurationClass(className);
            }
            catch (IOException ex) {
                throw new BeanDefinitionStoreException("Failed to load bean class: " + bd.getBeanClassName(), ex);
            }
        }
    }

这里就是对每个找到的配置类进行处理。比如，我们这里的demo，找到的就是启动类。

然后调用了下面的方法：

protected void processConfigurationClass(String className) throws IOException {
        MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(className);
        AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

        /**
         * 1. 判断该类上，是否有标注{@link MyComponentScan}
         */
        Map<String, Object> annotationAttributes = annotationMetadata.getAnnotationAttributes(MyComponentScan.class.getName(), true);
        AnnotationAttributes componentScan = AnnotationAttributes.fromMap(annotationAttributes);

        /**
         * 2. 如果类上有这个{@link MyComponentScan},则需要进行处理
         */
        if (componentScan != null) {
            /**
             * 3. 马上扫描这个base package路径下的bean，在里面，会注册beanDefinition到bean registry
             */
            Set<BeanDefinitionHolder> scannedBeanDefinitions =
                    this.componentScanParser.parse(componentScan, annotationMetadata.getClassName());

            /**
             * 4. 如果扫描回来的bean definition不为空，递归处理
             */
            if (!CollectionUtils.isEmpty(scannedBeanDefinitions)) {
                this.parse(scannedBeanDefinitions);
            }
        }

    }

1处，判断该类上，是否有标注 @MyComponentScan
2处，如果类上有这个 @MyComponentScan ,则需要进行处理
3处，马上扫描这个base package路径下的bean，在里面，会注册beanDefinition到bean registry
4处，对第三步扫描，得到bean，递归处理，查找更多bean

重点是这里的第三步，交给了一个叫componentScanParser的去处理，这个componentScanParser是在本类初始化的时候赋值的：

public MyConfigurationClassParser(Environment environment, BeanDefinitionRegistry registry) 	{
        this.environment = environment;
        this.registry = registry;
        this.componentScanParser = new MyComponentScanParser(componentScanBeanNameGenerator,
                environment,registry);
    }

MyComponentScanParser的处理过程

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, String className) {
        // 1
        String basePackage = componentScan.getString("value");
        // 2
        includeFilters.add(new AnnotationTypeFilter(MyComponent.class));
        // 3
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();

        /**
         * 4 获取包下的全部bean definition
         */
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        /**
         * 5 对扫描回来的bean，进行一定的处理，然后注册到bean registry
         */
        for (BeanDefinition candidate : candidates) {
            String generateBeanName = componentScanBeanNameGenerator.generateBeanName(candidate, registry);

            if (candidate instanceof AbstractBeanDefinition) {
                ((AbstractBeanDefinition)candidate).applyDefaults(this.beanDefinitionDefaults);
            }

            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }

            boolean b = checkCandidate(generateBeanName, candidate);
            if (b) {
                // 6
                beanDefinitions.add(new BeanDefinitionHolder(candidate,generateBeanName));
            }
        }

        /**
         * 7 注册到bean definition registry
         */
        for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitions) {
            registry.registerBeanDefinition(beanDefinitionHolder.getBeanName(),beanDefinitionHolder.getBeanDefinition());
        }

        return beanDefinitions;
    }

1处，获取MyComponentScan注解中value信息，表示要扫描的package
2处，设置识别bean的规则，这里是把注解了@MyComponent的，认为是自己人
3处，定义变量，用于存放返回的结果
4处，扫描包下的全部满足条件的，bean definition
5处，处理第4步拿到的bean definition集合
6处，加到待返回的结果集
7处，注册到spring容器

以上，只有第4处需要再次说明，其他都比较简单。

获取满足条件的bean definition的过程

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
    try {
        // 1
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                resolveBasePackage(basePackage) + "/" + this.resourcePattern;
        Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
        // 2
        for (Resource resource : resources) {
            log.info("Scanning " + resource);

            if (!resource.isReadable()) {
                continue;
            }
			// 3
            MetadataReader metadataReader = MyConfigurationUtils.getMetadataReader(resource);
            // 4
            if (isCandidateComponent(metadataReader)) {
                ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                sbd.setResource(resource);
                sbd.setSource(resource);
                // 5
                candidates.add(sbd);
            }
            else {
                log.info("Ignored because not matching any filter: " + resource);
            }
        }
    }
    ...

    return candidates;
}

1处，扫描包下的全部class
2处，遍历class
3处，获取该class的注解信息
4处，利用注解信息，判断是否是自己人（注解了@MyComponent）
5处，自己人，准备带走

其中，第4处，实现如下：

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        for (TypeFilter tf : this.includeFilters) {
            if (tf.match(metadataReader, MyConfigurationUtils.getMetadataReaderFactory())) {
                return true;
            }
        }
        return false;
    }

就是用includeFilters去匹配，大家还记得前面，我们设置了吧：

includeFilters.add(new AnnotationTypeFilter(MyComponent.class));

大致的过程，就是这样了。

dubbo中的实现，粗浅分析

我发现，好像和我上面说的，差得不太多，我也没用过dubbo，确实没参考dubbo的实现。

比如，它也定义了一个BeanDefinitionRegistryPostProcessor的实现类，叫：

public class ServiceAnnotationBeanPostProcessor implements BeanDefinitionRegistryPostProcessor, EnvironmentAware,
        ResourceLoaderAware, BeanClassLoaderAware {

其实现如下：

@Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

        registerBeans(registry, DubboBootstrapApplicationListener.class);
		// 1
        Set<String> resolvedPackagesToScan = resolvePackagesToScan(packagesToScan);

        if (!CollectionUtils.isEmpty(resolvedPackagesToScan)) {
            // 2
            registerServiceBeans(resolvedPackagesToScan, registry);
        } else {
            if (logger.isWarnEnabled()) {
                logger.warn("packagesToScan is empty , ServiceBean registry will be ignored!");
            }
        }

    }

1处，找到要扫描的package
2处，扫描指定包

上面的2处，实现如下：

private void registerServiceBeans(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

        DubboClassPathBeanDefinitionScanner scanner =
                new DubboClassPathBeanDefinitionScanner(registry, environment, resourceLoader);
		
        BeanNameGenerator beanNameGenerator = resolveBeanNameGenerator(registry);

        scanner.setBeanNameGenerator(beanNameGenerator);
		// 1
        scanner.addIncludeFilter(new AnnotationTypeFilter(Service.class));
		// 2
        scanner.addIncludeFilter(new AnnotationTypeFilter(com.alibaba.dubbo.config.annotation.Service.class));
		// 3
        for (String packageToScan : packagesToScan) {

            // 4 Registers @Service Bean first
            scanner.scan(packageToScan);
			// 5
            Set<BeanDefinitionHolder> beanDefinitionHolders =
                    findServiceBeanDefinitionHolders(scanner, packageToScan, registry, beanNameGenerator);
			// 6
            if (!CollectionUtils.isEmpty(beanDefinitionHolders)) {

                for (BeanDefinitionHolder beanDefinitionHolder : beanDefinitionHolders) {
                    // 7
                    registerServiceBean(beanDefinitionHolder, registry, scanner);
                }

            }

        }

    }

org.apache.dubbo.config.annotation.Service

总结

经过前面的讲解，大家应该立即更清楚一些了吧，如果还是有点懵，那最好把demo拉下来试试。

https://gitee.com/ckl111/spring-boot-first-version-learn/tree/master/all-demo-in-spring-learning/spring-annotation-custom-component-scan

如果大家觉得还有点帮助，帮忙点个赞吧。

原文 http://www.cnblogs.com/grey-wolf/p/12632419.html

正文到此结束

所属分类： Spring

本文标签： java tab cat 代码 parse dubbo BeanDefinition Collection springboot spring 源码 find NSA 遍历总结瑞士军刀 IO Spring Boot 递归 classpath tar Bootstrap 解析组织 ACE cache id HashSet 测试 js IDE HTML list http mapper Master Proxy ssl https redis App value src bean 希望字节码 root git UI CTO XML lib Service mmap EnableAutoConfiguration web 配置 CEO json dist Action WebService Feign apache db map 空间 Document client Property AOP bug
版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
本文海报： 生成海报一生成海报二

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

曹工说Spring Boot源码（28）-- Spring的component-scan机制，让你自己来进行简单实现，怎么办

写在前面的话

概要

实现思路

用@MyConfiguration注解一个起点配置类

具体实现

测试类，主逻辑，驱动整体流程

MyConfigurationClassPostProcessor，解析@MyComponentScan

MyConfigurationClassParser具体执行者

MyComponentScanParser的处理过程

获取满足条件的bean definition的过程

dubbo中的实现，粗浅分析

总结

热门推荐

相关文章

说给你听

本文目录

随机标签

书籍教程

近期评论

网站信息

其他链接

关于本站

问题交流