日韩无码专区无码一级三级片|91人人爱网站中日韩无码电影|厨房大战丰满熟妇|AV高清无码在线免费观看|另类AV日韩少妇熟女|中文日本大黄一级黄色片|色情在线视频免费|亚洲成人特黄a片|黄片wwwav色图欧美|欧亚乱色一区二区三区

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

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

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

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

源碼解析

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

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

本篇文章將整個(gè)啟動(dòng)過(guò)程分為了兩個(gè)部分，即容器的初始化與刷新，下面正式開(kāi)始。

初始化流程

流程分析

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

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

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

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

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

通過(guò)上面的思考，是不是上面的圖理解起來(lái)就輕而易舉呢?

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

核心代碼剖析

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

org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

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

 
 
 
 

  
  
  
  
public static Set registerAnnotationConfigProcessors( 
  
  
  
  
  BeanDefinitionRegistry registry, @Nullable Object source) { 
  
  
  
  
 
  
  
  
  
 DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry); 
  
  
  
  
 if (beanFactory != null) { 
  
  
  
  
  if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) { 
  
  
  
  
   beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE); 
  
  
  
  
  } 
  
  
  
  
  if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) { 
  
  
  
  
   beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver()); 
  
  
  
  
  } 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 Set beanDefs = new LinkedHashSet<>(8); 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)【BeanFactoryPostProcessor】：【ConfigurationClassPostProcessor】 
  
  
  
  
 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)); 
  
  
  
  
 } 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)【BeanPostProcessor】：【AutowiredAnnotationBeanPostProcessor】 
  
  
  
  
 if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
  
  
  
  
  RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class); 
  
  
  
  
  def.setSource(source); 
  
  
  
  
  beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor. 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)【BeanPostProcessor】：【CommonAnnotationBeanPostProcessor】 
  
  
  
  
 if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
  
  
  
  
  RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class); 
  
  
  
  
  def.setSource(source); 
  
  
  
  
  beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor. 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)【BeanPostProcessor】：【PersistenceAnnotationBeanPostProcessor】，前提條件是在 jpa 環(huán)境下 
  
  
  
  
 if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) { 
  
  
  
  
  RootBeanDefinition def = new RootBeanDefinition(); 
  
  
  
  
  try { 
  
  
  
  
   def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, 
  
  
  
  
     AnnotationConfigUtils.class.getClassLoader())); 
  
  
  
  
  } 
  
  
  
  
  catch (ClassNotFoundException ex) { 
  
  
  
  
   throw new IllegalStateException( 
  
  
  
  
     "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex); 
  
  
  
  
  } 
  
  
  
  
  def.setSource(source); 
  
  
  
  
  beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)); 
  
  
  
  
 } 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)【BeanFactoryPostProcessor】：【EventListenerMethodProcessor】 
  
  
  
  
 if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) { 
  
  
  
  
  RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class); 
  
  
  
  
  def.setSource(source); 
  
  
  
  
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME)); 
  
  
  
  
 } 
  
  
  
  
 // 向 beanDefinitionMap 中注冊(cè)組件：【DefaultEventListenerFactory】 
  
  
  
  
 if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) { 
  
  
  
  
  RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class); 
  
  
  
  
  def.setSource(source); 
  
  
  
  
  beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME)); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 return beanDefs; 
  
  
  
  
} 
 
 
 
 

org.springframework.context.annotation.AnnotatedBeanDefinitionReader#doRegisterBean

這個(gè)步驟主要是用來(lái)解析用戶傳入的 Spring 配置類，其實(shí)也是解析成一個(gè) BeanDefinition 然后注冊(cè)到容器中，沒(méi)有什么好說(shuō)的。

 
 
 
 

  
  
  
  
 void doRegisterBean(Class annotatedClass, @Nullable Supplier instanceSupplier, @Nullable String name, 
  
  
  
  
  @Nullable Class[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { 
  
  
  
  
 // 解析傳入的配置類，實(shí)際上這個(gè)方法既可以解析配置類，也可以解析 Spring bean 對(duì)象 
  
  
  
  
 AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); 
  
  
  
  
 // 判斷是否需要跳過(guò)，判斷依據(jù)是此類上有沒(méi)有 @Conditional 注解 
  
  
  
  
 if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { 
  
  
  
  
  return; 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 abd.setInstanceSupplier(instanceSupplier); 
  
  
  
  
 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); 
  
  
  
  
 abd.setScope(scopeMetadata.getScopeName()); 
  
  
  
  
 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); 
  
  
  
  
 // 處理類上的通用注解 
  
  
  
  
 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); 
  
  
  
  
 if (qualifiers != null) { 
  
  
  
  
  for (Class qualifier : qualifiers) { 
  
  
  
  
   if (Primary.class == qualifier) { 
  
  
  
  
    abd.setPrimary(true); 
  
  
  
  
   } 
  
  
  
  
   else if (Lazy.class == qualifier) { 
  
  
  
  
    abd.setLazyInit(true); 
  
  
  
  
   } 
  
  
  
  
   else { 
  
  
  
  
    abd.addQualifier(new AutowireCandidateQualifier(qualifier)); 
  
  
  
  
   } 
  
  
  
  
  } 
  
  
  
  
 } 
  
  
  
  
 // 封裝成一個(gè) BeanDefinitionHolder 
  
  
  
  
 for (BeanDefinitionCustomizer customizer : definitionCustomizers) { 
  
  
  
  
  customizer.customize(abd); 
  
  
  
  
 } 
  
  
  
  
 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); 
  
  
  
  
 // 處理 scopedProxyMode 
  
  
  
  
 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); 
  
  
  
  
 
  
  
  
  
 // 把 BeanDefinitionHolder 注冊(cè)到 registry 
  
  
  
  
 BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); 
  
  
  
  
} 
 
 
 
 

刷新流程

流程分析

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

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

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

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

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

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

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

核心代碼剖析

org.springframework.context.support.AbstractApplicationContext#refresh

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

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

 
 
 
 

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

org.springframework.context.support.AbstractApplicationContext#prepareBeanFactory

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

 
 
 
 

  
  
  
  
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
  
  
  
  
 // Tell the internal bean factory to use the context's class loader etc. 
  
  
  
  
 // 設(shè)置 classLoader 
  
  
  
  
 beanFactory.setBeanClassLoader(getClassLoader()); 
  
  
  
  
 //設(shè)置 bean 表達(dá)式解析器 
  
  
  
  
 beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader())); 
  
  
  
  
 beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment())); 
  
  
  
  
 
  
  
  
  
 // Configure the bean factory with context callbacks. 
  
  
  
  
 // 添加一個(gè) BeanPostProcessor【ApplicationContextAwareProcessor】 
  
  
  
  
 beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this)); 
  
  
  
  
 
  
  
  
  
 // 設(shè)置忽略自動(dòng)裝配的接口，即不能通過(guò)注解自動(dòng)注入 
  
  
  
  
 beanFactory.ignoreDependencyInterface(EnvironmentAware.class); 
  
  
  
  
 beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class); 
  
  
  
  
 beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class); 
  
  
  
  
 beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class); 
  
  
  
  
 beanFactory.ignoreDependencyInterface(MessageSourceAware.class); 
  
  
  
  
 beanFactory.ignoreDependencyInterface(ApplicationContextAware.class); 
  
  
  
  
 
  
  
  
  
 // BeanFactory interface not registered as resolvable type in a plain factory. 
  
  
  
  
 // MessageSource registered (and found for autowiring) as a bean. 
  
  
  
  
 // 注冊(cè)可以解析的自動(dòng)裝配類，即可以在任意組件中通過(guò)注解自動(dòng)注入 
  
  
  
  
 beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory); 
  
  
  
  
 beanFactory.registerResolvableDependency(ResourceLoader.class, this); 
  
  
  
  
 beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this); 
  
  
  
  
 beanFactory.registerResolvableDependency(ApplicationContext.class, this); 
  
  
  
  
 
  
  
  
  
 // Register early post-processor for detecting inner beans as ApplicationListeners. 
  
  
  
  
 // 添加一個(gè) BeanPostProcessor【ApplicationListenerDetector】 
  
  
  
  
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this)); 
  
  
  
  
 
  
  
  
  
 // Detect a LoadTimeWeaver and prepare for weaving, if found. 
  
  
  
  
 // 添加編譯時(shí)的 AspectJ 
  
  
  
  
 if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
  
  
  
  
  beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory)); 
  
  
  
  
  // Set a temporary ClassLoader for type matching. 
  
  
  
  
  beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader())); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // Register default environment beans. 
  
  
  
  
 // 注冊(cè) environment 組件，類型是【ConfigurableEnvironment】 
  
  
  
  
 if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
  
  
  
  
  beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment()); 
  
  
  
  
 } 
  
  
  
  
 // 注冊(cè) systemProperties 組件，類型是【Map】 
  
  
  
  
 if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
  
  
  
  
  beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties()); 
  
  
  
  
 } 
  
  
  
  
 // 注冊(cè) systemEnvironment 組件，類型是【Map】 
  
  
  
  
 if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
  
  
  
  
  beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment()); 
  
  
  
  
 } 
  
  
  
  
} 
 
 
 
 

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

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

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

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

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

 
 
 
 

  
  
  
  
public static void invokeBeanFactoryPostProcessors( 
  
  
  
  
  ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) { 
  
  
  
  
 // beanFactoryPostProcessors 這個(gè)參數(shù)是指用戶通過(guò) AnnotationConfigApplicationContext.addBeanFactoryPostProcessor() 方法手動(dòng)傳入的 BeanFactoryPostProcessor，沒(méi)有交給 spring 管理 
  
  
  
  
 // Invoke BeanDefinitionRegistryPostProcessors first, if any. 
  
  
  
  
 // 代表執(zhí)行過(guò)的 BeanDefinitionRegistryPostProcessor 
  
  
  
  
 Set processedBeans = new HashSet<>(); 
  
  
  
  
 
  
  
  
  
 if (beanFactory instanceof BeanDefinitionRegistry) { 
  
  
  
  
  BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; 
  
  
  
  
  // 常規(guī)后置處理器集合，即實(shí)現(xiàn)了 BeanFactoryPostProcessor 接口 
  
  
  
  
  List regularPostProcessors = new ArrayList<>(); 
  
  
  
  
  // 注冊(cè)后置處理器集合，即實(shí)現(xiàn)了 BeanDefinitionRegistryPostProcessor 接口 
  
  
  
  
  List registryProcessors = new ArrayList<>(); 
  
  
  
  
  // 處理自定義的 beanFactoryPostProcessors（指調(diào)用 context.addBeanFactoryPostProcessor() 方法），一般這里都沒(méi)有 
  
  
  
  
  for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { 
  
  
  
  
   if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { 
  
  
  
  
    BeanDefinitionRegistryPostProcessor registryProcessor = 
  
  
  
  
      (BeanDefinitionRegistryPostProcessor) postProcessor; 
  
  
  
  
    // 調(diào)用 postProcessBeanDefinitionRegistry 方法 
  
  
  
  
    registryProcessor.postProcessBeanDefinitionRegistry(registry); 
  
  
  
  
    registryProcessors.add(registryProcessor); 
  
  
  
  
   } 
  
  
  
  
   else { 
  
  
  
  
    regularPostProcessors.add(postProcessor); 
  
  
  
  
   } 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
  // Do not initialize FactoryBeans here: We need to leave all regular beans 
  
  
  
  
  // uninitialized to let the bean factory post-processors apply to them! 
  
  
  
  
  // Separate between BeanDefinitionRegistryPostProcessors that implement 
  
  
  
  
  // PriorityOrdered, Ordered, and the rest. 
  
  
  
  
  // 定義一個(gè)變量 currentRegistryProcessors，表示當(dāng)前要處理的 BeanFactoryPostProcessors 
  
  
  
  
  List currentRegistryProcessors = new ArrayList<>(); 
  
  
  
  
 
  
  
  
  
  // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered. 
  
  
  
  
  // 首先，從容器中查找實(shí)現(xiàn)了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 類型，這里只會(huì)查找出一個(gè)【ConfigurationClassPostProcessor】 
  
  
  
  
  String[] postProcessorNames = 
  
  
  
  
    beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
  
  
  
  
  for (String ppName : postProcessorNames) { 
  
  
  
  
   // 判斷是否實(shí)現(xiàn)了 PriorityOrdered 接口 
  
  
  
  
   if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
  
  
  
  
    // 添加到 currentRegistryProcessors 
  
  
  
  
    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
  
  
  
  
    // 添加到 processedBeans，表示已經(jīng)處理過(guò)這個(gè)類了 
  
  
  
  
    processedBeans.add(ppName); 
  
  
  
  
   } 
  
  
  
  
  } 
  
  
  
  
  // 設(shè)置排列順序 
  
  
  
  
  sortPostProcessors(currentRegistryProcessors, beanFactory); 
  
  
  
  
  // 添加到 registry 中 
  
  
  
  
  registryProcessors.addAll(currentRegistryProcessors); 
  
  
  
  
  // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
  
  
  
  
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
  
  
  
  
  // 將 currentRegistryProcessors 變量清空，下面會(huì)繼續(xù)用到 
  
  
  
  
  currentRegistryProcessors.clear(); 
  
  
  
  
 
  
  
  
  
  // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered. 
  
  
  
  
  // 接下來(lái)，從容器中查找實(shí)現(xiàn)了 Ordered 接口的 BeanDefinitionRegistryPostProcessors 類型，這里可能會(huì)查找出多個(gè) 
  
  
  
  
  // 因?yàn)椤綜onfigurationClassPostProcessor】已經(jīng)完成了 postProcessBeanDefinitionRegistry() 方法，已經(jīng)向容器中完成掃描工作，所以容器會(huì)有很多個(gè)組件 
  
  
  
  
  postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
  
  
  
  
  for (String ppName : postProcessorNames) { 
  
  
  
  
   // 判斷 processedBeans 是否處理過(guò)這個(gè)類，且是否實(shí)現(xiàn) Ordered 接口 
  
  
  
  
   if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) { 
  
  
  
  
    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
  
  
  
  
    processedBeans.add(ppName); 
  
  
  
  
   } 
  
  
  
  
  } 
  
  
  
  
  // 設(shè)置排列順序 
  
  
  
  
  sortPostProcessors(currentRegistryProcessors, beanFactory); 
  
  
  
  
  // 添加到 registry 中 
  
  
  
  
  registryProcessors.addAll(currentRegistryProcessors); 
  
  
  
  
  // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
  
  
  
  
  invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
  
  
  
  
  // 將 currentRegistryProcessors 變量清空，下面會(huì)繼續(xù)用到 
  
  
  
  
  currentRegistryProcessors.clear(); 
  
  
  
  
 
  
  
  
  
  // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear. 
  
  
  
  
  // 最后，從容器中查找剩余所有常規(guī)的 BeanDefinitionRegistryPostProcessors 類型 
  
  
  
  
  boolean reiterate = true; 
  
  
  
  
  while (reiterate) { 
  
  
  
  
   reiterate = false; 
  
  
  
  
   // 根據(jù)類型從容器中查找 
  
  
  
  
   postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false); 
  
  
  
  
   for (String ppName : postProcessorNames) { 
  
  
  
  
    // 判斷 processedBeans 是否處理過(guò)這個(gè)類 
  
  
  
  
    if (!processedBeans.contains(ppName)) { 
  
  
  
  
     // 添加到 currentRegistryProcessors 
  
  
  
  
     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)); 
  
  
  
  
     // 添加到 processedBeans，表示已經(jīng)處理過(guò)這個(gè)類了 
  
  
  
  
     processedBeans.add(ppName); 
  
  
  
  
     // 將標(biāo)識(shí)設(shè)置為 true，繼續(xù)循環(huán)查找，可能隨時(shí)因?yàn)榉乐瓜旅嬲{(diào)用了 invokeBeanDefinitionRegistryPostProcessors() 方法引入新的后置處理器 
  
  
  
  
     reiterate = true; 
  
  
  
  
    } 
  
  
  
  
   } 
  
  
  
  
   // 設(shè)置排列順序 
  
  
  
  
   sortPostProcessors(currentRegistryProcessors, beanFactory); 
  
  
  
  
   // 添加到 registry 中 
  
  
  
  
   registryProcessors.addAll(currentRegistryProcessors); 
  
  
  
  
   // 執(zhí)行 [postProcessBeanDefinitionRegistry] 回調(diào)方法 
  
  
  
  
   invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); 
  
  
  
  
   // 將 currentRegistryProcessors 變量清空，因?yàn)橄乱淮窝h(huán)可能會(huì)用到 
  
  
  
  
   currentRegistryProcessors.clear(); 
  
  
  
  
  } 
  
  
  
  
 
  
  
  
  
  // Now, invoke the postProcessBeanFactory callback of all processors handled so far. 
  
  
  
  
  // 現(xiàn)在執(zhí)行 registryProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
  
  
  
  
  invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); 
  
  
  
  
  // 執(zhí)行 regularPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法，也包含用戶手動(dòng)調(diào)用 addBeanFactoryPostProcessor() 方法添加的 BeanFactoryPostProcessor 
  
  
  
  
  invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 else { 
  
  
  
  
  // Invoke factory processors registered with the context instance. 
  
  
  
  
  invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // Do not initialize FactoryBeans here: We need to leave all regular beans 
  
  
  
  
 // uninitialized to let the bean factory post-processors apply to them! 
  
  
  
  
 // 從容器中查找實(shí)現(xiàn)了 BeanFactoryPostProcessor 接口的類 
  
  
  
  
 String[] postProcessorNames = 
  
  
  
  
   beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); 
  
  
  
  
 
  
  
  
  
 // Separate between BeanFactoryPostProcessors that implement PriorityOrdered, 
  
  
  
  
 // Ordered, and the rest. 
  
  
  
  
 // 表示實(shí)現(xiàn)了 PriorityOrdered 接口的 BeanFactoryPostProcessor 
  
  
  
  
 List priorityOrderedPostProcessors = new ArrayList<>(); 
  
  
  
  
 // 表示實(shí)現(xiàn)了 Ordered 接口的 BeanFactoryPostProcessor 
  
  
  
  
 List orderedPostProcessorNames = new ArrayList<>(); 
  
  
  
  
 // 表示剩下來(lái)的常規(guī)的 BeanFactoryPostProcessors 
  
  
  
  
 List nonOrderedPostProcessorNames = new ArrayList<>(); 
  
  
  
  
 for (String ppName : postProcessorNames) { 
  
  
  
  
  // 判斷是否已經(jīng)處理過(guò)，因?yàn)?nbsp;postProcessorNames 其實(shí)包含了上面步驟處理過(guò)的 BeanDefinitionRegistry 類型 
  
  
  
  
  if (processedBeans.contains(ppName)) { 
  
  
  
  
   // skip - already processed in first phase above 
  
  
  
  
  } 
  
  
  
  
  // 判斷是否實(shí)現(xiàn)了 PriorityOrdered 接口 
  
  
  
  
  else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
  
  
  
  
   priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); 
  
  
  
  
  } 
  
  
  
  
  // 判斷是否實(shí)現(xiàn)了 Ordered 接口 
  
  
  
  
  else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
  
  
  
  
   orderedPostProcessorNames.add(ppName); 
  
  
  
  
  } 
  
  
  
  
  // 剩下所有常規(guī)的 
  
  
  
  
  else { 
  
  
  
  
   nonOrderedPostProcessorNames.add(ppName); 
  
  
  
  
  } 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered. 
  
  
  
  
 // 先將 priorityOrderedPostProcessors 集合排序 
  
  
  
  
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory); 
  
  
  
  
 // 執(zhí)行 priorityOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
  
  
  
  
 invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory); 
  
  
  
  
 
  
  
  
  
 // Next, invoke the BeanFactoryPostProcessors that implement Ordered. 
  
  
  
  
 // 接下來(lái)，把 orderedPostProcessorNames 轉(zhuǎn)成 orderedPostProcessors 集合 
  
  
  
  
 List orderedPostProcessors = new ArrayList<>(); 
  
  
  
  
 for (String postProcessorName : orderedPostProcessorNames) { 
  
  
  
  
  orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); 
  
  
  
  
 } 
  
  
  
  
 // 將 orderedPostProcessors 集合排序 
  
  
  
  
 sortPostProcessors(orderedPostProcessors, beanFactory); 
  
  
  
  
 // 執(zhí)行 orderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
  
  
  
  
 invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory); 
  
  
  
  
 
  
  
  
  
 // Finally, invoke all other BeanFactoryPostProcessors. 
  
  
  
  
 // 最后把 nonOrderedPostProcessorNames 轉(zhuǎn)成 nonOrderedPostProcessors 集合，這里只有一個(gè)，myBeanFactoryPostProcessor 
  
  
  
  
 List nonOrderedPostProcessors = new ArrayList<>(); 
  
  
  
  
 for (String postProcessorName : nonOrderedPostProcessorNames) { 
  
  
  
  
  nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class)); 
  
  
  
  
 } 
  
  
  
  
 // 執(zhí)行 nonOrderedPostProcessors 的 [postProcessBeanFactory] 回調(diào)方法 
  
  
  
  
 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(); 
 
 
 
 

org.springframework.context.support.PostProcessorRegistrationDelegate#registerBeanPostProcessors

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

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

 
 
 
 

  
  
  
  
public static void registerBeanPostProcessors( 
  
  
  
  
  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) { 
  
  
  
  
 
  
  
  
  
 // 從容器中獲取 BeanPostProcessor 類型 
  
  
  
  
 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); 
  
  
  
  
 
  
  
  
  
 // Register BeanPostProcessorChecker that logs an info message when 
  
  
  
  
 // a bean is created during BeanPostProcessor instantiation, i.e. when 
  
  
  
  
 // a bean is not eligible for getting processed by all BeanPostProcessors. 
  
  
  
  
 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length; 
  
  
  
  
 // 向容器中添加【BeanPostProcessorChecker】，主要是用來(lái)檢查是不是有 bean 已經(jīng)初始化完成了， 
  
  
  
  
 // 如果沒(méi)有執(zhí)行所有的 beanPostProcessor（用數(shù)量來(lái)判斷），如果有就會(huì)打印一行 info 日志 
  
  
  
  
 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount)); 
  
  
  
  
 
  
  
  
  
 // Separate between BeanPostProcessors that implement PriorityOrdered, 
  
  
  
  
 // Ordered, and the rest. 
  
  
  
  
 // 存放實(shí)現(xiàn)了 PriorityOrdered 接口的 BeanPostProcessor 
  
  
  
  
 List priorityOrderedPostProcessors = new ArrayList<>(); 
  
  
  
  
 // 存放 MergedBeanDefinitionPostProcessor 類型的 BeanPostProcessor 
  
  
  
  
 List internalPostProcessors = new ArrayList<>(); 
  
  
  
  
 // 存放實(shí)現(xiàn)了 Ordered 接口的 BeanPostProcessor 的 name 
  
  
  
  
 List orderedPostProcessorNames = new ArrayList<>(); 
  
  
  
  
 // 存放剩下來(lái)普通的 BeanPostProcessor 的 name 
  
  
  
  
 List nonOrderedPostProcessorNames = new ArrayList<>(); 
  
  
  
  
 // 從 beanFactory 中查找 postProcessorNames 里的 bean，然后放到對(duì)應(yīng)的集合中 
  
  
  
  
 for (String ppName : postProcessorNames) { 
  
  
  
  
  // 判斷有無(wú)實(shí)現(xiàn) PriorityOrdered 接口 
  
  
  
  
  if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { 
  
  
  
  
   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 
  
  
  
  
   priorityOrderedPostProcessors.add(pp); 
  
  
  
  
   // 如果實(shí)現(xiàn)了 PriorityOrdered 接口，且屬于 MergedBeanDefinitionPostProcessor 
  
  
  
  
   if (pp instanceof MergedBeanDefinitionPostProcessor) { 
  
  
  
  
    // 把 MergedBeanDefinitionPostProcessor 類型的添加到 internalPostProcessors 集合中 
  
  
  
  
    internalPostProcessors.add(pp); 
  
  
  
  
   } 
  
  
  
  
  } 
  
  
  
  
  else if (beanFactory.isTypeMatch(ppName, Ordered.class)) { 
  
  
  
  
   orderedPostProcessorNames.add(ppName); 
  
  
  
  
  } 
  
  
  
  
  else { 
  
  
  
  
   nonOrderedPostProcessorNames.add(ppName); 
  
  
  
  
  } 
  
  
  
  
 } 
  
  
  
  
 
  
  
  
  
 // First, register the BeanPostProcessors that implement PriorityOrdered. 
  
  
  
  
 // 給 priorityOrderedPostProcessors 排序 
  
  
  
  
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory); 
  
  
  
  
 // 先注冊(cè)實(shí)現(xiàn)了 PriorityOrdered 接口的 beanPostProcessor 
  
  
  
  
 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); 
  
  
  
  
 
  
  
  
  
 // Next, register the BeanPostProcessors that implement Ordered. 
  
  
  
  
 // 從 beanFactory 中查找 orderedPostProcessorNames 里的 bean，然后放到對(duì)應(yīng)的集合中 
  
  
  
  
 List orderedPostProcessors = new ArrayList<>(); 
  
  
  
  
 for (String ppName : orderedPostProcessorNames) { 
  
  
  
  
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); 
  
  
  
  
  orderedPostProcessors.add(pp); 
  
  
  
  
  if (pp instanceof MergedBeanDefinitionPostProcessor) { 
  
  
  
  
   internalPostProcessors.a                                                

                                                本文題目：肝疼了3萬(wàn)字的Spring容器啟動(dòng)流程                                                

                                                當(dāng)前地址：http://www.5511xx.com/article/dpeipgh.html