Spring源码分析——AnnotationConfigApplicationContext组件注册流程

工程搭建

Maven依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.3.5</version>
    </dependency>
</dependencies>

在项目下新建一个byx.test包，然后在里面添加A、B、Config三个类：

public class A {
}

public class B {
}

@Component
public class Config {
}

A和B是两个普通的类（没有标注Component）注解，Config标注了Component注解，所以理论上只有Config会被注册到容器中。

然后再添加一个Main类作为启动类：

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext("byx.test");
        // 输出容器中的所有bean的name
        for (String name : ctx.getBeanDefinitionNames()) {
            System.out.println(name);
        }
    }
}

在main函数中，创建了一个AnnotationConfigApplicationContext，然后输出容器中所有bean的name。

最终的项目结构是这样的：

运行Main，控制台输出如下：

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
config

可以看到，容器中一共有5个bean，其中四个带internal的都是Spring内部自带的，config则是我们之前定义的Config类，下面就来探究一下这些组件是如何被注册的。

AnnotationConfigApplicationContext组件注册流程

在main函数的这一行加一个断点，并启动调试：

首先step into，然后多次step over，直到进入AnnotationConfigApplicationContext的构造函数:

继续step over，执行完this()调用：

这里分享一个调试Spring的小技巧，就是通过观察BeanFactory内部的beanDefinitionMap这个成员变量来分析组件注册的时机。beanDefinitionMap是一个ConcurrentHashMap，它的键是bean的name，值是对应的BeanDefinition。通过观察这个变量，我们就可以知道当前容器中所有已注册的bean信息。

现在把注意力放在调试器的Varieables面板，找到this.beanFactory.beanDefinitionMap这个变量。

可以看到，beanDefinitionMap的大小为4，里面已经有了四个bean：

这四个bean都是Spring内部自带的组件，由此可推测，Spring内部自带的组件的注册是在this()调用中，即AnnotationConfigApplicationContext的默认构造函数中完成的，。

继续step over，执行完scan(basePackages)这行后，发现beanDefinitionMap的大小变成了5，增加了一个name为config的bean，正是我们自定义的Config类（该类被Component注解标注）：

由此可推测，被Component注解标注的类是在scan(basePackages)调用中被注册的。从方法名可以推测，其内部执行了一个包扫描的操作。

Spring内置组件的注册

回到AnnotationConfigApplicationContext的构造函数：

public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    scan(basePackages);
    refresh();
}

从上面的分析可以知道，AnnotationConfigApplicationContext在它的默认构造函数中注册内部组件，即this()调用，实现如下：

public AnnotationConfigApplicationContext() {
    StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    this.reader = new AnnotatedBeanDefinitionReader(this);
    createAnnotatedBeanDefReader.end();
    this.scanner = new ClassPathBeanDefinitionScanner(this);
}

使用调试器跟踪，同时注意beanDefinitionMap的变化，发现注册操作发生在this.reader = new AnnotatedBeanDefinitionReader(this)这行代码中，所以直接查看AnnotatedBeanDefinitionReader的构造函数：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
    this(registry, getOrCreateEnvironment(registry));
}

继续进入另一个构造函数：

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    Assert.notNull(environment, "Environment must not be null");
    this.registry = registry;
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

真正的注册操作发生在AnnotationConfigUtils的registerAnnotationConfigProcessors方法中：

public static void registerAnnotationConfigProcessors(BeanDefinitionRegistry registry) {
    registerAnnotationConfigProcessors(registry, null);
}

继续进入registerAnnotationConfigProcessors重载方法，终于看到了核心代码（省略了一部分无关紧要的内容）：

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {
    ...
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    // 注册org.springframework.context.annotation.internalConfigurationAnnotationProcessor
    // ConfigurationClassPostProcessor用来处理Configuration注解
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册org.springframework.context.annotation.internalAutowiredAnnotationProcessor
    // AutowiredAnnotationBeanPostProcessor用来处理Autowired注解
    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }
    ...
    // 注册org.springframework.context.event.internalEventListenerProcessor
    // 与EventListener有关
    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    // 注册org.springframework.context.event.internalEventListenerFactory
    // 还是与EventListener有关
    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

registerAnnotationConfigProcessors方法内部注册了我们在控制台输出中看到的四个Spring内置组件。

Component注解的处理

回到AnnotationConfigApplicationContext的构造函数：

public AnnotationConfigApplicationContext(String... basePackages) {
    this();
    scan(basePackages);
    refresh();
}

从上面的分析可以知道，scan(basePackages)这个调用负责扫描并注册被Component标注的bean，该方法的实现如下：

public void scan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    StartupStep scanPackages = this.getApplicationStartup().start("spring.context.base-packages.scan")
            .tag("packages", () -> Arrays.toString(basePackages));
    this.scanner.scan(basePackages);
    scanPackages.end();
}

真正干活的是this.scanner.scan(basePackages)这个调用，其中this.scanner是一个ClassPathBeanDefinitionScanner的实例，它在AnnotationConfigApplicationContext的默认构造函数中被初始化：

public AnnotationConfigApplicationContext() {
    StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
    this.reader = new AnnotatedBeanDefinitionReader(this);
    createAnnotatedBeanDefReader.end();
    this.scanner = new ClassPathBeanDefinitionScanner(this); // 初始化scanner
}

ClassPathBeanDefinitionScanner的scan方法实现如下：

public int scan(String... basePackages) {
    int beanCountAtScanStart = this.registry.getBeanDefinitionCount();

    doScan(basePackages);

    // Register annotation config processors, if necessary.
    if (this.includeAnnotationConfig) {
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
    }

    return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}

scan方法内部调用了doScan方法，同时还记录了bean数量的改变量。doScan方法实现如下：

// basePackages就是我们在main函数中构造AnnotationConfigApplicationContext时传入的包名
// 从这里也可以看出，我们可以同时传入多个包名
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    // 遍历每个包名
    for (String basePackage : basePackages) {
        // 寻找每个包下符合条件的类，并包装成BeanDefinition
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        // 遍历找到的每个BeanDefinition
        for (BeanDefinition candidate : candidates) {
            // 设置scope属性
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            // 生成beanName
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
            // 设置一些默认属性
            if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            // 处理Lazy、Primary、DependsOn、Role、Description这些注解
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            // 把BeanDefinition包装成BeanDefinitionHolder
            if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder =
                        AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                // 真正执行注册操作
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    // 返回所有BeanDefinitionHolder
    return beanDefinitions;
}

doScan方法是注册bean的核心逻辑，它遍历每个传入的包名，通过调用findCandidateComponents方法来获取每个包下满足条件的bean，然后进行一些必要的设置，最后调用registerBeanDefinition方法完成注册操作。

findCandidateComponents方法的实现如下：

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
    if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
        return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    }
    else {
        return scanCandidateComponents(basePackage);
    }
}

scanCandidateComponents方法的实现如下：

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        // 将包名转换成一个资源url
        String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        // 读取资源
        Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
        boolean traceEnabled = logger.isTraceEnabled();
        boolean debugEnabled = logger.isDebugEnabled();
        // 遍历所有资源，每个资源表示一个.class文件
        for (Resource resource : resources) {
            if (traceEnabled) {
                logger.trace("Scanning " + resource);
            }
            if (resource.isReadable()) {
                try {
                    // 获取class的元数据，包括注解的信息
                    MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                    // 判断是否满足条件
                    if (isCandidateComponent(metadataReader)) {
                        // 构造BeanDefinition
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                        sbd.setSource(resource);
                        if (isCandidateComponent(sbd)) {
                            if (debugEnabled) {
                                logger.debug("Identified candidate component class: " + resource);
                            }
                            candidates.add(sbd);
                        }
                        else {
                            if (debugEnabled) {
                                logger.debug("Ignored because not a concrete top-level class: " + resource);
                            }
                        }
                    }
                    else {
                        if (traceEnabled) {
                            logger.trace("Ignored because not matching any filter: " + resource);
                        }
                    }
                }
                catch (Throwable ex) {
                    throw new BeanDefinitionStoreException(
                            "Failed to read candidate component class: " + resource, ex);
                }
            }
            else {
                if (traceEnabled) {
                    logger.trace("Ignored because not readable: " + resource);
                }
            }
        }
    }
    catch (IOException ex) {
        throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
    }
    // 返回所有满足条件的BeanDefinition
    return candidates;
}

scanCandidateComponents方法使用Spring内置的资源读取机制读取指定包下的所有class文件，然后转换成MetadataReader，并传入isCandidateComponent方法判断是否满足要求，如果满足要求则加入isCandidateComponent集合。

isCandidateComponent方法的实现如下：

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

isCandidateComponent方法通过excludeFilters和includeFilters两个集合来对MetadataReader进行过滤。在调试中可以发现，includeFilters包含了一个Component注解的过滤器，所以可以过滤出标注了Component的类。

如果使用调试器调试程序，可以发现，isCandidateComponent方法只会对Config类返回true，而对其他类（A、B、Main）都返回false。

includeFilters的初始化是在org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#registerDefaultFilters方法中被初始化的（ClassPathScanningCandidateComponentProvider是ClassPathBeanDefinitionScanner的父类）：

protected void registerDefaultFilters() {
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ...
}

到此，Component注解的处理过程就分析完了。