日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

RELATEED CONSULTING
相關(guān)咨詢
選擇下列產(chǎn)品馬上在線溝通
服務(wù)時間：8:30-17:00
你可能遇到了下面的問題
關(guān)閉右側(cè)工具欄

新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案
肝疼了3萬字的Spring容器啟動流程

 Spring Framework 是 Java 語言中影響最為深遠(yuǎn)的框架之一，其中的 IOC 和 AOP 兩個經(jīng)典思想更是一直被程序員津津樂道，后面推出的 Spring Boot、Spring Cloud 系列也是在其基礎(chǔ)之上開發(fā)，要想搞明白 Spring 全家桶系列，必須腳踏實地的從 Spring Framework 學(xué)習(xí)起。

創(chuàng)新互聯(lián)公司是一家集網(wǎng)站建設(shè),錦江企業(yè)網(wǎng)站建設(shè),錦江品牌網(wǎng)站建設(shè),網(wǎng)站定制,錦江網(wǎng)站建設(shè)報價,網(wǎng)絡(luò)營銷,網(wǎng)絡(luò)優(yōu)化,錦江網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè)，幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強(qiáng)企業(yè)競爭力。可充分滿足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時我們時刻保持專業(yè)、時尚、前沿，時刻以成就客戶成長自我，堅持不斷學(xué)習(xí)、思考、沉淀、凈化自己，讓我們?yōu)楦嗟钠髽I(yè)打造出實用型網(wǎng)站。

這是我 Spring Framework 源碼解析系列的第一篇，主要是從代碼層面對 Spring 框架的啟動做一個完整解析，這里的思想都是筆者根據(jù)自己使用 Spring 的經(jīng)驗和對 Spring 的了解綜合而成，以下內(nèi)容謹(jǐn)代表個人看法，若有疑問請不吝賜教。

另外提醒一下，本篇文章是基于 5.1.6.RELEASE 版本的代碼進(jìn)行分析，入口代碼也是采用官方推薦的 java-config 技術(shù)，而非 xml。

源碼解析

考慮到直接看源碼是一個非?？菰餆o味的過程，而且 Spring 的代碼設(shè)計非常優(yōu)秀規(guī)范，這會導(dǎo)致在翻開源碼時，類與類之間的跳躍會非常頻繁，不熟悉的同學(xué)可能直接暈菜，所以每一個重要流程前我都會先準(zhǔn)備一個流程圖，建議大家先通過流程圖了解一下整體步驟，然后再對代碼硬擼，這樣能夠降低不少難度。

相信每一個使用過 Spring 技術(shù)的同學(xué)都知道 Spring 在初始化過程中有一個非常重要的步驟，即 Spring 容器的刷新，這個步驟固然重要，但是刷新前的初始化流程也非常重要。

本篇文章將整個啟動過程分為了兩個部分，即容器的初始化與刷新，下面正式開始。

初始化流程

流程分析

因為是基于 java-config 技術(shù)分析源碼，所以這里的入口是 AnnotationConfigApplicationContext ，如果是使用 xml 分析，那么入口即為 ClassPathXmlApplicationContext ，它們倆的共同特征便是都繼承了 AbstractApplicationContext 類，而大名鼎鼎的 refresh 方法便是在這個類中定義的，現(xiàn)在就不劇透了，我們接著分析 AnnotationConfigApplicationContext 類，可以繪制成如下流程圖：

 看完流程圖，我們應(yīng)該思考一下：如果讓你去設(shè)計一個 IOC 容器，你會怎么做?首先我肯定會提供一個入口(AnnotationConfigApplicationContext )給用戶使用，然后需要去初始化一系列的工具組件：

①：如果我想生成 bean 對象，那么就需要一個 beanFactory 工廠(DefaultListableBeanFactory);

②：如果我想對加了特定注解(如 @Service、@Repository)的類進(jìn)行讀取轉(zhuǎn)化成 BeanDefinition 對象(BeanDefinition 是 Spring 中極其重要的一個概念，它存儲了 bean 對象的所有特征信息，如是否單例，是否懶加載，factoryBeanName 等)，那么就需要一個注解配置讀取器(AnnotatedBeanDefinitionReader);

③：如果我想對用戶指定的包目錄進(jìn)行掃描查找 bean 對象，那么還需要一個路徑掃描器(ClassPathBeanDefinitionScanner)。

通過上面的思考，是不是上面的圖理解起來就輕而易舉呢?

ps：圖中的黃色備注可以不看，只是在這里明確展示出來 Spring 的部分內(nèi)置組件是何時何地添加到容器中的，關(guān)于組件的作用在后面的系列文章中會詳細(xì)分析。

核心代碼剖析

考慮到要是對所有代碼都進(jìn)行解析，那么文章篇幅會過長，因此這里只對核心內(nèi)容進(jìn)行源碼層面的分析，凡是圖中標(biāo)注了 ①、②、③等字樣的步驟，都可以理解為是一個比較重要的步驟，下面開始進(jìn)行詳細(xì)分析。

org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

根據(jù)上圖分析，代碼運行到這里時候，Spring 容器已經(jīng)構(gòu)造完畢，那么就可以為容器添加一些內(nèi)置組件了，其中最主要的組件便是 ConfigurationClassPostProcessor 和 AutowiredAnnotationBeanPostProcessor ，前者是一個 beanFactory 后置處理器，用來完成 bean 的掃描與注入工作，后者是一個 bean 后置處理器，用來完成 @AutoWired 自動注入。

 
 
 
 
    
  
  
  
  
  1. public static Set registerAnnotationConfigProcessors( 
    2. 
  
  
  
  
  2.   BeanDefinitionRegistry registry, @Nullable Object source) { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); 
    5. 
  
  
  
  
  5.  if (beanFactory != null) { 
    6. 
  
  
  
  
  6.   if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { 
    7. 
  
  
  
  
  7.    beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); 
    8. 
  
  
  
  
  8.   } 
    9. 
  
  
  
  
  9.   if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { 
    10. 
  
  
  
  
  10.    beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); 
    11. 
  
  
  
  
  11.   } 
    12. 
  
  
  
  
  12.  } 
    13. 
  
  
  
  
  13.  
    14. 
  
  
  
  
  14.  Set beanDefs = new LinkedHashSet<>(8); 
    15. 
  
  
  
  
  15.  // 向 beanDefinitionMap 中注冊【BeanFactoryPostProcessor】：【ConfigurationClassPostProcessor】 
    16. 
  
  
  
  
  16.  if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    17. 
  
  
  
  
  17.   RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class); 
    18. 
  
  
  
  
  18.   def.setSource(source); 
    19. 
  
  
  
  
  19.   beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)); 
    20. 
  
  
  
  
  20.  } 
    21. 
  
  
  
  
  21.  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【AutowiredAnnotationBeanPostProcessor】 
    22. 
  
  
  
  
  22.  if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    23. 
  
  
  
  
  23.   RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); 
    24. 
  
  
  
  
  24.   def.setSource(source); 
    25. 
  
  
  
  
  25.   beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); 
    26. 
  
  
  
  
  26.  } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.  // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor. 
    29. 
  
  
  
  
  29.  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【CommonAnnotationBeanPostProcessor】 
    30. 
  
  
  
  
  30.  if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    31. 
  
  
  
  
  31.   RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); 
    32. 
  
  
  
  
  32.   def.setSource(source); 
    33. 
  
  
  
  
  33.   beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); 
    34. 
  
  
  
  
  34.  } 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.  // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor. 
    37. 
  
  
  
  
  37.  // 向 beanDefinitionMap 中注冊【BeanPostProcessor】：【PersistenceAnnotationBeanPostProcessor】，前提條件是在 jpa 環(huán)境下 
    38. 
  
  
  
  
  38.  if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
    39. 
  
  
  
  
  39.   RootBeanDefinition def = new RootBeanDefinition(); 
    40. 
  
  
  
  
  40.   try { 
    41. 
  
  
  
  
  41.    def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, 
    42. 
  
  
  
  
  42.      AnnotationConfigUtils.class.getClassLoader())); 
    43. 
  
  
  
  
  43.   } 
    44. 
  
  
  
  
  44.   catch (ClassNotFoundException ex) { 
    45. 
  
  
  
  
  45.    throw new IllegalStateException( 
    46. 
  
  
  
  
  46.      "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex); 
    47. 
  
  
  
  
  47.   } 
    48. 
  
  
  
  
  48.   def.setSource(source); 
    49. 
  
  
  
  
  49.   beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)); 
    50. 
  
  
  
  
  50.  } 
    51. 
  
  
  
  
  51.  // 向 beanDefinitionMap 中注冊【BeanFactoryPostProcessor】：【EventListenerMethodProcessor】 
    52. 
  
  
  
  
  52.  if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { 
    53. 
  
  
  
  
  53.   RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); 
    54. 
  
  
  
  
  54.   def.setSource(source); 
    55. 
  
  
  
  
  55.   beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME)); 
    56. 
  
  
  
  
  56.  } 
    57. 
  
  
  
  
  57.  // 向 beanDefinitionMap 中注冊組件：【DefaultEventListenerFactory】 
    58. 
  
  
  
  
  58.  if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { 
    59. 
  
  
  
  
  59.   RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); 
    60. 
  
  
  
  
  60.   def.setSource(source); 
    61. 
  
  
  
  
  61.   beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)); 
    62. 
  
  
  
  
  62.  } 
    63. 
  
  
  
  
  63.  
    64. 
  
  
  
  
  64.  return beanDefs; 
    65. 
  
  
  
  
  65. } 
    66.

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean

這個步驟主要是用來解析用戶傳入的 Spring 配置類，其實也是解析成一個 BeanDefinition 然后注冊到容器中，沒有什么好說的。

 
 
 
 
    
  
  
  
  
  1.  void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name, 
    2. 
  
  
  
  
  2.   @Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { 
    3. 
  
  
  
  
  3.  // 解析傳入的配置類，實際上這個方法既可以解析配置類，也可以解析 Spring bean 對象 
    4. 
  
  
  
  
  4.  AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); 
    5. 
  
  
  
  
  5.  // 判斷是否需要跳過，判斷依據(jù)是此類上有沒有 @Conditional 注解 
    6. 
  
  
  
  
  6.  if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { 
    7. 
  
  
  
  
  7.   return; 
    8. 
  
  
  
  
  8.  } 
    9. 
  
  
  
  
  9.  
    10. 
  
  
  
  
  10.  abd.setInstanceSupplier(instanceSupplier); 
    11. 
  
  
  
  
  11.  ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); 
    12. 
  
  
  
  
  12.  abd.setScope(scopeMetadata.getScopeName()); 
    13. 
  
  
  
  
  13.  String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); 
    14. 
  
  
  
  
  14.  // 處理類上的通用注解 
    15. 
  
  
  
  
  15.  AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); 
    16. 
  
  
  
  
  16.  if (qualifiers != null) { 
    17. 
  
  
  
  
  17.   for (Class qualifier : qualifiers) { 
    18. 
  
  
  
  
  18.    if (Primary.class == qualifier) { 
    19. 
  
  
  
  
  19.     abd.setPrimary(true); 
    20. 
  
  
  
  
  20.    } 
    21. 
  
  
  
  
  21.    else if (Lazy.class == qualifier) { 
    22. 
  
  
  
  
  22.     abd.setLazyInit(true); 
    23. 
  
  
  
  
  23.    } 
    24. 
  
  
  
  
  24.    else { 
    25. 
  
  
  
  
  25.     abd.addQualifier(new AutowireCandidateQualifier(qualifier)); 
    26. 
  
  
  
  
  26.    } 
    27. 
  
  
  
  
  27.   } 
    28. 
  
  
  
  
  28.  } 
    29. 
  
  
  
  
  29.  // 封裝成一個 BeanDefinitionHolder 
    30. 
  
  
  
  
  30.  for (BeanDefinitionCustomizer customizer : definitionCustomizers) { 
    31. 
  
  
  
  
  31.   customizer.customize(abd); 
    32. 
  
  
  
  
  32.  } 
    33. 
  
  
  
  
  33.  BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); 
    34. 
  
  
  
  
  34.  // 處理 scopedProxyMode 
    35. 
  
  
  
  
  35.  definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); 
    36. 
  
  
  
  
  36.  
    37. 
  
  
  
  
  37.  // 把 BeanDefinitionHolder 注冊到 registry 
    38. 
  
  
  
  
  38.  BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); 
    39. 
  
  
  
  
  39. } 
    40.

刷新流程

流程分析

下面這一段代碼則是 Spring 中最為重要的一個步驟：容器刷新，同樣先看圖再分析。

 看完流程圖，我們也先思考一下：在 3.1 中我們知道了如何去初始化一個 IOC 容器，那么接下來就是讓這個 IOC 容器真正起作用的時候了：即先掃描出要放入容器的 bean，將其包裝成 BeanDefinition 對象，然后通過反射創(chuàng)建 bean，并完成賦值操作，這個就是 IOC 容器最簡單的功能了。

但是看完上圖，明顯 Spring 的初始化過程比這個多的多，下面我們就詳細(xì)分析一下這樣設(shè)計的意圖：

如果用戶想在掃描完 bean 之后做一些自定義的操作：假設(shè)容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d，這種騷操作 Spring 也是支持的，得益于它提供的 BeanFactoryPostProcessor 后置處理器，對應(yīng)的是上圖中的 invokeBeanFactoryPostProcessors 操作。

如果用戶還想在 bean 的初始化前后做一些操作呢?比如生成代理對象，修改對象屬性等，Spring 為我們提供了 BeanPostProcessor 后置處理器，實際上 Spring 容器中的大多數(shù)功能都是通過 Bean 后置處理器完成的，Spring 也是給我們提供了添加入口，對應(yīng)的是上圖中的 registerBeanPostProcessors 操作。

整個容器創(chuàng)建過程中，如果用戶想監(jiān)聽容器啟動、刷新等事件，根據(jù)這些事件做一些自定義的操作呢?Spring 也早已為我們考慮到了，提供了添加監(jiān)聽器接口和容器事件通知接口，對應(yīng)的是上圖中的 registerListeners 操作。

此時再看上圖，是不是就覺得簡單很多呢，下面就一些重要代碼進(jìn)行分析。

核心代碼剖析

org.springframework.context.support.AbstractApplicationContext#refresh

這個方法是對上圖中的具體代碼實現(xiàn)，可劃分為12個步驟，其中比較重要的步驟下面會有詳細(xì)說明。

在這里，我們需要記?。篠pring 中的每一個容器都會調(diào)用 refresh 方法進(jìn)行刷新，無論是 Spring 的父子容器，還是 Spring Cloud Feign 中的 feign 隔離容器，每一個容器都會調(diào)用這個方法完成初始化。

 
 
 
 
    
  
  
  
  
  1. public void refresh() throws BeansException, IllegalStateException { 
    2. 
  
  
  
  
  2.  synchronized (this.startupShutdownMonitor) { 
    3. 
  
  
  
  
  3.   // Prepare this context for refreshing. 
    4. 
  
  
  
  
  4.   // 1. 刷新前的預(yù)處理 
    5. 
  
  
  
  
  5.   prepareRefresh(); 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.   // Tell the subclass to refresh the internal bean factory. 
    8. 
  
  
  
  
  8.   // 2. 獲取 beanFactory，即前面創(chuàng)建的【DefaultListableBeanFactory】 
    9. 
  
  
  
  
  9.   ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); 
    10. 
  
  
  
  
  10.  
    11. 
  
  
  
  
  11.   // Prepare the bean factory for use in this context. 
    12. 
  
  
  
  
  12.   // 3. 預(yù)處理 beanFactory，向容器中添加一些組件 
    13. 
  
  
  
  
  13.   prepareBeanFactory(beanFactory); 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.   try { 
    16. 
  
  
  
  
  16.    // Allows post-processing of the bean factory in context subclasses. 
    17. 
  
  
  
  
  17.    // 4. 子類通過重寫這個方法可以在 BeanFactory 創(chuàng)建并與準(zhǔn)備完成以后做進(jìn)一步的設(shè)置 
    18. 
  
  
  
  
  18.    postProcessBeanFactory(beanFactory); 
    19. 
  
  
  
  
  19.  
    20. 
  
  
  
  
  20.    // Invoke factory processors registered as beans in the context. 
    21. 
  
  
  
  
  21.    // 5. 執(zhí)行 BeanFactoryPostProcessor 方法，beanFactory 后置處理器 
    22. 
  
  
  
  
  22.    invokeBeanFactoryPostProcessors(beanFactory); 
    23. 
  
  
  
  
  23.  
    24. 
  
  
  
  
  24.    // Register bean processors that intercept bean creation. 
    25. 
  
  
  
  
  25.    // 6. 注冊 BeanPostProcessors，bean 后置處理器 
    26. 
  
  
  
  
  26.    registerBeanPostProcessors(beanFactory); 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.    // Initialize message source for this context. 
    29. 
  
  
  
  
  29.    // 7. 初始化 MessageSource 組件（做國際化功能；消息綁定，消息解析） 
    30. 
  
  
  
  
  30.    initMessageSource(); 
    31. 
  
  
  
  
  31.  
    32. 
  
  
  
  
  32.    // Initialize event multicaster for this context. 
    33. 
  
  
  
  
  33.    // 8. 初始化事件派發(fā)器，在注冊監(jiān)聽器時會用到 
    34. 
  
  
  
  
  34.    initApplicationEventMulticaster(); 
    35. 
  
  
  
  
  35.  
    36. 
  
  
  
  
  36.    // Initialize other special beans in specific context subclasses. 
    37. 
  
  
  
  
  37.    // 9. 留給子容器（子類），子類重寫這個方法，在容器刷新的時候可以自定義邏輯，web 場景下會使用 
    38. 
  
  
  
  
  38.    onRefresh(); 
    39. 
  
  
  
  
  39.  
    40. 
  
  
  
  
  40.    // Check for listener beans and register them. 
    41. 
  
  
  
  
  41.    // 10. 注冊監(jiān)聽器，派發(fā)之前步驟產(chǎn)生的一些事件（可能沒有） 
    42. 
  
  
  
  
  42.    registerListeners(); 
    43. 
  
  
  
  
  43.  
    44. 
  
  
  
  
  44.    // Instantiate all remaining (non-lazy-init) singletons. 
    45. 
  
  
  
  
  45.    // 11. 初始化所有的非單實例 bean 
    46. 
  
  
  
  
  46.    finishBeanFactoryInitialization(beanFactory); 
    47. 
  
  
  
  
  47.  
    48. 
  
  
  
  
  48.    // Last step: publish corresponding event. 
    49. 
  
  
  
  
  49.    // 12. 發(fā)布容器刷新完成事件 
    50. 
  
  
  
  
  50.    finishRefresh(); 
    51. 
  
  
  
  
  51.   } 
    52. 
  
  
  
  
  52.  
    53. 
  
  
  
  
  53.   ... 
    54. 
  
  
  
  
  54.    
    55. 
  
  
  
  
  55.  } 
    56. 
  
  
  
  
  56. } 
    57.

org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory

顧名思義，這個接口是為 beanFactory 工廠添加一些內(nèi)置組件，預(yù)處理過程。

 
 
 
 
    
  
  
  
  
  1. protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
    2. 
  
  
  
  
  2.  // Tell the internal bean factory to use the context's class loader etc. 
    3. 
  
  
  
  
  3.  // 設(shè)置 classLoader 
    4. 
  
  
  
  
  4.  beanFactory.setBeanClassLoader(getClassLoader()); 
    5. 
  
  
  
  
  5.  //設(shè)置 bean 表達(dá)式解析器 
    6. 
  
  
  
  
  6.  beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); 
    7. 
  
  
  
  
  7.  beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); 
    8. 
  
  
  
  
  8.  
    9. 
  
  
  
  
  9.  // Configure the bean factory with context callbacks. 
    10. 
  
  
  
  
  10.  // 添加一個 BeanPostProcessor【ApplicationContextAwareProcessor】 
    11. 
  
  
  
  
  11.  beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); 
    12. 
  
  
  
  
  12.  
    13. 
  
  
  
  
  13.  // 設(shè)置忽略自動裝配的接口，即不能通過注解自動注入 
    14. 
  
  
  
  
  14.  beanFactory.ignoreDependencyInterface(EnvironmentAware.class); 
    15. 
  
  
  
  
  15.  beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); 
    16. 
  
  
  
  
  16.  beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); 
    17. 
  
  
  
  
  17.  beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); 
    18. 
  
  
  
  
  18.  beanFactory.ignoreDependencyInterface(MessageSourceAware.class); 
    19. 
  
  
  
  
  19.  beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); 
    20. 
  
  
  
  
  20.  
    21. 
  
  
  
  
  21.  // BeanFactory interface not registered as resolvable type in a plain factory. 
    22. 
  
  
  
  
  22.  // MessageSource registered (and found for autowiring) as a bean. 
    23. 
  
  
  
  
  23.  // 注冊可以解析的自動裝配類，即可以在任意組件中通過注解自動注入 
    24. 
  
  
  
  
  24.  beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); 
    25. 
  
  
  
  
  25.  beanFactory.registerResolvableDependency(ResourceLoader.class, this); 
    26. 
  
  
  
  
  26.  beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); 
    27. 
  
  
  
  
  27.  beanFactory.registerResolvableDependency(ApplicationContext.class, this); 
    28. 
  
  
  
  
  28.  
    29. 
  
  
  
  
  29.  // Register early post-processor for detecting inner beans as ApplicationListeners. 
    30. 
  
  
  
  
  30.  // 添加一個 BeanPostProcessor【ApplicationListenerDetector】 
    31. 
  
  
  
  
  31.  beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); 
    32. 
  
  
  
  
  32.  
    33. 
  
  
  
  
  33.  // Detect a LoadTimeWeaver and prepare for weaving, if found. 
    34. 
  
  
  
  
  34.  // 添加編譯時的 AspectJ 
    35. 
  
  
  
  
  35.  if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
    36. 
  
  
  
  
  36.   beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); 
    37. 
  
  
  
  
  37.   // Set a temporary ClassLoader for type matching. 
    38. 
  
  
  
  
  38.   beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); 
    39. 
  
  
  
  
  39.  } 
    40. 
  
  
  
  
  40.  
    41. 
  
  
  
  
  41.  // Register default environment beans. 
    42. 
  
  
  
  
  42.  // 注冊 environment 組件，類型是【ConfigurableEnvironment】 
    43. 
  
  
  
  
  43.  if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
    44. 
  
  
  
  
  44.   beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); 
    45. 
  
  
  
  
  45.  } 
    46. 
  
  
  
  
  46.  // 注冊 systemProperties 組件，類型是【Map】 
    47. 
  
  
  
  
  47.  if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
    48. 
  
  
  
  
  48.   beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); 
    49. 
  
  
  
  
  49.  } 
    50. 
  
  
  
  
  50.  // 注冊 systemEnvironment 組件，類型是【Map】 
    51. 
  
  
  
  
  51.  if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
    52. 
  
  
  
  
  52.   beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); 
    53. 
  
  
  
  
  53.  } 
    54. 
  
  
  
  
  54. } 
    55.

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

前文我們說過，Spring 在掃描完所有的 bean 轉(zhuǎn)成 BeanDefinition 時候，我們是可以做一些自定義操作的，這得益于 Spring 為我們提供的 BeanFactoryPostProcessor 接口。

其中 BeanFactoryPostProcessor 又有一個子接口 BeanDefinitionRegistryPostProcessor ，前者會把 ConfigurableListableBeanFactory 暴露給我們使用，后者會把 BeanDefinitionRegistry 注冊器暴露給我們使用，一旦獲取到注冊器，我們就可以按需注入了，例如搞定這種需求：假設(shè)容器中包含了 a 和 b，那么就動態(tài)向容器中注入 c，不滿足就注入 d。

熟悉 Spring 的同學(xué)都知道，Spring 中的同類型組件是允許我們控制順序的，比如在 AOP 中我們常用的 @Order 注解，這里的 BeanFactoryPostProcessor 接口當(dāng)然也是提供了順序，最先被執(zhí)行的是實現(xiàn)了 PriorityOrdered 接口的實現(xiàn)類，然后再到實現(xiàn)了 Ordered 接口的實現(xiàn)類，最后就是剩下來的常規(guī) BeanFactoryPostProcessor 類。

 此時再看上圖，是不是發(fā)現(xiàn)和喝水一般簡單，首先會回調(diào) postProcessBeanDefinitionRegistry() 方法，然后再回調(diào) postProcessBeanFactory() 方法，最后注意順序即可，下面一起看看具體的代碼實現(xiàn)吧。

 
 
 
 
    
  
  
  
  
  1. public static void invokeBeanFactoryPostProcessors( 
    2. 
  
  
  
  
  2.   ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) { 
    3. 
  
  
  
  
  3.  // beanFactoryPostProcessors 這個參數(shù)是指用戶通過 AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手動傳入的 BeanFactoryPostProcessor，沒有交給 spring 管理 
    4. 
  
  
  
  
  4.  // Invoke BeanDefinitionRegistryPostProcessors first, if any. 
    5. 
  
  
  
  
  5.  // 代表執(zhí)行過的 BeanDefinitionRegistryPostProcessor 
    6. 
  
  
  
  
  6.  Set processedBeans = new HashSet<>(); 
    7. 
  
  
  
  
  7.  
    8. 
  
  
  
  
  8.  if (beanFactory instanceof BeanDefinitionRegistry) { 
    9. 
  
  
  
  
  9.   BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; 
    10. 
  
  
  
  
  10.   // 常規(guī)后置處理器集合，即實現(xiàn)了 BeanFactoryPostProcessor 接口 
    11. 
  
  
  
  
  11.   List regularPostProcessors = new ArrayList<>(); 
    12. 
  
  
  
  
  12.   // 注冊后置處理器集合，即實現(xiàn)了 BeanDefinitionRegistryPostProcessor 接口 
    13. 
  
  
  
  
  13.   List registryProcessors = new ArrayList<>(); 
    14. 
  
  
  
  
  14.   // 處理自定義的 beanFactoryPostProcessors（指調(diào)用 context.addBeanFactoryPostProcessor() 方法），一般這里都沒有 
    15. 
  
  
  
  
  15.   for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { 
    16. 
  
  
  
  
  16.    if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { 
    17. 
  
  
  
  
  17.     BeanDefinitionRegistryPostProcessor registryProcessor = 
    18. 
  
  
  
  
  18.       (BeanDefinitionRegistryPostProcessor) postProcessor; 
    19. 
  
  
  
  
  19.     // 調(diào)用 postProcessBeanDefinitionRegistry 方法 
    20. 
  
  
  
  
  20.     registryProcessor.postProcessBeanDefinitionRegistry(registry); 
    21. 
  
  
  
  
  21.     registryProcessors.add(registryProcessor); 
    22. 
  
  
  
  
  22.    } 
    23. 
  
  
  
  
  23.    else { 
    24. 
  
  
  
  
  24.     regularPostProcessors.add(postProcessor); 
    25. 
  
  
  
  
  25.    } 
    26. 
  
  
  
  
  26.   } 
    27. 
  
  
  
  
  27.  
    28. 
  
  
  
  
  28.   // Do not initialize FactoryBeans here: We need to leave all regular beans 
    29. 
  
  
  
  
  29.   // uninitialized to let the bean factory post-processors apply to them! 
    30. 
  
  
  
  
  30.   // Separate between BeanDefinitionRegistryPostProcessors that implement 
    31. 
  
  
  
  
  31.   // PriorityOrdered, Ordered, and the rest. 
    32. 
  
  
  
  
  32.   // 定義一個變量 currentRegistryProcessors，表示當(dāng)前要處理的 BeanFactoryPostProcessors 
    33. 
  
  
  
  
  33.   List currentRegistryProcessors = new ArrayList<>(); 
    34. 
  
  
  
  
  34.  
    35. 
  
  
  
  
  35.   // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. 
    36. 
  
  
  
  
  36.   // 首先，從容器中查找實現(xiàn)了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 類型，這里只會查找出一個【ConfigurationClassPostProcessor】 
    37. 
  
  
  
  
  37.   String[] postProcessorNames = 
    38. 
  
  
  
  
  38.     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
    39. 
  
  
  
  
  39.   for (String ppName : postProcessorNames) { 
    40. 
  
  
  
  
  40.    // 判斷是否實現(xiàn)了 PriorityOrdered 接口 
    41. 
  
  
  
  
  41.    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
    42. 
  
  
  
  
  42.     // 添加到 currentRegistryProcessors 
    43. 
  
  
  
  
  43.     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
    44. 
  
  
  
  
  44.     // 添加到 processedBeans，表示已經(jīng)處理過這個類了 
    45. 
  
  
  
  
  45.     processedBeans.add(ppName); 
    46. 
  
  
  
  
  46.    } 
    47. 
  
  
  
  
  47.   } 
    48. 
  
  
  
  
  48.   // 設(shè)置排列順序 
    49. 
  
  
  
  
  49.   sortPostProcessors(currentRegistryProcessors, beanFactory); 
    50. 
  
  
  
  
  50.   // 添加到 registry 中 
    51. 
  
  
  
  
  51.   registryProcessors.addAll(currentRegistryProcessors); 
    52. 
  
  
  
  
  52.   // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
    53. 
  
  
  
  
  53.   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
    54. 
  
  
  
  
  54.   // 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到 
    55. 
  
  
  
  
  55.   currentRegistryProcessors.clear(); 
    56. 
  
  
  
  
  56.  
    57. 
  
  
  
  
  57.   // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered. 
    58. 
  
  
  
  
  58.   // 接下來，從容器中查找實現(xiàn)了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 類型，這里可能會查找出多個 
    59. 
  
  
  
  
  59.   // 因為【ConfigurationClassPostProcessor】已經(jīng)完成了 postProcessBeanDefinitionRegistry() 方法，已經(jīng)向容器中完成掃描工作，所以容器會有很多個組件 
    60. 
  
  
  
  
  60.   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
    61. 
  
  
  
  
  61.   for (String ppName : postProcessorNames) { 
    62. 
  
  
  
  
  62.    // 判斷 processedBeans 是否處理過這個類，且是否實現(xiàn) Ordered 接口 
    63. 
  
  
  
  
  63.    if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { 
    64. 
  
  
  
  
  64.     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
    65. 
  
  
  
  
  65.     processedBeans.add(ppName); 
    66. 
  
  
  
  
  66.    } 
    67. 
  
  
  
  
  67.   } 
    68. 
  
  
  
  
  68.   // 設(shè)置排列順序 
    69. 
  
  
  
  
  69.   sortPostProcessors(currentRegistryProcessors, beanFactory); 
    70. 
  
  
  
  
  70.   // 添加到 registry 中 
    71. 
  
  
  
  
  71.   registryProcessors.addAll(currentRegistryProcessors); 
    72. 
  
  
  
  
  72.   // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
    73. 
  
  
  
  
  73.   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
    74. 
  
  
  
  
  74.   // 將 currentRegistryProcessors 變量清空，下面會繼續(xù)用到 
    75. 
  
  
  
  
  75.   currentRegistryProcessors.clear(); 
    76. 
  
  
  
  
  76.  
    77. 
  
  
  
  
  77.   // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear. 
    78. 
  
  
  
  
  78.   // 最后，從容器中查找剩余所有常規(guī)的 BeanDefinitionRegistryPostProcessors 類型 
    79. 
  
  
  
  
  79.   boolean reiterate = true; 
    80. 
  
  
  
  
  80.   while (reiterate) { 
    81. 
  
  
  
  
  81.    reiterate = false; 
    82. 
  
  
  
  
  82.    // 根據(jù)類型從容器中查找 
    83. 
  
  
  
  
  83.    postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
    84. 
  
  
  
  
  84.    for (String ppName : postProcessorNames) { 
    85. 
  
  
  
  
  85.     // 判斷 processedBeans 是否處理過這個類 
    86. 
  
  
  
  
  86.     if (!processedBeans.contains(ppName)) { 
    87. 
  
  
  
  
  87.      // 添加到 currentRegistryProcessors 
    88. 
  
  
  
  
  88.      currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
    89. 
  
  
  
  
  89.      // 添加到 processedBeans，表示已經(jīng)處理過這個類了 
    90. 
  
  
  
  
  90.      processedBeans.add(ppName); 
    91. 
  
  
  
  
  91.      // 將標(biāo)識設(shè)置為 true，繼續(xù)循環(huán)查找，可能隨時因為防止下面調(diào)用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置處理器 
    92. 
  
  
  
  
  92.      reiterate = true; 
    93. 
  
  
  
  
  93.     } 
    94. 
  
  
  
  
  94.    } 
    95. 
  
  
  
  
  95.    // 設(shè)置排列順序 
    96. 
  
  
  
  
  96.    sortPostProcessors(currentRegistryProcessors, beanFactory); 
    97. 
  
  
  
  
  97.    // 添加到 registry 中 
    98. 
  
  
  
  
  98.    registryProcessors.addAll(currentRegistryProcessors); 
    99. 
  
  
  
  
  99.    // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
    100. 
  
  
  
  
  100.    invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
    101. 
  
  
  
  
  101.    // 將 currentRegistryProcessors 變量清空，因為下一次循環(huán)可能會用到 
    102. 
  
  
  
  
  102.    currentRegistryProcessors.clear(); 
    103. 
  
  
  
  
  103.   } 
    104. 
  
  
  
  
  104.  
    105. 
  
  
  
  
  105.   // Now, invoke the postProcessBeanFactory callback of all processors handled so far. 
    106. 
  
  
  
  
  106.   // 現(xiàn)在執(zhí)行 registryProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
    107. 
  
  
  
  
  107.   invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); 
    108. 
  
  
  
  
  108.   // 執(zhí)行 regularPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法，也包含用戶手動調(diào)用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor 
    109. 
  
  
  
  
  109.   invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); 
    110. 
  
  
  
  
  110.  } 
    111. 
  
  
  
  
  111.  
    112. 
  
  
  
  
  112.  else { 
    113. 
  
  
  
  
  113.   // Invoke factory processors registered with the context instance. 
    114. 
  
  
  
  
  114.   invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); 
    115. 
  
  
  
  
  115.  } 
    116. 
  
  
  
  
  116.  
    117. 
  
  
  
  
  117.  // Do not initialize FactoryBeans here: We need to leave all regular beans 
    118. 
  
  
  
  
  118.  // uninitialized to let the bean factory post-processors apply to them! 
    119. 
  
  
  
  
  119.  // 從容器中查找實現(xiàn)了 BeanFactoryPostProcessor 接口的類 
    120. 
  
  
  
  
  120.  String[] postProcessorNames = 
    121. 
  
  
  
  
  121.    beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); 
    122. 
  
  
  
  
  122.  
    123. 
  
  
  
  
  123.  // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, 
    124. 
  
  
  
  
  124.  // Ordered, and the rest. 
    125. 
  
  
  
  
  125.  // 表示實現(xiàn)了 PriorityOrdered 接口的 BeanFactoryPostProcessor 
    126. 
  
  
  
  
  126.  List priorityOrderedPostProcessors = new ArrayList<>(); 
    127. 
  
  
  
  
  127.  // 表示實現(xiàn)了 Ordered 接口的 BeanFactoryPostProcessor 
    128. 
  
  
  
  
  128.  List orderedPostProcessorNames = new ArrayList<>(); 
    129. 
  
  
  
  
  129.  // 表示剩下來的常規(guī)的 BeanFactoryPostProcessors 
    130. 
  
  
  
  
  130.  List nonOrderedPostProcessorNames = new ArrayList<>(); 
    131. 
  
  
  
  
  131.  for (String ppName : postProcessorNames) { 
    132. 
  
  
  
  
  132.   // 判斷是否已經(jīng)處理過，因為 postProcessorNames 其實包含了上面步驟處理過的 BeanDefinitionRegistry 類型 
    133. 
  
  
  
  
  133.   if (processedBeans.contains(ppName)) { 
    134. 
  
  
  
  
  134.    // skip - already processed in first phase above 
    135. 
  
  
  
  
  135.   } 
    136. 
  
  
  
  
  136.   // 判斷是否實現(xiàn)了 PriorityOrdered 接口 
    137. 
  
  
  
  
  137.   else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
    138. 
  
  
  
  
  138.    priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); 
    139. 
  
  
  
  
  139.   } 
    140. 
  
  
  
  
  140.   // 判斷是否實現(xiàn)了 Ordered 接口 
    141. 
  
  
  
  
  141.   else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
    142. 
  
  
  
  
  142.    orderedPostProcessorNames.add(ppName); 
    143. 
  
  
  
  
  143.   } 
    144. 
  
  
  
  
  144.   // 剩下所有常規(guī)的 
    145. 
  
  
  
  
  145.   else { 
    146. 
  
  
  
  
  146.    nonOrderedPostProcessorNames.add(ppName); 
    147. 
  
  
  
  
  147.   } 
    148. 
  
  
  
  
  148.  } 
    149. 
  
  
  
  
  149.  
    150. 
  
  
  
  
  150.  // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. 
    151. 
  
  
  
  
  151.  // 先將 priorityOrderedPostProcessors 集合排序 
    152. 
  
  
  
  
  152.  sortPostProcessors(priorityOrderedPostProcessors, beanFactory); 
    153. 
  
  
  
  
  153.  // 執(zhí)行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
    154. 
  
  
  
  
  154.  invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); 
    155. 
  
  
  
  
  155.  
    156. 
  
  
  
  
  156.  // Next, invoke the BeanFactoryPostProcessors that implement Ordered. 
    157. 
  
  
  
  
  157.  // 接下來，把 orderedPostProcessorNames 轉(zhuǎn)成 orderedPostProcessors 集合 
    158. 
  
  
  
  
  158.  List orderedPostProcessors = new ArrayList<>(); 
    159. 
  
  
  
  
  159.  for (String postProcessorName : orderedPostProcessorNames) { 
    160. 
  
  
  
  
  160.   orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); 
    161. 
  
  
  
  
  161.  } 
    162. 
  
  
  
  
  162.  // 將 orderedPostProcessors 集合排序 
    163. 
  
  
  
  
  163.  sortPostProcessors(orderedPostProcessors, beanFactory); 
    164. 
  
  
  
  
  164.  // 執(zhí)行 orderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
    165. 
  
  
  
  
  165.  invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); 
    166. 
  
  
  
  
  166.  
    167. 
  
  
  
  
  167.  // Finally, invoke all other BeanFactoryPostProcessors. 
    168. 
  
  
  
  
  168.  // 最后把 nonOrderedPostProcessorNames 轉(zhuǎn)成 nonOrderedPostProcessors 集合，這里只有一個，myBeanFactoryPostProcessor 
    169. 
  
  
  
  
  169.  List nonOrderedPostProcessors = new ArrayList<>(); 
    170. 
  
  
  
  
  170.  for (String postProcessorName : nonOrderedPostProcessorNames) { 
    171. 
  
  
  
  
  171.   nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); 
    172. 
  
  
  
  
  172.  } 
    173. 
  
  
  
  
  173.  // 執(zhí)行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
    174. 
  
  
  
  
  174.  invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory); 
    175. 
  
  
  
  
  175.  
    176. 
  
  
  
  
  176.  // Clear cached merged bean definitions since the post-processors might have 
    177. 
  
  
  
  
  177.  // modified the original metadata, e.g. replacing placeholders in values... 
    178. 
  
  
  
  
  178.  // 清除緩存 
    179. 
  
  
  
  
  179.  beanFactory.clearMetadataCache(); 
    180.

org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors

這一步是向容器中注入 BeanPostProcessor ，注意這里僅僅是向容器中注入而非使用。參考上面的步驟和下面的代碼，讀者自行分析即可，應(yīng)該不是很困難。

關(guān)于 BeanPostProcessor ，它的作用在后續(xù) Spring 創(chuàng)建 bean 流程文章里我會詳細(xì)分析一下，當(dāng)然不可能分析全部的 BeanPostProcessor 組件，那樣可能得寫好幾篇續(xù)文，這里我們只需要簡單明白這個組件會干預(yù) Spring 初始化 bean 的流程，從而完成代理、自動注入、循環(huán)依賴等各種功能。

 
 
 
 
    
  
  
  
  
  1. public static void registerBeanPostProcessors( 
    2. 
  
  
  
  
  2.   ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { 
    3. 
  
  
  
  
  3.  
    4. 
  
  
  
  
  4.  // 從容器中獲取 BeanPostProcessor 類型 
    5. 
  
  
  
  
  5.  String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); 
    6. 
  
  
  
  
  6.  
    7. 
  
  
  
  
  7.  // Register BeanPostProcessorChecker that logs an info message when 
    8. 
  
  
  
  
  8.  // a bean is created during BeanPostProcessor instantiation, i.e. when 
    9. 
  
  
  
  
  9.  // a bean is not eligible for getting processed by all BeanPostProcessors. 
    10. 
  
  
  
  
  10.  int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; 
    11. 
  
  
  
  
  11.  // 向容器中添加【BeanPostProcessorChecker】，主要是用來檢查是不是有 bean 已經(jīng)初始化完成了， 
    12. 
  
  
  
  
  12.  // 如果沒有執(zhí)行所有的 beanPostProcessor（用數(shù)量來判斷），如果有就會打印一行 info 日志 
    13. 
  
  
  
  
  13.  beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); 
    14. 
  
  
  
  
  14.  
    15. 
  
  
  
  
  15.  // Separate between BeanPostProcessors that implement PriorityOrdered, 
    16. 
  
  
  
  
  16.  // Ordered, and the rest. 
    17. 
  
  
  
  
  17.  // 存放實現(xiàn)了 PriorityOrdered 接口的 BeanPostProcessor 
    18. 
  
  
  
  
  18.  List priorityOrderedPostProcessors = new ArrayList<>(); 
    19. 
  
  
  
  
  19.  // 存放 MergedBeanDefinitionPostProcessor 類型的 BeanPostProcessor 
    20. 
  
  
  
  
  20.  List internalPostProcessors = new ArrayList<>(); 
    21. 
  
  
  
  
  21.  // 存放實現(xiàn)了 Ordered 接口的 BeanPostProcessor 的 name 
    22. 
  
  
  
  
  22.  List orderedPostProcessorNames = new ArrayList<>(); 
    23. 
  
  
  
  
  23.  // 存放剩下來普通的 BeanPostProcessor 的 name 
    24. 
  
  
  
  
  24.  List nonOrderedPostProcessorNames = new ArrayList<>(); 
    25. 
  
  
  
  
  25.  // 從 beanFactory 中查找 postProcessorNames 里的 bean，然后放到對應(yīng)的集合中 
    26. 
  
  
  
  
  26.  for (String ppName : postProcessorNames) { 
    27. 
  
  
  
  
  27.   // 判斷有無實現(xiàn) PriorityOrdered 接口 
    28. 
  
  
  
  
  28.   if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
    29. 
  
  
  
  
  29.    BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 
    30. 
  
  
  
  
  30.    priorityOrderedPostProcessors.add(pp); 
    31. 
  
  
  
  
  31.    // 如果實現(xiàn)了 PriorityOrdered 接口，且屬于 MergedBeanDefinitionPostProcessor 
    32. 
  
  
  
  
  32.    if (pp instanceof MergedBeanDefinitionPostProcessor) { 
    33. 
  
  
  
  
  33.     // 把 MergedBeanDefinitionPostProcessor 類型的添加到 internalPostProcessors 集合中 
    34. 
  
  
  
  
  34.     internalPostProcessors.add(pp); 
    35. 
  
  
  
  
  35.    } 
    36. 
  
  
  
  
  36.   } 
    37. 
  
  
  
  
  37.   else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
    38. 
  
  
  
  
  38.    orderedPostProcessorNames.add(ppName); 
    39. 
  
  
  
  
  39.   } 
    40. 
  
  
  
  
  40.   else { 
    41. 
  
  
  
  
  41.    nonOrderedPostProcessorNames.add(ppName); 
    42. 
  
  
  
  
  42.   } 
    43. 
  
  
  
  
  43.  } 
    44. 
  
  
  
  
  44.  
    45. 
  
  
  
  
  45.  // First, register the BeanPostProcessors that implement PriorityOrdered. 
    46. 
  
  
  
  
  46.  // 給 priorityOrderedPostProcessors 排序 
    47. 
  
  
  
  
  47.  sortPostProcessors(priorityOrderedPostProcessors, beanFactory); 
    48. 
  
  
  
  
  48.  // 先注冊實現(xiàn)了 PriorityOrdered 接口的 beanPostProcessor 
    49. 
  
  
  
  
  49.  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); 
    50. 
  
  
  
  
  50.  
    51. 
  
  
  
  
  51.  // Next, register the BeanPostProcessors that implement Ordered. 
    52. 
  
  
  
  
  52.  // 從 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到對應(yīng)的集合中 
    53. 
  
  
  
  
  53.  List orderedPostProcessors = new ArrayList<>(); 
    54. 
  
  
  
  
  54.  for (String ppName : orderedPostProcessorNames) { 
    55. 
  
  
  
  
  55.   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 
    56. 
  
  
  
  
  56.   orderedPostProcessors.add(pp); 
    57. 
  
  
  
  
  57.   if (pp instanceof MergedBeanDefinitionPostProcessor) { 
    58. 
  
  
  
  
  58.    internalPostProcessors.a                                                
    
                                                本文名稱：肝疼了3萬字的Spring容器啟動流程                                                
    
                                                文章位置：http://www.dlmjj.cn/article/dpeipgh.html