Spring源码解析 – AnnotationConfigApplicationContext容器建立过程

时间 2019-12-10

标签 spring 源码解析 annotationconfigapplicationcontext 容器建立过程栏目 Spring 繁體版

原文原文链接

Spring在BeanFactory基础上提供了一些列具体容器的实现，其中AnnotationConfigApplicationContext是一个用来管理注解bean的容器，从AnnotationConfigApplicationContext的实现结构图中能够看出：java

AnnotationConfigApplicationContext继承GenericApplicationContext这个通用应用上下文，GenericApplicationContext内部定义了一个DefaultListableBeanFactory实例，GenericApplicationContext实现了BeanDefinitionRegistry接口，因此能够经过AnnotationConfigApplicationContext实例注册bean defintion，而后调用refresh()方法来初始化上下文。
AnnotationConfigApplicationContext继承AbstractApplicationContext，AbstractApplicationContext提供了ApplicationContext的抽象实现。

下面经过一个示例分析AnnotationConfigApplicationContext的初始化过程：spring

 AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtensionConfig.class);

构造函数：bootstrap

1 //1. 初始化bean读取器和扫描器;
2     //调用父类GenericApplicationContext无参构造函数，初始化一个BeanFactory: DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory()
3    this();
4 //2.注册bean配置类
5    register(annotatedClasses);
6 //3.刷新上下文
7    refresh();
8 }

1. this() 初始化bean读取器和扫描器

1 public AnnotationConfigApplicationContext() {
2     //在IOC容器中初始化一个 注解bean读取器AnnotatedBeanDefinitionReader
3    this.reader = new AnnotatedBeanDefinitionReader(this);
4    //在IOC容器中初始化一个 按类路径扫描注解bean的 扫描器
5    this.scanner = new ClassPathBeanDefinitionScanner(this);

GenericApplicationContext部分代码:数据结构

 1 public class GenericApplicationContext extends AbstractApplicationContext implements BeanDefinitionRegistry {
 2 private final DefaultListableBeanFactory beanFactory;
 3 
 4 //初始化一个BeanFactory
 5 public GenericApplicationContext() {
 6       this.beanFactory = new DefaultListableBeanFactory();
 7     }
 8 
 9     …
10 }

2. register(annotatedClasses)

注册bean配置类, AnnotationConfigApplicationContext容器经过AnnotatedBeanDefinitionReader的register方法实现注解bean的读取，具体源码以下：app

AnnotationConfigApplicationContext.java中register方法异步

 1 //按指定bean配置类读取bean
 2 public void register(Class<?>... annotatedClasses) {
 3    for (Class<?> annotatedClass : annotatedClasses) {
 4       registerBean(annotatedClass);
 5    }
 6 }
 7 
 8 public void registerBean(Class<?> annotatedClass) {
 9    doRegisterBean(annotatedClass, null, null, null);
10 }
11 
12 //核心实现逻辑
13 <T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
14       @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
15     //将Bean配置类信息转成容器中AnnotatedGenericBeanDefinition数据结构, AnnotatedGenericBeanDefinition继承自BeanDefinition做用是定义一个bean的数据结构，下面的getMetadata能够获取到该bean上的注解信息
16    AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
17     //@Conditional装配条件判断是否须要跳过注册
18    if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
19       return;
20    }
21    //@param instanceSupplier a callback for creating an instance of the bean
22    //设置回调
23    abd.setInstanceSupplier(instanceSupplier);
24    //解析bean做用域(单例或者原型)，若是有@Scope注解，则解析@Scope，没有则默认为singleton 
25    ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
26 　　//做用域写回BeanDefinition数据结构, abd中缺损的状况下为空，将默认值singleton从新赋值到abd
27    abd.setScope(scopeMetadata.getScopeName());
28 　　//生成bean配置类beanName
29    String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
30    //通用注解解析到abd结构中，主要是处理Lazy, primary DependsOn, Role ,Description这五个注解
31    AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
32 　　//@param qualifiers specific qualifier annotations to consider, if any, in addition to qualifiers at the bean class level
33 　　// @Qualifier特殊限定符处理，
34    if (qualifiers != null) {
35       for (Class<? extends Annotation> qualifier : qualifiers) {
36          if (Primary.class == qualifier) {
37     // 若是配置@Primary注解，则设置当前Bean为自动装配autowire时首选bean
38             abd.setPrimary(true);
39          }
40 　　else if (Lazy.class == qualifier) {
41 　　//设置当前bean为延迟加载
42             abd.setLazyInit(true);
43          }
44          else {
45 　　　　　　//其余注解，则添加到abd结构中
46             abd.addQualifier(new AutowireCandidateQualifier(qualifier));
47          }
48       }
49    }
50 　　//自定义bean注册，一般用在applicationContext建立后，手动向容器中一lambda表达式的方式注册bean, 
51 　　//好比：applicationContext.registerBean(UserService.class, () -> new UserService());
52    for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
53　　　　 //自定义bean添加到BeanDefinition
54       customizer.customize(abd);
55    }
56    //根据beanName和bean定义信息封装一个beanhold,heanhold其实就是一个 beanname和BeanDefinition的映射
57    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
58 　　//建立代理对象
59    definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
60 　　// BeanDefinitionReaderUtils.registerBeanDefinition 内部经过DefaultListableBeanFactory.registerBeanDefinition(String beanName, BeanDefinition beanDefinition)按名称将bean定义信息注册到容器中，
61 　　// 实际上DefaultListableBeanFactory内部维护一个Map<String, BeanDefinition>类型变量beanDefinitionMap，用于保存注bean定义信息（beanname 和 beandefine映射）
62    BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
63 }

register方法重点完成了bean配置类自己的解析和注册，处理过程能够分为如下几个步骤：ide

根据bean配置类，使用BeanDefinition解析Bean的定义信息，主要是一些注解信息
Bean做用域的处理，默认缺乏@Scope注解，解析成单例
借助AnnotationConfigUtils工具类解析通用注解
将bean定义信息已beanname，beandifine键值对的形式注册到ioc容器中

3. refresh()刷新上下文

refresh方法在AbstractApplicationContext容器中实现，refresh()方法的做用加载或者刷新当前的配置信息，若是已经存在spring容器，则先销毁以前的容器，从新建立spring容器，载入bean定义，完成容器初始化工做，因此能够看出AnnotationConfigApplicationContext容器是经过调用其父类AbstractApplicationContext的refresh()函数启动整个IoC容器完成对Bean定义的载入。函数

AbstractApplicationContext.java中refresh方法的实现代码以下：工具

 1 public void refresh() throws BeansException, IllegalStateException {
 2    synchronized (this.startupShutdownMonitor) {
 3       //1.刷新前的预处理
 4       prepareRefresh();
 5 
 6       //2.获取刷新后的内部Bean工厂
 7       ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
 8 
 9       //3.BeanFactory的预准备工做
10       prepareBeanFactory(beanFactory);
11 
12       try {
13          // BeanFactory准备工做完成后，能够作一些后置处理工做，
14 　　　　  // 4.空方法，用于在容器的子类中扩展
15          postProcessBeanFactory(beanFactory);
16 
17          // 5. 执行BeanFactoryPostProcessor的方法，BeanFactory的后置处理器，在BeanFactory标准初始化以后执行的
18          invokeBeanFactoryPostProcessors(beanFactory);
19 
20          // 6. 注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean建立过程
21          registerBeanPostProcessors(beanFactory);
22 
23          // 7. 初始化MessageSource组件（作国际化功能；消息绑定，消息解析）
24          initMessageSource();
25 
26          // 8. 初始化事件派发器
27          initApplicationEventMulticaster();
28 
29          // 9.空方法，能够用于子类实如今容器刷新时自定义逻辑
30          onRefresh();
31 
32          // 10. 注册时间监听器，将全部项目里面的ApplicationListener注册到容器中来
33          registerListeners();
34 
35          // 11. 初始化全部剩下的单实例bean,单例bean在初始化容器时建立，原型bean在获取时（getbean）时建立
36          finishBeanFactoryInitialization(beanFactory);
37 
38          // 12. 完成BeanFactory的初始化建立工做，IOC容器就建立完成；
39          finishRefresh();
40       }
41 
42       catch (BeansException ex) {
43          if (logger.isWarnEnabled()) {
44             logger.warn("Exception encountered during context initialization - " +
45                   "cancelling refresh attempt: " + ex);
46          }
47 
48          // Destroy already created singletons to avoid dangling resources.
49          destroyBeans();
50 
51          // Reset 'active' flag.
52          cancelRefresh(ex);
53 
54          // Propagate exception to caller.
55          throw ex;
56       }
57 
58       finally {
59          // Reset common introspection caches in Spring's core, since we
60          // might not ever need metadata for singleton beans anymore...
61          resetCommonCaches();
62       }
63    }
64 }

具体分析refresh中的函数逻辑：post

1. 刷新预处理：

AbstractApplicationContext. prepareRefresh ()方法:

 1 protected void prepareRefresh() {
 2 　　//设置容器启动时间
 3    this.startupDate = System.currentTimeMillis();
 4 　　//启动标识
 5    this.closed.set(false);
 6    this.active.set(true);
 7 
 8    if (logger.isInfoEnabled()) {
 9       logger.info("Refreshing " + this);
10    }
11 
12    //空方法，用于子容器自定义个性化的属性设置方法
13    initPropertySources();
14    //检验属性的合法等
15    getEnvironment().validateRequiredProperties();
16 
17    //保存容器中的一些早期的事件
18    this.earlyApplicationEvents = new LinkedHashSet<>();
19 }

2. 获取刷新后的内部Bean工厂，obtainFreshBeanFactory方法为内部bean工厂从新生成id，并返回bean工厂

AbstractApplicationContext. obtainFreshBeanFactory()方法

 1 protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
 2 　　//为beanfactory生成惟一序列化id，beanfactory已经在GenericApplicationContext构造函数中初始化了，refreshBeanFactory的逻辑在AbstractApplicationContext的实现类GenericApplicationContext中
 3  refreshBeanFactory();
 4　　 //获取beanfactory
 5    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 6    if (logger.isDebugEnabled()) {
 7       logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
 8    }
 9    return beanFactory;
10 }

GenericApplicationContext.refreshBeanFactory()实现代码

1 protected final void refreshBeanFactory() throws IllegalStateException {
2    if (!this.refreshed.compareAndSet(false, true)) {
3       throw new IllegalStateException(
4             "GenericApplicationContext does not support multiple refresh attempts: just call 'refresh' once");
5    }
6 　　//生成一个序列化id
7    this.beanFactory.setSerializationId(getId());
8 }

这里使用AbstractApplicationContext. refreshBeanFactory()在不一样实现容器中有点区别，若是是以xml方式配置bean，会使用AbstractRefreshableApplicationContext容器中的实现，该容器中实现xml配置文件定位，并经过BeanDefinition载入和解析xml配置文件。

而若是是注解的方式，则并无解析项目包下的注解，而是经过在refresh()方法中执行ConfigurationClassPostProcessor后置处理器完成对bean的加载.

3.BeanFactory的预准备工做

prepareBeanFactory主要完成beanFactory的一些属性设置

 1 protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
 2    // Tell the internal bean factory to use the context's class loader etc.
 3    beanFactory.setBeanClassLoader(getClassLoader());  //设置类加载器
 4    beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); //bean表达式解析器
 5    beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
 6 
 7    // Configure the bean factory with context callbacks.
 8    beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));  //添加一个BeanPostProcessor实现ApplicationContextAwareProcessor
 9 //设置忽略的自动装配接口，表示这些接口的实现类不容许经过接口自动注入
10    beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
11    beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
12    beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
13    beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
14    beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
15    beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
16 
17    // BeanFactory interface not registered as resolvable type in a plain factory.
18    // MessageSource registered (and found for autowiring) as a bean.
19 //注册能够自动装配的组件，就是能够在任何组件中容许自动注入的组件
20    beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
21    beanFactory.registerResolvableDependency(ResourceLoader.class, this);
22    beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
23    beanFactory.registerResolvableDependency(ApplicationContext.class, this);
24 
25    // Register early post-processor for detecting inner beans as ApplicationListeners.
26    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
27 
28    //添加编译时的AspectJ
29    if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
30       beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
31       // Set a temporary ClassLoader for type matching.
32       beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
33    }
34 
35    // 给beanfactory容器中注册组件ConfigurableEnvironment、systemProperties、systemEnvironment
36    if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
37       beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
38    }
39    if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
40       beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
41    }
42    if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
43       beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
44    }
45 }

5.invokeBeanFactoryPostProcessors 执行bean工厂后置处理器

AbstractApplicationContext. invokeBeanFactoryPostProcessors方法实现：

 1 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 2    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
 3 
 4    // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
 5    // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
 6    if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
 7       beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
 8       beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
 9    }
10 }

invokeBeanFactoryPostProcessors方法内部执行实现了BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor这两个接口的Processor，先获取全部BeanDefinitionRegistryPostProcessor的实现，按优先级执行（是否实现PriorityOrdered优先级接口，是否实现Ordered顺序接口）；再以相同的策略执行全部BeanFactoryPostProcessor的实现。

PostProcessorRegistrationDelegate. invokeBeanFactoryPostProcessors实现:

  1 public static void invokeBeanFactoryPostProcessors(
  2       ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  3 
  4    // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  5    Set<String> processedBeans = new HashSet<>();
  6 
  7    if (beanFactory instanceof BeanDefinitionRegistry) {
  8       BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  9       List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
 10       List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
 11 
 12       for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
 13          if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
 14             BeanDefinitionRegistryPostProcessor registryProcessor =
 15                   (BeanDefinitionRegistryPostProcessor) postProcessor;
 16             registryProcessor.postProcessBeanDefinitionRegistry(registry);
 17             registryProcessors.add(registryProcessor);
 18          }
 19          else {
 20             regularPostProcessors.add(postProcessor);
 21          }
 22       }
 23 
 24       // Do not initialize FactoryBeans here: We need to leave all regular beans
 25       // uninitialized to let the bean factory post-processors apply to them!
 26       // Separate between BeanDefinitionRegistryPostProcessors that implement
 27       // PriorityOrdered, Ordered, and the rest.
 28       List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
 29 
 30       // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
 31       String[] postProcessorNames =
 32             beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 33       for (String ppName : postProcessorNames) {
 34          if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
 35             currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 36             processedBeans.add(ppName);
 37          }
 38       }
 39       sortPostProcessors(currentRegistryProcessors, beanFactory);
 40       registryProcessors.addAll(currentRegistryProcessors);
 41       invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 42       currentRegistryProcessors.clear();
 43 
 44       // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
 45       postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 46       for (String ppName : postProcessorNames) {
 47          if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
 48             currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 49             processedBeans.add(ppName);
 50          }
 51       }
 52       sortPostProcessors(currentRegistryProcessors, beanFactory);
 53       registryProcessors.addAll(currentRegistryProcessors);
 54       invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 55       currentRegistryProcessors.clear();
 56 
 57       // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
 58       boolean reiterate = true;
 59       while (reiterate) {
 60          reiterate = false;
 61          postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
 62          for (String ppName : postProcessorNames) {
 63             if (!processedBeans.contains(ppName)) {
 64                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
 65                processedBeans.add(ppName);
 66                reiterate = true;
 67             }
 68          }
 69          sortPostProcessors(currentRegistryProcessors, beanFactory);
 70          registryProcessors.addAll(currentRegistryProcessors);
 71          invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
 72          currentRegistryProcessors.clear();
 73       }
 74 
 75       // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
 76       invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
 77       invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
 78    }
 79 
 80    else {
 81       // Invoke factory processors registered with the context instance.
 82       invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
 83    }
 84 
 85    // Do not initialize FactoryBeans here: We need to leave all regular beans
 86    // uninitialized to let the bean factory post-processors apply to them!
 87    String[] postProcessorNames =
 88          beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
 89 
 90    // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
 91    // Ordered, and the rest.
 92    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 93    List<String> orderedPostProcessorNames = new ArrayList<>();
 94    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 95    for (String ppName : postProcessorNames) {
 96       if (processedBeans.contains(ppName)) {
 97          // skip - already processed in first phase above
 98       }
 99       else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
100          priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
101       }
102       else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
103          orderedPostProcessorNames.add(ppName);
104       }
105       else {
106          nonOrderedPostProcessorNames.add(ppName);
107       }
108    }
109 
110    // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
111    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
112    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
113 
114    // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
115    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
116    for (String postProcessorName : orderedPostProcessorNames) {
117       orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
118    }
119    sortPostProcessors(orderedPostProcessors, beanFactory);
120    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
121 
122    // Finally, invoke all other BeanFactoryPostProcessors.
123    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
124    for (String postProcessorName : nonOrderedPostProcessorNames) {
125       nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
126    }
127    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
128 
129    // Clear cached merged bean definitions since the post-processors might have
130    // modified the original metadata, e.g. replacing placeholders in values...
131    beanFactory.clearMetadataCache();
132 }

这里面在处理BeanDefinitionRegistryPostProcessors时有一个很是重要的过程，AnnotationConfigApplicationContext构造函数在初始化reader时为内部beanFactory容器初始化了一个id为org.springframework.context.annotation.internalConfigurationAnnotationProcessor的组件，这是一个ConfigurationClassPostProcessor组件，用来处理添加@Configuration注解的类，并将Bean定义注册到BeanFactory中。

6.注册BeanPostProcessor（Bean的后置处理器）,用于拦截bean建立过程

注册后置处理器的大体逻辑是：

　　1.获取全部的 BeanPostProcessor

　　2.根据处理器实现的接口区分出4中类型：

　　　　a.实现PriorityOrdered接口的处理器

　　　　b.实现Ordered接口的处理器，

　　　　c.实现MergedBeanDefinitionPostProcessor接口的处理器，

　　　　d.普通后置处理器

　　3.按这个4中类型依次注册到容器中

　　4.注册一个特殊的后置处理器ApplicationListenerDetector，ApplicationListenerDetector自己也实现了MergedBeanDefinitionPostProcessor接口，有个问题，这个为何没有在上面c,d之间注册，而是放到最后？

AbstractApplicationContext .registerBeanPostProcessors(beanFactory);实现逻辑：

1 protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
2    PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
3 }

 1 public static void registerBeanPostProcessors(
 2       ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 3 
 4    String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 5 
 6    // Register BeanPostProcessorChecker that logs an info message when
 7    // a bean is created during BeanPostProcessor instantiation, i.e. when
 8    // a bean is not eligible for getting processed by all BeanPostProcessors.
 9    int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
10    beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
11 
12    // Separate between BeanPostProcessors that implement PriorityOrdered,
13    // Ordered, and the rest.
14 //按优先级分类
15    List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
16    List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
17    List<String> orderedPostProcessorNames = new ArrayList<>();
18    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
19    for (String ppName : postProcessorNames) {
20       if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
21          BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
22          priorityOrderedPostProcessors.add(pp);
23          if (pp instanceof MergedBeanDefinitionPostProcessor) {
24             internalPostProcessors.add(pp);
25          }
26       }
27       else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
28          orderedPostProcessorNames.add(ppName);
29       }
30       else {
31          nonOrderedPostProcessorNames.add(ppName);
32       }
33    }
34 
35    //先注册实现PriorityOrdered接口的处理器，添加到beanfactory容器中beanFactory.addBeanPostProcessor(postProcessor);
36    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
37    registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
38 
39    //注册实现Ordered接口的处理器
40    List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
41    for (String ppName : orderedPostProcessorNames) {
42       BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
43       orderedPostProcessors.add(pp);
44       if (pp instanceof MergedBeanDefinitionPostProcessor) {
45          internalPostProcessors.add(pp);
46       }
47    }
48    sortPostProcessors(orderedPostProcessors, beanFactory);
49    registerBeanPostProcessors(beanFactory, orderedPostProcessors);
50 
51    // 注册没有实现Ordered或PriorityOrdered的处理器（nonOrderedPostProcessors）
52    List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
53    for (String ppName : nonOrderedPostProcessorNames) {
54       BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
55       nonOrderedPostProcessors.add(pp);
56       if (pp instanceof MergedBeanDefinitionPostProcessor) {
57          internalPostProcessors.add(pp);
58       }
59    }
60    registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
61 
62    // Finally, re-register all internal BeanPostProcessors.
63 　　//最后，从新注册全部internal BeanPostProcessors（实现MergedBeanDefinitionPostProcessor接口的后置处理器
64 65    sortPostProcessors(internalPostProcessors, beanFactory);
66    registerBeanPostProcessors(beanFactory, internalPostProcessors);
67 
68    //注册ApplicationListenerDetector，用于Bean建立完时检查是不是ApplicationListener
69    beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
70 }

7.初始化MessageSource组件（作国际化功能；消息绑定，消息解析）

AbstractApplicationContext .initMessageSource()方法实现代码：

 1 protected void initMessageSource() {
 2 //获取beanFactory
 3    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 4 //判断是否已经存在id为MESSAGE_SOURCE_BEAN_NAME的组件
 5    if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
 6       this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
 7       // Make MessageSource aware of parent MessageSource.
 8       if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
 9          HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
10          if (hms.getParentMessageSource() == null) {
11             // Only set parent context as parent MessageSource if no parent MessageSource
12             // registered already.
13             hms.setParentMessageSource(getInternalParentMessageSource());
14          }
15       }
16       if (logger.isDebugEnabled()) {
17          logger.debug("Using MessageSource [" + this.messageSource + "]");
18       }
19    }
20    else {
21       // Use empty MessageSource to be able to accept getMessage calls.
22       DelegatingMessageSource dms = new DelegatingMessageSource();
23       dms.setParentMessageSource(getInternalParentMessageSource());
24       this.messageSource = dms;
25       beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
26       if (logger.isDebugEnabled()) {
27          logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
28                "': using default [" + this.messageSource + "]");
29       }
30    }
31 }

8.初始化事件派发器

AbstractApplicationContext .initApplicationEventMulticaster()方法实现逻辑

 1 protected void initApplicationEventMulticaster() {
 2 //获取BeanFactory
 3    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
 4 //若是有配置beanName为applicationEventMulticaster的事件派发器，则将其赋给容器中的applicationEventMulticaster对象
 5    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
 6       this.applicationEventMulticaster =
 7             beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
 8       if (logger.isDebugEnabled()) {
 9          logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
10       }
11    }
12    else {
13 //不存在，则建立一个SimpleApplicationEventMulticaster事件派发器，并注册到beanfactory中
14       this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
15       beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
16       if (logger.isDebugEnabled()) {
17          logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
18                APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
19                "': using default [" + this.applicationEventMulticaster + "]");
20       }
21    }
22 }

10. 注册时间监听器，将项目里面的ApplicationListener注册到容器中来

registerListeners方法主要实现将事件监听器添加到IOC容器中的事件派发器中，并在最后作了一个事件发布的逻辑(若是以前的步骤有产生事件，则将earlyApplicationEvents中保存的事件逐一发布)

AbstractApplicationContext .registerListeners()方法实现逻辑：

 1 protected void registerListeners() {
 2    // Register statically specified listeners first.
 3    for (ApplicationListener<?> listener : getApplicationListeners()) {
 4       getApplicationEventMulticaster().addApplicationListener(listener);
 5    }
 6 
 7    // Do not initialize FactoryBeans here: We need to leave all regular beans
 8    // uninitialized to let post-processors apply to them!
 9    String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
10    for (String listenerBeanName : listenerBeanNames) {
11       getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
12    }
13 
14    // Publish early application events now that we finally have a multicaster...
15    Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
16    this.earlyApplicationEvents = null;
17    if (earlyEventsToProcess != null) {
18       for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
19          getApplicationEventMulticaster().multicastEvent(earlyEvent);
20       }
21    }
22 }

11. 初始化全部剩下的单实例bean,单例bean在初始化容器时建立，原型bean在获取时（getbean）时建立

AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory);方法实现代码：

 1 protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
 2    //组件转换器相关
 3    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
 4          beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
 5       beanFactory.setConversionService(
 6             beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
 7    }
 8 
 9    // Register a default embedded value resolver if no bean post-processor
10    // (such as a PropertyPlaceholderConfigurer bean) registered any before:
11    // at this point, primarily for resolution in annotation attribute values.
12    if (!beanFactory.hasEmbeddedValueResolver()) {
13       beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
14    }
15 
16    //aspectj相关.
17    String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
18    for (String weaverAwareName : weaverAwareNames) {
19       getBean(weaverAwareName);
20    }
21 
22    // Stop using the temporary ClassLoader for type matching.
23    beanFactory.setTempClassLoader(null);
24 
25    // Allow for caching all bean definition metadata, not expecting further changes.
26    beanFactory.freezeConfiguration();
27 
28    // 初始化后剩下的单实例bean
29    beanFactory.preInstantiateSingletons();
30 }

DefaultListableBeanFactory. preInstantiateSingletons()方法实现逻辑：

 1 public void preInstantiateSingletons() throws BeansException {
 2    if (logger.isDebugEnabled()) {
 3       logger.debug("Pre-instantiating singletons in " + this);
 4    }
 5 
 6    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
 7    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
 8 　　//容器中全部bean名称
 9    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
10 
11    // Trigger initialization of all non-lazy singleton beans...
12    for (String beanName : beanNames) {
13 　　//获取Bean的定义信息；RootBeanDefinition
14       RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
15 　　//非抽象，单例，非延迟加载
16       if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
17 　　//是不是FactoryBean
18          if (isFactoryBean(beanName)) {
19     // 经过"&beanName"获取工厂Bean实例
20             Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
21             if (bean instanceof FactoryBean) {
22                final FactoryBean<?> factory = (FactoryBean<?>) bean;
23                boolean isEagerInit;
24                if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
25                   isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
26                               ((SmartFactoryBean<?>) factory)::isEagerInit,
27                         getAccessControlContext());
28                }
29                else {
30                   isEagerInit = (factory instanceof SmartFactoryBean &&
31                         ((SmartFactoryBean<?>) factory).isEagerInit());
32                }
33                if (isEagerInit) {
34                   getBean(beanName);
35                }
36             }
37          }
38          else {
39 　　　　　　//不是FactoryBean,则利用getBean(beanName)实例化bean 
40             getBean(beanName);
41          }
42       }
43    }
44 
45    // Trigger post-initialization callback for all applicable beans...
46    for (String beanName : beanNames) {
47       Object singletonInstance = getSingleton(beanName);
48       if (singletonInstance instanceof SmartInitializingSingleton) {
49          final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
50          if (System.getSecurityManager() != null) {
51             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
52                smartSingleton.afterSingletonsInstantiated();
53                return null;
54             }, getAccessControlContext());
55          }
56          else {
57             smartSingleton.afterSingletonsInstantiated();
58          }
59       }
60    }
61 }

12. 完成BeanFactory的初始化建立工做，IOC容器就建立完成

AbstractApplicationContext.finishRefresh()实现逻辑：

 1 protected void finishRefresh() {
 2    // Clear context-level resource caches (such as ASM metadata from scanning).
 3    clearResourceCaches();
 4 
 5    //初始化和生命周期有关的后置处理器LifecycleProcessor，默认DefaultLifecycleProcessor
 6    initLifecycleProcessor();
 7 
 8    // 回调生命周期处理器
 9    getLifecycleProcessor().onRefresh();
10 
11    //发布容器刷新完成事件：ContextRefreshedEvent
12    publishEvent(new ContextRefreshedEvent(this));
13 
14    LiveBeansView.registerApplicationContext(this);
15 }

　　以上基本分析了AnnotationConfigApplicationContext容器的初始化过程， Spring容器在启动过程当中，会先保存全部注册进来的Bean的定义信息；Spring容器根据条件建立Bean实例，区分单例，仍是原型，后置处理器等（后置处理器会在容器建立过程当中经过getBean建立，并执行相应的逻辑）；Spring容器在建立bean实例后，会使用多种后置处理器来增长bean的功能，好比处理自动注入，AOP，异步，这种后置处理器机制也丰富了bean的功能。