Spring在BeanFactory基礎上提供了一些列具體容器的實現，其中AnnotationConfigApplicationContext是一個用來管理註解bean的容器，從AnnotationConfigApplicationContext的實現結構圖中可以看出：

• AnnotationConfigApplicationContext繼承GenericApplicationContext這個通用應用上下文，GenericApplicationContext內部定義了一個DefaultListableBeanFactory例項，GenericApplicationContext實現了BeanDefinitionRegistry介面，所以可以通過AnnotationConfigApplicationContext例項註冊bean defintion，然後呼叫refresh()方法來初始化上下文。
• AnnotationConfigApplicationContext繼承AbstractApplicationContext，AbstractApplicationContext提供了ApplicationContext的抽象實現。

下面通過一個示例分析AnnotationConfigApplicationContext的初始化過程：

 AnnotationConfigApplicationContext applicationContext  = new AnnotationConfigApplicationContext(ExtensionConfig.class);

建構函式：

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的讀取，具體原始碼如下：

 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配置類本身的解析和註冊，處理過程可以分為以下幾個步驟：

1. 根據bean配置類，使用BeanDefinition解析Bean的定義資訊，主要是一些註解資訊
2. Bean作用域的處理，預設缺少@Scope註解，解析成單例
3. 藉助AnnotationConfigUtils工具類解析通用註解
4. 將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中的函式邏輯：

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<BeanPos