1. 概述

1. 作為AnnotationConfigApplicationContext的欄位

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry {

    /**
     * 註解 Class 讀取器/處理器，在建構函式中建立
     * AnnotatedBeanDefinitionReader 被例項化時已經向容器注入了部分 BeanDefinition
     * 區分 BeanPostProcessor 和 BeanFactoryPostProcessor
     *
     * 從其提供的 API 來看，大致就是將一個 Class 解析為 BeanDefinition 放入 BeanFactory
     */
    private final AnnotatedBeanDefinitionReader reader;
}
 

2. 當AnnotationConfigApplicationContext建構函式傳入配置類/啟動類時，也是通過它進行轉換為BeanDefinition並注入容器

this.reader.register(componentClasses);

3. 功能
   其類頭註釋為

Convenient adapter for programmatic registration of bean classes.
This is an alternative to ClassPathBeanDefinitionScanner, applying the same resolution of annotations but for explicitly registered classes only.
 

便於將一個Class註冊到容器，類似一個 Helper 工具類，將一些功能抽出來專門作為一個類處理，單一職責。
類似於ClassPathBeanDefinitionScanner，不過這個類僅處理顯式註冊的類，而前者會自動在類路徑下查詢並註冊。

2. 建構函式

BeanDefinitionRegistry 例項作為屬性：registry 可看出是一個註冊器，能夠將 BD 注入容器，因此這個類肯定有註冊類的能力
Environmet：作為屬性，這個也挺重要的，但是這裡也暫略

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

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

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);
    // 註冊一些和處理配置類相關的 BeanDefinition
    // BeanPostProcessor 插手 Bean 的初始化過程
    // BeanFactoryPostProcessor 插手 BeanDefinition 的處理過程
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
 

3. EnvironmentCapable

ApplicationContext繼承了這個介面，因此所有的ApplicationContext子類都有這個功能。
單一職責。

public interface EnvironmentCapable {

    /**
     * Return the {@link Environment} associated with this component.
     */
    Environment getEnvironment();

}

4. registerAnnotationConfigProcessors

AnnotatedBeanDefinitionReader 呼叫它向 BeanDefinitionRegistry 注入了很多配置類處理器 ConfigProcessor
org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

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

    DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
    if (beanFactory != null) {
        if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
            beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
        }
        if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
            beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
        }
    }

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

    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // RootBeanDefinition 表明是 Spring 自己注入的
        // 是一個 BeanFactoryPostProcessor（BeanDefinitionRegistryPostProcessor），能夠插手 BeanDefinition 的處理過程
        RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一個 BeanPostProcessor，能夠插手 Bean 的例項化過程
        RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
    if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一個 BeanPostProcessor，能夠插手 Bean 的例項化過程
        RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
    if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
        // 是一個 BeanPostProcessor，能夠插手 Bean 的例項化過程
        RootBeanDefinition def = new RootBeanDefinition();
        try {
            def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                    AnnotationConfigUtils.class.getClassLoader()));
        }
        catch (ClassNotFoundException ex) {
            throw new IllegalStateException(
                    "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
        }
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
        // 是一個 BeanFactoryPostProcessor，能夠插手 BeanDefinition 的處理過程
        RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
    }

    if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
        // 較為普通的 Bean
        RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
        def.setSource(source);
        beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
    }

    return beanDefs;
}

private static BeanDefinitionHolder registerPostProcessor(
        BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    // 暫時不知道作用
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    registry.registerBeanDefinition(beanName, definition);
    return new BeanDefinitionHolder(definition, beanName);
}

注意，它上面雖然呼叫 unwrapDefaultListableBeanFactory 返回 DefaultListableBeanFactory，但並未強制要求，僅是一個可選項，而且僅是設定屬性，而非注入 BD

5. 注入的 BD

單獨 spring-context 使用 AnnotationConfigApplicationContext 時注入了那些東西呢（當使用WEB、SpringBoot時，可能還不一樣）
除了JPA的那個，其他都注入了

1. ConfigurationClassPostProcessor
   處理配置類的，能夠處理@ComponentScan、@Import等等註解。
   繼承 BeanDefinitionRegistryPostProcessor 可用於註冊 BD。
   BeanFactoryPostProcessor 可用於處理 BD。
   繼承 PriorityOrdered 但是 LOWEST_PRECEDENCE，也即排序優先順序最高，但是在繼承 PriorityOrdered 的類中優先順序又最低。
   這是一個及其核心和重要的類，由 Readre 預設註冊了。

2. AutowiredAnnotationBeanPostProcessor
   繼承 BeanPostProcessor，參與類的例項化過程。
   處理的註解：@Autowire、@Value、@Inject、@Lookup，前兩個是最常用的和主要的。

3. CommonAnnotationBeanPostProcessor
   繼承 BeanPostProcessor，參與類的例項化過程。
   處理生命週期註解 @PostConstructor、@PreDestroy。
   處理Java本身提供的註解而非Spring提供的：@Resource。等等

4. EventListenerMethodProcessor
   是一個 BeanFactoryPostProcessor，參與 BD 的生成，可處理/修改已註冊進入容器的BD。
   處理 @EventListener 註解的方法。

5. DefaultEventListenerFactory
   生成 ApplicationListener 的工廠。
   暫時不知道作用。