SpringBoot 源码解析：AnnotationConfigServletWebServerApplicationContext 构造流程

该类实现了 Application 接口，构造时传入的 this 即应用上下文实例。下图展示了其继承体系结构：

一、初始化注解 Bean 定义读取器

构造 AnnotatedBeanDefinitionReader 时，主要完成三件事：获取注册表、获取环境对象、注册后置处理器。

public class AnnotatedBeanDefinitionReader {
    private final BeanDefinitionRegistry registry;
    private ConditionEvaluator conditionEvaluator;

    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);
    }
}

1. BeanDefinitionRegistry（Bean 定义注册接口）

这里的 registry 参数实际上就是当前应用上下文 AnnotationConfigServletWebServerApplicationContext 本身。它是 Spring 容器管理 Bean 定义的核心接口，支持动态注册、移除和查询。

public interface BeanDefinitionRegistry extends AliasRegistry {
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
    void removeBeanDefinition(String beanName);
    BeanDefinition getBeanDefinition(String beanName);
    boolean containsBeanDefinition(String beanName);
    String[] getBeanDefinitionNames();
    int getBeanDefinitionCount();
    boolean isBeanNameInUse(String beanName);
}

2. 获取环境对象 Environment

环境对象通过注册表自动创建或获取。如果注册表实现了 EnvironmentCapable 接口，则直接调用；否则创建标准环境。

private static Environment getOrCreateEnvironment(BeanDefinitionRegistry registry) {
    Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
    if (registry instanceof EnvironmentCapable) {
        return ((EnvironmentCapable) registry).getEnvironment();
    }
    return new StandardEnvironment();
}

3. 注册注解配置处理器

这是构造过程中的关键步骤，系统会自动注册一系列处理特定注解的后置处理器。

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
        BeanDefinitionRegistry registry, @Nullable Object source) {

    // 获取默认的 ListableBeanFactory 对象
    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        // 设置依赖比较器，支持 @Order 注解排序
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        // 设置自动注入候选者解析器，处理 @Autowired 等
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);

    // 注册 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));
    }

    // 注册 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));
    }

    // 注册 CommonAnnotationBeanPostProcessor，处理 @Resource 等
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // 注册 EventListenerMethodProcessor，处理 @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));
    }

    return beanDefs;
}

3.1 获取默认 Bean 工厂

通过 unwrapDefaultListableBeanFactory 方法从注册表中提取 DefaultListableBeanFactory。该工厂负责管理容器中所有 Bean 的定义与生命周期。

@Nullable
private static DefaultListableBeanFactory unwrapDefaultListableBeanFactory(BeanDefinitionRegistry registry) {
    if (registry instanceof DefaultListableBeanFactory) {
        return (DefaultListableBeanFactory) registry;
    } else if (registry instanceof GenericApplicationContext) {
        return ((GenericApplicationContext) registry).getDefaultListableBeanFactory();
    } else {
        return null;
    }
}

这里设置了两个重要属性：

• AnnotationAwareOrderComparator：支持 @Order 注解的依赖排序比较器。
• ContextAnnotationAutowireCandidateResolver：处理基于注解的自动注入候选者解析。

3.2 注册后置处理器（注册 Bean 定义）

上述代码中创建的 RootBeanDefinition 主要用于 Spring 内部处理注解配置。注册时需将角色设置为 ROLE_INFRASTRUCTURE（基础设施），区别于用户业务 Bean 的 ROLE_APPLICATION。

private static BeanDefinitionHolder registerPostProcessor(
        BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}

这些后置处理器涵盖了常见的注解场景：

• ConfigurationClassPostProcessor：处理 @Configuration, @Bean, @Import, @ComponentScan。
• AutowiredAnnotationBeanPostProcessor：处理 @Autowired, @Value。
• CommonAnnotationBeanPostProcessor：处理 @PostConstruct, @PreDestroy, @Resource。
• EventListenerMethodProcessor：处理 @EventListener。

二、初始化类路径 Bean 定义扫描器

ClassPathBeanDefinitionScanner 负责扫描指定包路径下的组件类。

1. 注册默认注解过滤器

扫描器初始化时会注册默认的过滤规则，确保能识别标准的 Spring 组件注解。

protected void registerDefaultFilters() {
    // 添加 @Component 注解的过滤器
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
        // 尝试加载 JSR-250 ManagedBean 注解
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
    } catch (ClassNotFoundException ex) {
        // 忽略未找到异常
    }
    try {
        // 尝试加载 JSR-330 Named 注解
        this.includeFilters.add(new AnnotationTypeFilter(
            ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
    } catch (ClassNotFoundException ex) {
        // 忽略未找到异常
    }
}

2. 自定义包扫描

当调用扫描方法时，会遍历指定包路径，查找符合条件的候选组件并注册到容器中。

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) {
        Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
        for (BeanDefinition candidate : candidates) {
            ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
            candidate.setScope(scopeMetadata.getScopeName());
            String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);

            if (candidate instanceof AbstractBeanDefinition) {
                postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
            }
            if (candidate instanceof AnnotatedBeanDefinition) {
                AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
            }
            if (checkCandidate(beanName, candidate)) {
                BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                beanDefinitions.add(definitionHolder);
                registerBeanDefinition(definitionHolder, this.registry);
            }
        }
    }
    return beanDefinitions;
}

总结

本文详细拆解了 AnnotationConfigServletWebServerApplicationContext 构造过程中的核心逻辑。主要包括两部分：一是初始化注解 Bean 定义读取器，注册各类后置处理器以支持注解解析；二是初始化类路径 Bean 定义扫描器，配置默认过滤器以便后续组件扫描。理解这一过程有助于掌握 SpringBoot 容器启动及 Bean 加载的底层机制。