IOC容器加載過程及Bean的生命周期和後置處理器

SpringIOC 容器加載過程

第一步：執行個體化化容器：AnnotationConfigApplicationContext

@Configuration
@ComponentScan("cn.zhe")
public class MainStartTest {
    public static void main(String[] args) {
        // SpringIOC 出發點 加載Spring上下文
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainStartTest.class);
        HelloSpring bean = applicationContext.getBean(HelloSpring.class);
        bean.sayHello();
    }
}

構造函數

// 根據參數可知，可以傳入多個Class，但這種情況及其少見
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    /**
    * 調用無參構造函數
    * 主要分三步：
    *    a.調用父類構造函數
    *    b.本類構造函數 初始化注解模式下的 bean定義讀取器 AnnotatedBeanDefinitionReader
    *    c.本類構造函數 初始化 classPath類型的 bean定義掃描器 AnnotatedBeanDefinitionScaner
    */
    this();
    /**
     * 注冊配置類
     * 把傳入的類進行注冊，分為兩種情況
     *     a. @Configuration的配置類
     *     b. 傳入普通 Bean (基本不會這麼做)
     *  Spring把配置類分為兩種
     *     a. 帶@Configuration注解的配置類稱之為FULL配置類
     *     b. 不帶@Configuration注解，是帶有@Component，@Import，@ImportResouce，
     *        @Service， @ComponentScan等注解的配置類稱之為Lite配置類
     */
    register(componentClasses);
    // 重新整理IOC容器
    refresh();
}

this()方法分析開始

第二步：執行個體化工廠：DefaultListableBeanFactory

DefaultListableBeanFactory 就是我們所說的容器，裡面放着beanDefinitionMap， beanDefinitionNames等

// 調用無參構造，會先調用父類GenericApplicationContext的構造函數
// 第一步調用父類構造函數，建立一個Bean工廠
public GenericApplicationContext() {
    /**
    * 調用父類的構造函數,為 ApplicationContext spring 上下文對象初始 beanFactory
    * 因為 DefaultListableBeanFactory 是最底層的實作，功能是最全的
    */
    this.beanFactory = new DefaultListableBeanFactory();
}

// 第二三步
 public class AnnotationConfigApplicationContext extends GenericApplicationContext 
     implements AnnotationConfigRegistry {
     // 注解bean定義讀取器，主要作用是用來讀取被注解的Bean
     private final AnnotatedBeanDefinitionReader reader;
     // 外部調用scan手動掃描的scanner對象,用處不大
     private final ClassPathBeanDefinitionScanner scanner;

     public AnnotationConfigApplicationContext() {
        /**
         * 初始化注解模式下的bean定義掃描器
         * 調用AnnotatedBeanDefinitionReader構造方法，傳入的
         * 是this(AnnotationConfigApplicationContext)對象
         */
        this.reader = new AnnotatedBeanDefinitionReader(this);
        /**
        * 初始化classPath類型的bean定義掃描器
        * 使用場景極少，僅外部手動調用掃描使用，正常方式是不會用到scanner對象的
        * 此處掃描器僅用于自定義的掃描 applicationContext.scan();
        */
        this.scanner = new ClassPathBeanDefinitionScanner(this);
    }
 }

第三步：執行個體化 BeanDefinition 讀取器 (AnnotatedBeanDefinitionReader)

主要就做了兩件事情：

注冊内置 BeanPostProcessor
注冊内置相關核心的 BeanDefinition

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   Assert.notNull(environment, "Environment must not be null");
   // 把ApplicationContext對象指派給AnnotatedBeanDefinitionReader
   this.registry = registry;
   // 使用者處理條件表達式計算 @Condition
   this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
   // 注冊一些配置的後置處理器，并注冊Spring内置的多個Bean
   AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}

關于

registerAnnotationConfigProcessors(this.registry);

方法内容較多，但大多相同的判斷，注冊 Spring 内置的多個 Bean，以

ConfigurationClassPostProcesso

為例：

/**
 * 為容器中注冊解析配置類的後置處理器 ConfigurationClassPostProcessor
 * org.springframework.context.annotation.internalConfigurationAnnotationProcessor
 */
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));
}

/**
 * 這方法為BeanDefinition設定了一個Role，ROLE_INFRASTRUCTURE代表這是spring内部的，并非使用者定義的
 * registry.registerBeanDefinition(beanName, definition);是一個接口方法，
 * 實作類是 DefaultListableBeanFactory
 *    核心工作就是
 *    a.this.beanDefinitionMap.put(beanName, beanDefinition);
 *      把beanName作為key，beanDefinition作為value，放到map裡面
 *    b.beanDefinitionNames就是一個List<String>,這裡就是把beanName放到List中去
 * DefaultListableBeanFactory就是我們所說的容器,裡面放着beanDefinitionMap， beanDefinitionNames，
 *      beanDefinitionMap是一個hashMap，beanName作為Key,beanDefinition作為Value，
 *      beanDefinitionNames是一個集合，裡面存放了beanName
 */
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 Bean
如果不存在，就通過 RootBeanDefinition 的構造方法獲得 ConfigurationClassPostProcessor 的BeanDefinition
執行 registerPostProcessor() 方法，其内部就是注冊Bean（與其他 Bean 注冊流程一緻）

internalConfigurationAnnotationProcessor

ConfigurationClassPostProcessor 是 Spring 中極其重要的一個類，它實作 BeanDefinitionRegistryPostProcessor 接口，BeanDefinitionRegistryPostProcessor 接口又擴充了 BeanFactoryPostProcessor 接口，BeanFactoryPostProcessor 是 Spring 的擴充點之一。

至此加載完以下擴充點（beanDefinition -> beanDefinitionMap）

第四步：建立 BeanDefinition 掃描器 (ClassPathBeanDefinitionScanner)

初始化 classPath 類型的 BeanDefinition 掃描器，使用場景極少，僅外部手動調用掃描使用，正常方式是不會用到 scanner 對象的此處掃描器僅用于自定義的掃描

applicationContext.scan()

。

至此this()方法結束

第五步：注冊配置類為BeanDefinition (register(annotatedClasses);)

/**
 * 注冊配置類
 * 把傳入的類進行注冊，分為兩種情況
 *     a. @Configuration的配置類
 *     b. 傳入普通 Bean (基本不會這麼做)
 * Spring把配置類分為兩種
 *     a. 帶@Configuration注解的配置類稱之為FULL配置類
 *     b. 不帶@Configuration注解，是帶有@Component，@Import，@ImportResouce，
 *        @Service， @ComponentScan等注解的配置類稱之為Lite配置類
 */
register(componentClasses);

public void register(Class<?>... componentClasses) {
    this.reader.register(componentClasses);
}

private <T> void doRegisterBean(Class<T> beanClass, @Nullable String name,
      @Nullable Class<? extends Annotation>[] qualifiers, @Nullable Supplier<T> supplier,
      @Nullable BeanDefinitionCustomizer[] customizers) {
   // AnnotatedGenericBeanDefinition可以了解為一種資料結構，是用來描述Bean的，這裡的作用就是把傳入
   // 的标記了注解的類轉為AnnotatedGenericBeanDefinition資料結構，裡面有一個getMetadata方法，可以拿到類上的注解
   AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(beanClass);
   // 判斷是否需要跳過注解，spring中有一個@Condition注解，當不滿足條件，這個bean就不會被解析
   if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
      return;
   }

   abd.setInstanceSupplier(supplier);
   // 解析bean的作用域，如果沒有設定的話，預設為單例
   ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
   abd.setScope(scopeMetadata.getScopeName());
   // 獲得beanName
   String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
   // 解析通用注解，填充到AnnotatedGenericBeanDefinition，
   // 解析的注解 Lazy，Primary，DependsOn，Role，Description
   AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
   if (qualifiers != null) {
      for (Class<? extends Annotation> qualifier : qualifiers) {
         if (Primary.class == qualifier) {
            abd.setPrimary(true);
         }
         else if (Lazy.class == qualifier) {
            abd.setLazyInit(true);
         }
         else {
            abd.addQualifier(new AutowireCandidateQualifier(qualifier));
         }
      }
   }
   if (customizers != null) {
      for (BeanDefinitionCustomizer customizer : customizers) {
         customizer.customize(abd);
      }
   }
   // 這個方法用處不大，就是把AnnotatedGenericBeanDefinition資料結構和beanName封裝到一個對象中
   BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
   definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
   // 注冊，最終會調用DefaultListableBeanFactory中的registerBeanDefinition方法去注冊
   // DefaultListableBeanFactory維護着一系列資訊，比如beanDefinitionNames，beanDefinitionMap
   // beanDefinitionMap是一個Map,用來儲存beanName和beanDefinition
   BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}

通過AnnotatedGenericBeanDefinition的構造方法，獲得配置類的BeanDefinition

判斷需不需要跳過注冊，Spring中有一個@Condition注解，如果不滿足條件，就會跳過這個類的注冊

然後是解析作用域，如果沒有設定的話，預設為單例

獲得BeanName

解析通用注解，填充到 AnnotatedGenericBeanDefinition，解析的注解為Lazy，Primary，DependsOn，Role，Description

限定符處理，不是特指@Qualifier注解，也有可能是Primary，或者是Lazy，或者是其他（理論上是任何注解，這裡沒有判斷注解的有效性）

把AnnotatedGenericBeanDefinition資料結構和beanName封裝到一個對象中（不重要，友善傳參）

注冊，最終會調用 DefaultListableBeanFactory 中的 registerBeanDefinition() 方法

至此，注冊配置類加載結束，配置類(MainStartTest，标記了@Configuration的類) 被放入 BeanDefinitionMap 中未執行個體化。（執行個體化都在

reflesh()

方法中進行）

至此register()方法結束,将我們傳入的配置類加載完畢即：mainStartTest

refresh() 方法分析開始

第六步：refresh();

到這一步 Spring 還沒有進行掃描，隻是執行個體化了一個工廠，注冊了一些内置的 Bean 和配置類，這一行是至關重要的一個方法，也是内容最多的，裡面做了大量的處理。

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 1:準備重新整理上下文環境
      // 重新整理預處理，和主流程關系不大，就是儲存了容器的啟動時間，啟動标志等
      prepareRefresh();

      //2:告訴子類初始化Bean工廠(MVC),擷取Bean工廠
      // 和主流程關系也不大，最終獲得了DefaultListableBeanFactory
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // 3:對Bean工廠進行填充屬性
      /**
       * ①添加了兩個後置處理器：
       *    a.ApplicationContextAwareProcessor
       *    b.ApplicationListenerDetector
       * ②設定忽略自動裝配和允許自動裝配的接口,如果不存在某個bean的時候，
       *  spring就自動注冊singleton bean
       * ③ 設定了bean表達式解析器
       */
      prepareBeanFactory(beanFactory);

      try {
         // 4:空方法 留給子類去實作該接口 允許在上下文子類中對Bean工廠進行後置處理。
         postProcessBeanFactory(beanFactory);

         // 5:調用Bean工廠的後置處理器.
         // 執行自定義的BeanFactoryPostProcessor和内置的BeanFactoryPostProcessor
         invokeBeanFactoryPostProcessors(beanFactory);

         // 6:注冊BeanPostProcessors
         registerBeanPostProcessors(beanFactory);

         // 7:初始化國際化資源處理器.
         initMessageSource();

         // 8:建立事件多點傳播器
         initApplicationEventMulticaster();

         // 9:這個方法同樣也是留個子類實作的springboot也是從這個方法進行啟動tomcat的.
         // 模闆方法，在容器重新整理的時候可以自定義邏輯，不同的Spring容器做不同的事情
         onRefresh();

         // 10:将事件監聽器注冊到多點傳播器上
         registerListeners();

         // 11:執行個體化懶加載單例Bean的，也就是Bean絕大部分都是在這裡被建立出來的
         finishBeanFactoryInitialization(beanFactory);

         // 12:最後容器重新整理 釋出重新整理事件(Spring cloud也是從這裡啟動的)
         finishRefresh();
      }

      catch (BeansException ex) {
         if (logger.isWarnEnabled()) {
            logger.warn("Exception encountered during context initialization - " +
                  "cancelling refresh attempt: " + ex);
         }

         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         throw ex;
      }

      finally {
         // 清除中繼資料緩沖，執行個體化後就不需要了
         resetCommonCaches();
      }
   }
}

下面來逐一解析裡面比較重要的幾個方法，有些不重要的就僅在上面注釋了

6.1 prepareBeanFactory(beanFactory)

顧名思義，BeanFactory的一些準備工作

設定了一個類加載器

設定了bean表達式解析器

添加了屬性編輯器的支援

添加了一個後置處理器：ApplicationContextAwareProcessor，此後置處理器實作了BeanPostProcessor接口

設定了一些忽略自動裝配的接口

設定了一些允許自動裝配的接口，并且進行了指派操作

在容器中還沒有XX的 bean 的時候，幫我們注冊 beanName 為 XX 的 singleton bean

6.2 invokeBeanFactoryPostProcessors(beanFactory)

首先看一下我們到這一步時 BeanDefinitionMap 裡面 bean 定義的情況：

/**
 * 調用Bean工廠的後置處理器.
 * 執行自定義的 BeanFactoryPostProcessor 和内置的 BeanFactoryPostProcessor
 */
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    // getBeanFactoryPostProcessors()，獲得外部可以手動添加一個後置處理器，如果不添加獲得的集合永遠為空
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
   // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
   // (例如通過ConfigurationClassPostProcessor注冊的@Bean方法)
   if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

   // 第一步:首先調用BeanDefinitionRegistryPostProcessor的後置處理器
   // 裝beanName 後續會根據這個集合來判斷處理器是否已經被執行過了
   Set<String> processedBeans = new HashSet<>();

   if (beanFactory instanceof BeanDefinitionRegistry) {
      // 強行把bean工廠轉為BeanDefinitionRegistry
      BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
      // 儲存BeanFactoryPostProcessor類型的後置
      List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
      List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
      // 循環傳遞進來的 beanFactoryPostProcessors，正常情況為資料，隻有手動添加了後置處理器才會有資料
      for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
         // 判斷後置處理器是不是 BeanDefinitionRegistryPostProcessor
         // 因為BeanDefinitionRegistryPostProcessor擴充了BeanFactoryPostProcessor
         if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
            // 進行強制轉換
            BeanDefinitionRegistryPostProcessor registryProcessor =
                  (BeanDefinitionRegistryPostProcessor) postProcessor;
            // 調用作為BeanDefinitionRegistryPostProcessor的處理器的後置方法
            registryProcessor.postProcessBeanDefinitionRegistry(registry);
            // 添加到用于儲存的BeanDefinitionRegistryPostProcessor的集合中
            registryProcessors.add(registryProcessor);
         }
         // 若沒有實作BeanDefinitionRegistryPostProcessor 接口，那麼它就是BeanFactoryPostProcessor
         // 把目前的後置處理器加入到regularPostProcessors中
         else {
            regularPostProcessors.add(postProcessor);
         }
      }

      // 定義一個集合使用者儲存目前準備建立的BeanDefinitionRegistryPostProcessor
      List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

      // 第一步:去容器中擷取BeanDefinitionRegistryPostProcessor的bean的處理器名稱
      // internalConfigurationAnnotationProcessor即ConfigurationAnnotationProcessor
      String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      // 循環上一步擷取的BeanDefinitionRegistryPostProcessor的類型名稱
      for (String ppName : postProcessorNames) {
         // 判斷是否實作了PriorityOrdered接口的
         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            // 顯示的調用getBean()的方式擷取出該對象然後加入到currentRegistryProcessors集合中去
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            // 同時也加入到processedBeans集合中去
            // 後續會根據這個集合來判斷處理器是否已經被執行過了
            processedBeans.add(ppName);
         }
      }
       // 對currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor進行排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
       // 把他加入到用于儲存到registryProcessors中
       // 為什麼要合并，因為registryProcessors是裝載BeanDefinitionRegistryPostProcessor的
       // 一開始的時候，spring隻會執行BeanDefinitionRegistryPostProcessor獨有的方法
       // 而不會執行BeanDefinitionRegistryPostProcessor父類的方法，即BeanFactoryProcessor的方法
       // 是以這裡需要把處理器放入一個集合中，後續統一執行父類的方法
      registryProcessors.addAll(currentRegistryProcessors);
      /**
       * 在這裡典型的BeanDefinitionRegistryPostProcessor就是
       * ConfigurationClassPostProcessor
       * 用于進行bean定義的加載 比如我們的包掃描，@import 等等
       */
       // Spring熱插播的展現，像ConfigurationClassPostProcessor就相當于一個元件
       // Spring很多事情就是交給元件去管理，如果不想用這個元件，直接去掉注冊元件就行
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      // 調用完之後，馬上clear掉，臨時變量需要清除
      // list.clear()隻清除對象的引用使其變為垃圾，與list = null 集合也會置空
      currentRegistryProcessors.clear();

      // 接下來，去容器中擷取BeanDefinitionRegistryPostProcessor的bean的處理器名稱
      postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
      // 循環上一步擷取的BeanDefinitionRegistryPostProcessor的類型名稱
      for (String ppName : postProcessorNames) {
         // 沒有被處理過,且實作了Ordered接口的
         if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
            // 顯示的調用getBean()的方式擷取出該對象然後加入到currentRegistryProcessors集合中去
            currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
            // 同時也加入到processedBeans集合中去
            processedBeans.add(ppName);
         }
      }
      // 對currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor進行排序
      sortPostProcessors(currentRegistryProcessors, beanFactory);
      // 把他加入到用于儲存到registryProcessors中
      registryProcessors.addAll(currentRegistryProcessors);
      // 調用他的後置處理方法
      invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
      // 調用完之後，馬上clear掉
      currentRegistryProcessors.clear();

      // 調用沒有實作任何優先級接口的BeanDefinitionRegistryPostProcessor
      // 定義一個重複處理的開關變量 預設值為true
      // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
      boolean reiterate = true;
      // 第一次就可以進來
      while (reiterate) {
         // 進入循環馬上把開關變量給改為fasle
         reiterate = false;
         // 去容器中擷取BeanDefinitionRegistryPostProcessor的bean的處理器名稱
         // 根據類型查 beanName 一般情況下隻會擷取到一個
org.springframework.context.annotation.internalConfigurationAnnotationProcessor，
          也就是 ConfigurationAnnotationProcessor
         postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
         // 循環上一步擷取的BeanDefinitionRegistryPostProcessor的類型名稱
         for (String ppName : postProcessorNames) {
            // 沒有被處理過的
            if (!processedBeans.contains(ppName)) {
               // 顯示的調用getBean()的方式擷取出該對象然後加入到currentRegistryProcessors集合中去
               currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
               // 同時也加入到processedBeans集合中去
               processedBeans.add(ppName);
               // 再次設定為true
               reiterate = true;
            }
         }
         // 對currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor進行排序
         sortPostProcessors(currentRegistryProcessors, beanFactory);
         // 把他加入到用于儲存到registryProcessors中
         registryProcessors.addAll(currentRegistryProcessors);
         // 調用他的後置處理方法
         invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
         // 調用完之後，馬上clear掉
         currentRegistryProcessors.clear();
      }

      // 調用實作了BeanDefinitionRegistryPostProcessor的接口 他是他也同時實作了BeanFactoryPostProcessor的方法
      invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
      // 調用BeanFactoryPostProcessor成品的不是通過getBean的
      invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
   }

   else {
      // 若目前的beanFactory沒有實作了BeanDefinitionRegistry 直接調用
      // 直接調用 beanFactoryPostProcessor 接口的方法進行後置處理
      invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
   }

   // 擷取容器中所有的 BeanFactoryPostProcessor
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // 儲存BeanFactoryPostProcessor類型實作了priorityOrdered
   List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
   // 儲存BeanFactoryPostProcessor類型實作了Ordered接口的
   List<String> orderedPostProcessorNames = new ArrayList<>();
   // 儲存BeanFactoryPostProcessor沒有實作任何優先級接口的
   List<String> nonOrderedPostProcessorNames = new ArrayList<>();
   for (String ppName : postProcessorNames) {
      // processedBeans包含的話，表示在上面處理BeanDefinitionRegistryPostProcessor的時候處理過了
      if (processedBeans.contains(ppName)) {
         // skip - already processed in first phase above
      }
      // 判斷是否實作了PriorityOrdered
      else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
      }
      // 判斷是否實作了Ordered
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      // 沒有實作任何的優先級接口的
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // 首先，先調用BeanFactoryPostProcessor實作了 PriorityOrdered接口的
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // 再調用BeanFactoryPostProcessor實作了 Ordered.
   List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
   for (String postProcessorName : orderedPostProcessorNames) {
      orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

   // 最後調用沒有實作任何方法接口的
   List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
   for (String postProcessorName : nonOrderedPostProcessorNames) {
      nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
   }
   invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

   // Clear cached merged bean definitions since the post-processors might have
   // modified the original metadata, e.g. replacing placeholders in values...
   beanFactory.clearMetadataCache();
}

總結：

首先，之前已經了解過 BeanDefinition 的兩個擴充點 postProcessBeanFactory 和 postProcessBeanDefinitionRegistry。前者是可以修改 BeanDefinition，重寫方法，後者可以多添加 BeanDefinition

1、定義了一個 Set，
processedBeans
裝載BeanName，後面會根據此 Set 來判斷後置處理器是否被執行過

2、判斷目前的 beanFactory 有沒有實作 BeanDefinitionRegistry，當然是肯定的，定義了兩個 List 一個是 regularPostProcessors，用來裝載 BeanFactoryPostProcessor。它隻有一個實作方法
postProcessBeanFactory() 。一個是 registryProcessors，用來裝載 BeanDefinitionRegistryPostProcessor。因為它繼承了 BeanFactoryPostProcessor 它不僅有 postProcessBeanFactory() 還有 postProcessBeanDefinitionRegistry()
。

3、循環傳進來的
beanFactoryPostProcessors ，一般情況下都是空的，除非自己 add 了 beanFactory 的後置處理器。假設有資料，先判斷是否是 BeanDefinitionRegistryPostProcessor 如果是調用 postProcessBeanDefinitionRegistry() 方法，并添加到集合 registryProcessors 中，否的話直接加入到集合 regularPostProcessors。（ postProcessBeanFactory()
會在後面執行，先存起來）

4、定義一個集合(List 臨時變量)
currentRegistryProcessors
使用者儲存目前準備建立的 BeanDefinitionRegistryPostProcessor

5、去容器中擷取BeanDefinitionRegistryPostProcessor的bean的處理器名稱
internalConfigurationAnnotationProcessor 即 ConfigurationAnnotationProcessor 一般情況都隻會擷取到一個。此時Spring還未掃描完成，掃描是在ConfigurationClassPostProcessor類完成的，就是下面的第一個 invokeBeanDefinitionRegistryPostProcessors()
方法

6、循環 postProcessorNames
internalConfigurationAnnotationProcessor
判斷是否實作了 PriorityOrdered，實作了添加到currentRegistryProcessors和processedBeans表示它們被處理過了（下一步才處理）

7、對 currentRegistryProcessors 集合中BeanDefinitionRegistryPostProcessor 進行排序

8、将
currentRegistryProcessors 集合加到 registryProcessors 集合中，因為 registryProcessors 是裝載 BeanDefinitionRegistryPostProcessor ，一開始的時候，spring隻會執行 BeanDefinitionRegistryPostProcessor 獨有的方法 postProcessBeanDefinitionRegistry() 。而不會執行 BeanDefinitionRegistryPostProcessor 父類的方法，即 BeanFactoryProcessor 的方法 postProcessBeanFactory()
。所有在此統一放到一起等待後續執行

9、
internalConfigurationAnnotationProcessor(currentRegistryProcessors, registry) ，執行 currentRegistryProcessors 中的 ConfigurationClassPostProcessor 中的 postProcessBeanDefinitionRegistry() 方法，這裡展現了 Spring 中熱插拔，插件化開發的思想，如果不想用這個，不添加就行了。從下圖可以看到，執行完該方法後 bean定義被加載到了BeanDefinitionMap中

IOC容器加載過程及Bean的生命周期和後置處理器
10、清空 currentRegistryProcessors
，用完了就需要清空，給後面的其他的重複使用

11、最後會重複上面的邏輯，調用順序如下：

實作了PriorityOrdered接口的

實作了Ordered接口的

沒有實作任何的優先級接口的

如果實作了多個的話，将在最先實作的地方調用，第二次将會判斷是否已經處理過

再來看一下

postProcessBeanFactory()

方法，它調用了一個會解析我們BeanDefinition的方法

processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
    int factoryId = System.identityHashCode(beanFactory);
    if (this.factoriesPostProcessed.contains(factoryId)) {
        throw new IllegalStateException(
            "postProcessBeanFactory already called on this post-processor against " + beanFactory);
    }
    this.factoriesPostProcessed.add(factoryId);
    if (!this.registriesPostProcessed.contains(factoryId)) {
        // BeanDefinitionRegistryPostProcessor hook apparently not supported...
        // Simply call processConfigurationClasses lazily at this point then.
        processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
    }
    // 為屬性為full的Bean定義做CGLIB增強
    enhanceConfigurationClasses(beanFactory);
    beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

這個方法中會引申出一個知識點

注冊配置類把傳入的類進行注冊，分為兩種情況

a. @Configuration 的配置類

b. 傳入普通 Bean (基本不會這麼做)

Spring 把配置類分為兩種

a. 帶 @Configuration 注解的配置類稱之為 FULL 配置類

b. 不帶 @Configuration 注解，而是帶有 @Component，@Import，@ImportResouce， @Service， @ComponentScan 等注解的配置類稱之為 Lite 配置類

如果我們注冊了Full 配置類，我們 getBean 這個配置類，會發現它已經不是原本那個配置類了，而是已經被 CGLIB 代理的類

例如：寫一個A類，其中有一個構造方法，列印出“HelloSpring”，再寫一個配置類，裡面有兩個帶 @Bean 的方法。假設其中一個方法
getA() 它 new A() ，并且傳回A的對象。第二個方法又調用了 getA() 。如果配置類是 Lite 配置類，會發現列印了兩次“HelloSpring”，即 A 類被 new 了兩次。如果配置類是 FULL 配置類，會發現隻列印一次，因為這個類被 CGLIB 代理了。

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
        List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
        // 擷取IOC 容器中目前所有bean定義的名稱
        String[] candidateNames = registry.getBeanDefinitionNames();

        // 循環上一步擷取的所有的Bean定義資訊
        for (String beanName : candidateNames) {
            // 通過Bean的名稱來擷取我們的bean定義對象
            BeanDefinition beanDef = registry.getBeanDefinition(beanName);
            // 判斷是否有沒有解析過
            if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
                }
            }
            // 進行正在的解析判斷是不是完全的配置類 還是一個非正式的配置類
            else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
                // 滿足添加就加入到候選的配置類集合中
                configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
            }
        }

        // Return immediately if no @Configuration classes were found
        // 若沒有找到配置類直接傳回
        if (configCandidates.isEmpty()) {
            return;
        }

        // Sort by previously determined @Order value, if applicable
        // 對配置類進行Order排序
        configCandidates.sort((bd1, bd2) -> {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return Integer.compare(i1, i2);
        });

        // Detect any custom bean name generation strategy supplied through the enclosing application context
        // 建立我們通過@CompentScan導入進來的bean name的生成器
        // 建立我們通過@Import導入進來的bean的名稱
        SingletonBeanRegistry sbr = null;
        if (registry instanceof SingletonBeanRegistry) {
            sbr = (SingletonBeanRegistry) registry;
            if (!this.localBeanNameGeneratorSet) {
                BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
                        AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
                if (generator != null) {
                    // 設定@CompentScan導入進來的bean的名稱生成器
                    this.componentScanBeanNameGenerator = generator;
                    // 設定@Import導入進來的bean的名稱生成器
                    this.importBeanNameGenerator = generator;
                }
            }
        }

        if (this.environment == null) {
            this.environment = new StandardEnvironment();
        }

        // 建立一個配置類解析器對象
        // Parse each @Configuration class
        ConfigurationClassParser parser = new ConfigurationClassParser(
                this.metadataReaderFactory, this.problemReporter, this.environment,
                this.resourceLoader, this.componentScanBeanNameGenerator, registry);
        // 建立一個集合用于儲存我們的配置類BeanDefinitionHolder集合預設長度是配置類集合的長度
        Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
        // 建立一個集合用于儲存我們的已經解析的配置類，長度預設為解析出來預設的配置類的集合長度
        Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
        //do while 會進行第一次解析
        do {
            // 解析配置類
            // 經過這一步，會将@ComponentScans、@ComponentScan、@Bean、@Import等注解要注冊的類掃描出來
            parser.parse(candidates);
            parser.validate();
            // 解析出來的配置類
            Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
            configClasses.removeAll(alreadyParsed);

            // Read the model and create bean definitions based on its content
            if (this.reader == null) {
                this.reader = new ConfigurationClassBeanDefinitionReader(
                        registry, this.sourceExtractor, this.resourceLoader, this.environment,
                        this.importBeanNameGenerator, parser.getImportRegistry());
            }
            // 把解析出來的配置類注冊到容器中
            // 經過這一步會将@Bean、@import 注冊的類變成BeanDefinition
            this.reader.loadBeanDefinitions(configClasses);
            // 加入到已經解析的集合中
            alreadyParsed.addAll(configClasses);

            candidates.clear();
            //判斷我們IOC容器中的是不是>候選原始的bean定義的個數
            if (registry.getBeanDefinitionCount() > candidateNames.length) {
                // 擷取所有的bean定義
                String[] newCandidateNames = registry.getBeanDefinitionNames();
                // 原始的老的候選的bean定義
                Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
                Set<String> alreadyParsedClasses = new HashSet<>();
                // 指派已經解析的
                for (ConfigurationClass configurationClass : alreadyParsed) {
                    alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
                }
                for (String candidateName : newCandidateNames) {
                    // 表示目前循環的還沒有被解析過
                    if (!oldCandidateNames.contains(candidateName)) {
                        BeanDefinition bd = registry.getBeanDefinition(candidateName);
                        // 判斷有沒有被解析過
                        // checkConfigurationClassCandidate 此時為Bean定義辨別為full或lite,在後面根據屬性潘森是否需要用CGLIB增強
                        if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
                                !alreadyParsedClasses.contains(bd.getBeanClassName())) {
                            candidates.add(new BeanDefinitionHolder(bd, candidateName));
                        }
                    }
                }
                candidateNames = newCandidateNames;
            }
        }
        // 存在沒有解析過的 需要循環解析
        while (!candidates.isEmpty());

        // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
        if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }

        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // Clear cache in externally provided MetadataReaderFactory; this is a no-op
            // for a shared cache since it'll be cleared by the ApplicationContext.
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }
    }

至此自定義的配置類都加載到了beanDefinitonMap 中，但仍未初始化

此處會執行個體化以下幾個内置 Bean

6.3 registerBeanPostProcessors(beanFactory);

執行個體化和注冊 beanFactory 中擴充了 BeanPostProcessor 的bean。

例如：

AutowiredAnnotationBeanPostProcessor(處理被@Autowired注解修飾的bean并注入)

RequiredAnnotationBeanPostProcessor(處理被@Required注解修飾的方法)

CommonAnnotationBeanPostProcessor(處理@PreDestroy、@PostConstruct、@Resource等多個注解的作用)等。

此處會執行個體化以下幾個内置 Bean

6.4 initApplicationEventMulticaster(); 和 registerListeners();

建立事件多點傳播器

注冊監聽器，廣播early application events

後續監聽機制再來看這兩個

6.5 finishBeanFactoryInitialization(beanFactory);

執行個體化非懶加載單例 Bean ，也就是我們的 Bean 都是在這裡被建立出來的。包括（執行個體化、填充屬性、初始化）

裡面會有一個方法

preInstantiateSingletons()

是一個接口方法，這個方法隻有一個實作類

DefaultListableBeanFactory

，裡面最重要的就是

getBean();

。這中間還會去判斷是否是一個特殊的Bean(即：FactoryBean)一旦一個類實作了 FactoryBean 并從寫了getObject() 方法那麼，IOC容器拿到的執行個體就是調用getObject方法得到的特殊的執行個體，沒有實作這個接口時注冊到IOC容器中的就是一個普通的Bean，當實作後，IOC容器會調用getObject方法傳回的執行個體（工廠模式）

// 初始化所有的非懶加載單例Bean
beanFactory.preInstantiateSingletons();
// 執行 getBean流程
getBean(beanName);
複制代碼

裡面調用的是 AbstractBeanFactory.java 裡面的getBean();

@Override
public Object getBean(String name) throws BeansException {
   return doGetBean(name, null, null, false);
}

doGetBean 方法太多了，這裡挑出主要建立單例bean 的邏輯

// 建立單例bean
if (mbd.isSingleton()) {
    // 把beanName 和一個 singletonFactory 并且傳入一個回調對象用于回調
    sharedInstance = getSingleton(beanName, () -> {
        try {
            // 進入建立bean的邏輯
            return createBean(beanName, mbd, args);
        }
        catch (BeansException ex) {
            // 建立bean的過程中發生異常,需要銷毀關于目前bean的所有資訊
            destroySingleton(beanName);
            throw ex;
        }
    });
    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

這裡的

creatBean()

又是一個接口方法，但也僅僅隻有一個類對其做了實作

AbstractAutowireCapableBeanFactory

。該方法前面也會進行一大堆的判斷，我們再次挑出關鍵步驟

// 真正的開始建立Bean執行個體對象
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
   logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;

點進方法

doCreateBean(beanName, mbdToUse, args);

發現也在該類下面，裡面又做了一大堆的事情，我們主要調出機構關鍵點

建立執行個體

// 使用合适的執行個體化政策來建立新的執行個體：工廠方法、構造函數自動注入、簡單初始化 
instanceWrapper = createBeanInstance(beanName, mbd, args);

填充屬性及初始化

// 給我們的屬性進行指派(調用set方法進行指派)
populateBean(beanName, mbd, instanceWrapper);
// 進行對象初始化操作(在這裡可能生成代理對象)
exposedObject = initializeBean(beanName, exposedObject, mbd);

在

initializeBean(beanName, exposedObject, mbd);

中，又調用了

invokeInitMethods(beanName, wrappedBean, mbd);

和

invokeAwareMethods(beanName, bean);

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
         invokeAwareMethods(beanName, bean);
         return null;
      }, getAccessControlContext());
   }
   else {
      // 若我們的bean實作了XXXAware接口進行方法的回調
      invokeAwareMethods(beanName, bean);
   }

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      // 調用我們的bean的後置處理器的postProcessorsBeforeInitialization方法  @PostCust注解的方法
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

   try {
      // 調用初始化方法
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      // 調用我們bean的後置處理器的PostProcessorsAfterInitialization方法
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      // 此bean實作了BeanNameAware
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      // 實作了BeanClassLoaderAware接口
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      // 實作了BeanFactoryAware
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

至此剩餘的Bean也全部初始化完成至 IOC 容器中

驗證Spring Bean 的生命周期

定義一個SpringBean

@ComponentScan
public  class SpringBean
        implements InitializingBean, DisposableBean, BeanNameAware, BeanFactoryAware, BeanClassLoaderAware {

    // 就是一個普通的被@Component标注的類
    @Autowired
    AutoBean autoBean;

    public SpringBean() {
        System.out.println("SpringBean Constructor Method:" + autoBean);
        System.out.println("SpringBean()");
    }

    @Override
    public void setBeanClassLoader(ClassLoader classLoader) {
        System.out.println("ClassLoader");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory");
    }

    @Override
    public void setBeanName(String name) {
        System.out.println("setBeanName:" + autoBean);
        System.out.println("setBeanName");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("destroy");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");
    }

    public void initMethod() {
        System.out.println("initMethod");
    }

    public void destroyMethod() {
        System.out.println("destroyMethod");
    }
}

再定義一個BeanPostProcessor，在重寫的兩個方法中進行了判斷，如果傳進來的 beanName 是 springBean 才進行列印

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

   @Override
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      if(beanName.equals("springBean")) {
         System.out.println("postProcessBeforeInitialization");
      }
      return bean;
   }

   @Override
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      if(beanName.equals("springBean")) {
         System.out.println("postProcessAfterInitialization");
      }
      return bean;
   }
}

定義一個配置類，完成自動掃描，但是SpringBean是手動注冊的，并且聲明了initMethod和destroyMethod：

@Configuration
@ComponentScan
public class MainConfig {
   @Bean(initMethod = "initMethod",destroyMethod = "destroyMethod")
   public SpringBean springBean() {
      return new SpringBean();
   }
}

然後是啟動類：

public class Main {
   public static void main(String[] args) throws Exception {
       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MainConfig.class);
       // Spring 的 destroy() 方法已過時會報錯，推薦使用 registerShutdownHook() 優雅的關閉 IOC
       // context.registerShutdownHook() 是一個鈎子方法，當jvm關閉退出的時候會調用這個鈎子方法
       // 當然 context.close() 也可以銷毀容器
       context.registerShutdownHook();
   }
}

運作結果：

① 執行個體化Bean對象，這個時候 Bean 的對象是非常低級的，基本不能夠被我們使用，因為連最基本的屬性都沒有設定，可以了解為連Autowired注解都是沒有解析的
② 填充屬性，當做完這一步，Bean對象基本是完整的了，可以了解為Autowired注解已經解析完畢，依賴注入完成了
③ 如果Bean實作了BeanNameAware接口，則調用setBeanName方法
④ 如果Bean實作了BeanClassLoaderAware接口，則調用setBeanClassLoader方法
⑤ 如果Bean實作了BeanFactoryAware接口，則調用setBeanFactory方法
⑥ 調用BeanPostProcessor的postProcessBeforeInitialization方法
⑦ 如果Bean實作了InitializingBean接口，調用afterPropertiesSet方法
⑧ 如果Bean定義了init-method方法，則調用Bean的init-method方法
⑨ 調用BeanPostProcessor的postProcessAfterInitialization方法。當進行到這一步，Bean已經被準備就緒了，一直停留在應用的上下文中，直到被銷毀
⑩ 如果應用的上下文被銷毀了，如果Bean實作了DisposableBean接口，則調用destroy方法，如果Bean定義了destory-method聲明了銷毀方法也會被調用

IOC容器加載過程及Bean的生命周期和後置處理器

SpringIOC 容器加載過程

第一步：執行個體化化容器：AnnotationConfigApplicationContext

第二步：執行個體化工廠：DefaultListableBeanFactory

第三步：執行個體化 BeanDefinition 讀取器 (AnnotatedBeanDefinitionReader)

第四步：建立 BeanDefinition 掃描器 (ClassPathBeanDefinitionScanner)

第五步：注冊配置類為BeanDefinition (register(annotatedClasses);)

第六步：refresh();

6.1 prepareBeanFactory(beanFactory)

6.2 invokeBeanFactoryPostProcessors(beanFactory)

6.3 registerBeanPostProcessors(beanFactory);

6.4 initApplicationEventMulticaster(); 和 registerListeners();

6.5 finishBeanFactoryInitialization(beanFactory);

驗證Spring Bean 的生命周期

思考

繼續閱讀

MyBatis-Plus 之AR模式

馴服爛代碼_馴服Tomcat：Tomcat 5的過濾技巧

基于Springboot+VUE+Mysql的大學生校園疫情防控管理系統

Using MessageConverter

馴服爛代碼_C＃中的馴服配置

Spring Cloud整合Sleuth，當請求完成後，Zipkin沒有鍊路資訊

JAVA自學之路——馬士兵

Rabbitmq指令行手動建立隊列

整合 Spring 開發架構及服務端技術

SSM整合02---Spring-SpringMVC層一、添加web架構支援二、web.xml三、spring-mvc.xml

SSM架構（二）------------表現層的SpringMVC

Intellij idea基于Maven 的SSM 架構整合

Spring資料和Redis

SpringMVC的啟動過程源碼分析1 SpringMVC 配置XML的方式啟動2 SpringMVC純注解模式啟動

Java Spring 架構

SpringCloud微服務（四）之ribbon筆記ribbon是什麼？入門案例自定義均衡負載算法