Alian解读SpringBoot 2.6.0 源码（八）：启动流程分析之刷新应用上下文（中）

一、背景
- 1.1、刷新的整体调用流程
- 1.2、本文解读范围
二、调用后处理器
- 2.1、调用在上下文中注册为beanFactory的后置处理器
- 2.2、invokeBeanFactoryPostProcessors的整体流程
- 2.3、两个常用的调用方法
- 2.4、beanFactory获取BeanDefinitionRegistryPostProcessor
- 2.5、BeanDefinitionRegistryPostProcessor类
- - 2.5.1、实现了PriorityOrdered
  - 2.5.2、实现了Ordered
  - 2.5.3、没实现排序
  - 2.5.4、结果
- 2.6、BeanFactoryPostProcessor类
- - 2.6.1、实现了PriorityOrdered
  - 2.6.2、实现了Ordered
  - 2.6.3、没实现排序
三、注册拦截bean创建的BeanPostProcessor
- 3.1、registerBeanPostProcessors
- 3.2、常用的调用方法
- 3.3、BeanPostProcessor类
- - 3.3.1、实现了PriorityOrdered
  - 3.3.2、实现了Ordered
  - 3.3.3、没实现排序
  - 3.3.4、MergedBeanDefinitionPostProcessor
  - 3.3.5、最终beanFactory里的BeanPostProcessor
四、初始化消息源
五、初始化SimpleApplicationEventMulticaster
结语

一、背景

上一篇我们解读了刷新应用上下文（上），本篇主要解读刷新应用上下文（中），老样子还是回顾下刷新的整体流程，这样就能不迷路。

1.1、刷新的整体调用流程

此方法所在类的具体路径：org.springframework.boot.SpringApplication

 private void refreshContext(ConfigurableApplicationContext context) {if (this.registerShutdownHook) {// 又增加一个监听器ApplicationContextClosedListener，上一文我们讲过准备刷新是11个，现在就是12个了shutdownHook.registerApplicationContext(context);}refresh(context);}protected void refresh(ConfigurableApplicationContext applicationContext) {// 最终实现是AbstractApplicationContext的refresh方法applicationContext.refresh();}

此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext

@Overridepublic void refresh() throws BeansException, IllegalStateException {// 同步的方式刷新synchronized (this.startupShutdownMonitor) {StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");// 准备此上下文以进行刷新prepareRefresh();// 告诉子类刷新内部bean工厂ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();// 准备bean工厂，以便在此上下文中使用prepareBeanFactory(beanFactory);try {// 允许在上下文中子类对bean工厂进行后处理postProcessBeanFactory(beanFactory);StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");// 调用在上下文中注册为beanFactory的后置处理器invokeBeanFactoryPostProcessors(beanFactory);// 注册拦截bean创建的BeanPostProcessorregisterBeanPostProcessors(beanFactory);beanPostProcess.end();// 为此上下文初始化消息源，也就是注册DelegatingMessageSourceinitMessageSource();// 为此上下文初始化事件multicasterinitApplicationEventMulticaster();// 初始化特定上下文子类中的其他特殊bean，比如创建内置的Servlet容器onRefresh();// 检查监听器bean并注册它们registerListeners();// 实例化所有剩余的（非惰性初始化）单例finishBeanFactoryInitialization(beanFactory);// 最后一步：发布相应的事件finishRefresh();} catch (BeansException ex) {if (logger.isWarnEnabled()) {logger.warn("Exception encountered during context initialization - " + "cancelling refresh attempt: " + ex);}// 销毁已创建的单例以避免悬空资源destroyBeans();// 重置“active”标志cancelRefresh(ex);// 将异常传播到调用方throw ex;} finally {//重置Spring核心中的常见内省缓存，因为我们可能不再需要单例bean的元数据了。。。resetCommonCaches();contextRefresh.end();}}}

1.2、本文解读范围

本文主要讲解refresh()方法的部分内容，也就是：

 // 前面已讲解，就省略了try {// 前面已讲解，就省略了StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");// 调用在上下文中注册为bean的工厂处理器invokeBeanFactoryPostProcessors(beanFactory);// 注册拦截bean创建的BeanPostProcessorregisterBeanPostProcessors(beanFactory);beanPostProcess.end();// 为此上下文初始化消息源，也就是注册DelegatingMessageSourceinitMessageSource();// 为此上下文初始化事件multicasterinitApplicationEventMulticaster();// 后面省略，本文解读到此处} catch (BeansException ex) {}finally{}

整个方法的内容比较多，为了比较详细的解读，我们就分多个部分解读，大家一定要先看刷新应用上下文（上）。

二、调用后处理器

2.1、调用在上下文中注册为beanFactory的后置处理器

此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext

 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());// 检测LoadTimeWeaver并准备编织（如果同时发现）//（例如，通过ConfigurationClassPostProcessor注册的@Bean方法）if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}

这里是委托给PostProcessorRegistrationDelegate去调用beanFactory的后置处理器，首先我们要先看下getBeanFactoryPostProcessors方法返回的两个后置处理器。

SharedMetadataReaderFactoryContextInitializer 的内部类CachingMetadataReaderFactoryPostProcessor
ConfigurationWarningsApplicationContextInitializer 的内部类ConfigurationWarningsPostProcessor

那么这两个后置处理器是什么时候添加的呢？如果有看过我之前的文章：Alian解读SpringBoot 2.6.0 源码（七）：启动流程分析之准备应用上下文中的章节2.4、应用所有初始化器，就会知道是在调用应用初始化器方法applyInitializers时，遍历所有的初始化器，并调用初始化器的initialize方法时添加的，两个初始化器分别是：SharedMetadataReaderFactoryContextInitializer和ConfigurationWarningsApplicationContextInitializer

2.2、invokeBeanFactoryPostProcessors的整体流程

接下里我们看下最核心的invokeBeanFactoryPostProcessors方法，此方法所在类的具体路径：org.springframework.context.support.PostProcessorRegistrationDelegate

开始这里讲解时，我们先介绍两个基本的概念，这样大家有个简单的区分：

BeanFactoryPostProcessor：用来修改Spring容器中已经存在的bean的定义，使用ConfigurableListableBeanFactory对bean进行处理
BeanDefinitionRegistryPostProcessor：继承BeanFactoryPostProcessor，作用跟BeanFactoryPostProcessor一样，只不过是使用BeanDefinitionRegistry对bean进行处理

final class PostProcessorRegistrationDelegate {private PostProcessorRegistrationDelegate() {}// 此方法最重要的是要确保注册和调用按照指定的顺序，比如PriorityOrdered和Ordered public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// 定义Set集合processedBeans Set<String> processedBeans = new HashSet<>();// beanFactory 就是DefaultListableBeanFactory,它实现了接口BeanDefinitionRegistry// 故此处是BeanDefinitionRegistry的实例if (beanFactory instanceof BeanDefinitionRegistry) {// 转为BeanDefinitionRegistry BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;// 定义BeanFactoryPostProcessor列表List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();// 定义BeanDefinitionRegistryPostProcessor列表，属于BeanDefinitionRegistryPostProcessor的实例的List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();// 从上一步我们知道beanFactoryPostProcessors有两个：// CachingMetadataReaderFactoryPostProcessor 和 ConfigurationWarningsPostProcessor// 开始遍历后置处理器beanFactoryPostProcessorsfor (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {// 都实现了BeanDefinitionRegistryPostProcessor接口if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {// 转为BeanDefinitionRegistryPostProcessor BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;// 调用后置处理器的postProcessBeanDefinitionRegistryregistryProcessor.postProcessBeanDefinitionRegistry(registry);// 加入到BeanDefinitionRegistryPostProcessor列表registryProcessors.add(registryProcessor);} else {// 加入到BeanFactoryPostProcessor列表regularPostProcessors.add(postProcessor);}}// 定义当前调用的BeanDefinitionRegistryPostProcessor列表// 同样不要在这里初始化FactoryBeans：需要确保所有常规Bean未初始化以使beanFactory后处理器应用于它们List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();// 首先，调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessorString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {// 是否实现了PriorityOrdered接口if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// 获取对应的后处理器，添加到当前调用的BeanDefinitionRegistryPostProcessor列表currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));// 添加到Set集合processedBeansprocessedBeans.add(ppName);}}// 排序sortPostProcessors(currentRegistryProcessors, beanFactory);// 把当前实现了PriorityOrdered接口BeanDefinitionRegistryPostProcessor列表都加入到BeanDefinitionRegistryPostProcessor列表registryProcessors.addAll(currentRegistryProcessors);// 循环调用postProcessBeanDefinitionRegistry()方法（实现了PriorityOrdered接口）invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());// 清空当前调用的BeanDefinitionRegistryPostProcessor列表currentRegistryProcessors.clear();// 接下来，调用实现Ordered接口的BeanDefinitionRegistryPostProcessor。postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {// 是否实现了Ordered接口if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {// 把当前实现了Ordered接口BeanDefinitionRegistryPostProcessor都加入到BeanDefinitionRegistryPostProcessor列表currentRegistryProcessors.add(beanFactory.getBean(ppName,BeanDefinitionRegistryPostProcessor.class));// 添加到Set集合processedBeansprocessedBeans.add(ppName);}} // 排序sortPostProcessors(currentRegistryProcessors, beanFactory);// 把当前实现了Ordered接口BeanDefinitionRegistryPostProcessor列表都加入到BeanDefinitionRegistryPostProcessor列表registryProcessors.addAll(currentRegistryProcessors);// 循环调用postProcessBeanDefinitionRegistry()方法（实现了Ordered接口）invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());// 清空当前调用的BeanDefinitionRegistryPostProcessor列表currentRegistryProcessors.clear();// 最后，调用所有没有实现PriorityOrdered接口或Ordered接口的BeanDefinitionRegistryPostProcessorboolean reiterate = true;while (reiterate) {reiterate = false;postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (!processedBeans.contains(ppName)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);reiterate = true;}}// 排序sortPostProcessors(currentRegistryProcessors, beanFactory);// 没有实现PriorityOrdered接口或Ordered接口的BeanDefinitionRegistryPostProcessor都加入到BeanDefinitionRegistryPostProcessor列表registryProcessors.addAll(currentRegistryProcessors);// 循环调用postProcessBeanDefinitionRegistry()方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());// 清空当前调用的BeanDefinitionRegistryPostProcessor列表currentRegistryProcessors.clear();}// 现在，调用到目前为止处理的所有处理器的postProcessBeanFactory回调invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);} else {// 调用在上下文实例中注册的工厂处理器,也就是调用postProcessBeanFactory方法invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}// 定义后处理名称列表，同样此处也不要初始化String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (processedBeans.contains(ppName)) {// 跳过-已在上述第一阶段处理} else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// 实现了PriorityOrdered的加入到新的BeanFactoryPostProcessor列表priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {// 实现了Ordered接口的，把后处理器名称加入到列表orderedPostProcessorNames orderedPostProcessorNames.add(ppName);} else {// 没有排序的，把后处理器名称加入到列表nonOrderedPostProcessorNames nonOrderedPostProcessorNames.add(ppName);}}// 首先// 对实现了PriorityOrdered接口的BeanFactoryPostProcessor列表进行排序sortPostProcessors(priorityOrderedPostProcessors, beanFactory);// 首先，调用实现PriorityOrdered接口的BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 接下来List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String postProcessorName : orderedPostProcessorNames) {// 通过beanFactory和后处理器名称获取后处理器（实现Ordered接口），并添加到列表orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}// 对实现了Ordered接口的后处理器进行排序sortPostProcessors(orderedPostProcessors, beanFactory);// 调用实现Ordered接口的BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);// 最后// 调用所有其他BeanFactoryPostProcessorList<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String postProcessorName : nonOrderedPostProcessorNames) {// 通过beanFactory和后处理器名称获取后处理器，并添加到列表nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}// 调用所有其他BeanFactoryPostProcessorinvokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// 清除缓存的合并bean定义，因为后处理器可能修改了原始元数据，例如替换值中的占位符beanFactory.clearMetadataCache();}
}

代码是不是很长？来我们来整理下：

开始遍历后置处理器beanFactoryPostProcessors（上篇文章可知2个），如果是BeanDefinitionRegistryPostProcessor的实例，就调用后置处理器的postProcessBeanDefinitionRegistry方法，然后加入到BeanDefinitionRegistryPostProcessor列表（registryProcessors ）；否则就加入到BeanFactoryPostProcessor列表（regularPostProcessors ）
定义当前调用的BeanDefinitionRegistryPostProcessor列表（currentRegistryProcessors ），不要有初始值
获取实现了BeanDefinitionRegistryPostProcessor的后处理器的名称列表（postProcessorNames），遍历这个列表，判断是否实现了PriorityOrdered接口，如果实现了，就获取对应的后处理器，并把它添加到当前调用的BeanDefinitionRegistryPostProcessor列表（currentRegistryProcessors ），同时把名称加入到Set集合（processedBeans），对列表（currentRegistryProcessors ）进行排序，然后把currentRegistryProcessors 都加入到registryProcessors，通过方法invokeBeanDefinitionRegistryPostProcessors，循环调用每个后处理器的postProcessBeanDefinitionRegistry()方法，最后清空currentRegistryProcessors列表
获取实现了BeanDefinitionRegistryPostProcessor的后处理器的名称列表（postProcessorNames），遍历这个列表，判断是否实现了Ordered接口，如果实现了，就获取对应的后处理器，并把它添加到当前调用的BeanDefinitionRegistryPostProcessor列表（currentRegistryProcessors ），同时把名称加入到Set集合（processedBeans），对列表（currentRegistryProcessors ）进行排序，然后把currentRegistryProcessors 都加入到registryProcessors，通过方法invokeBeanDefinitionRegistryPostProcessors，循环调用每个后处理器的postProcessBeanDefinitionRegistry()方法，最后清空currentRegistryProcessors列表
调用所有没有实现PriorityOrdered接口或Ordered接口的BeanDefinitionRegistryPostProcessor，并把它添加到currentRegistryProcessors 列表，对列表（currentRegistryProcessors ）进行排序，然后把currentRegistryProcessors 都加入到registryProcessors，通过方法invokeBeanDefinitionRegistryPostProcessors，循环调用每个后处理器的postProcessBeanDefinitionRegistry()方法，最后清空currentRegistryProcessors列表
调用到目前为止处理的所有处理器的postProcessBeanFactory回调（也就是registryProcessors和regularPostProcessors）
定义BeanFactoryPostProcessor列表（priorityOrderedPostProcessors ），实现Ordered接口的名称列表（orderedPostProcessorNames ），没有实现排序的接口名称列表（nonOrderedPostProcessorNames）
获取实现了BeanFactoryPostProcessor的后处理器的名称列表，遍历这个列表，如果实现了PriorityOrdered就把它加入到priorityOrderedPostProcessors，如果实现了Ordered接口，就把后处理器名称加入到列表orderedPostProcessorNames，没有排序的，把后处理器名称加入到列表nonOrderedPostProcessorNames
对priorityOrderedPostProcessors进行排序，然后通过方法invokeBeanFactoryPostProcessors，循环调用每个后处理器的postProcessBeanFactory()方法
定义BeanFactoryPostProcessor列表（orderedPostProcessors ），对orderedPostProcessors进行排序，然后通过方法invokeBeanFactoryPostProcessors，循环调用每个后处理器的postProcessBeanFactory()方法
定义BeanFactoryPostProcessor列表（nonOrderedPostProcessors ），遍历列表nonOrderedPostProcessorNames，通过beanFactory和后处理器名称获取后处理器，并添加到列表nonOrderedPostProcessors，然后通过方法invokeBeanFactoryPostProcessors，循环调用每个后处理器的postProcessBeanFactory()方法
清除缓存的合并bean定义，因为后处理器可能修改了原始元数据，例如替换值中的占位符

这里的查找规则，不管是BeanDefinitionRegistryPostProcessor还是BeanFactoryPostProcessor，都是先找PriorityOrdered，然后是Ordered，最后是两者都没实现的，其中每一个类型中操作完一种接口的实现就清空一次currentRegistryProcessors列表，执行也是一样。

2.3、两个常用的调用方法

两个方法所在类的具体路径：org.springframework.context.support.PostProcessorRegistrationDelegate ，其实也很好分，一个是和BeanDefinitionRegistryPostProcessor有关的invokeBeanDefinitionRegistryPostProcessors方法；

 private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process").tag("postProcessor", postProcessor::toString);postProcessor.postProcessBeanDefinitionRegistry(registry);postProcessBeanDefRegistry.end();}}

一个是和BeanFactoryPostProcessor有关的invokeBeanFactoryPostProcessors方法

 private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {for (BeanFactoryPostProcessor postProcessor : postProcessors) {StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process").tag("postProcessor", postProcessor::toString);postProcessor.postProcessBeanFactory(beanFactory);postProcessBeanFactory.end();}}

看完这两个方法，我们再把结果理一下，大家就会对整个流程很清晰了

2.4、beanFactory获取BeanDefinitionRegistryPostProcessor

从上面2.1章节我们知道beanFactoryPostProcessors有两个，这里会判断是否属于BeanDefinitionRegistryPostProcessor，是则先调用postProcessBeanDefinitionRegistry()方法，此步骤得到的结果（registryProcessors）如下：

CachingMetadataReaderFactoryPostProcessor（ SharedMetadataReaderFactoryContextInitializer 的内部类）
ConfigurationWarningsPostProcessor（ConfigurationWarningsApplicationContextInitializer 的内部类）

2.5、BeanDefinitionRegistryPostProcessor类

这里先找出所有实现BeanDefinitionRegistryPostProcessor类的对象，然后分成三类进行解析调用。我这里整理了，也把结果贴出来了。

2.5.1、实现了PriorityOrdered

ConfigurationClassPostProcessor

2.5.2、实现了Ordered

没有获取到

2.5.3、没实现排序

没有获取到

2.5.4、结果

到这里时此步骤得到的结果（registryProcessors）如下：

CachingMetadataReaderFactoryPostProcessor（ SharedMetadataReaderFactoryContextInitializer 的内部类）
ConfigurationWarningsPostProcessor（ConfigurationWarningsApplicationContextInitializer 的内部类）
ConfigurationClassPostProcessor

2.6、BeanFactoryPostProcessor类

同样的这里先找出所有实现BeanFactoryPostProcessor类的对象，然后分成三类进行解析调用。这里我也整理了，也把结果贴出来了。

2.6.1、实现了PriorityOrdered

PropertySourcesPlaceholderConfigurer

2.6.2、实现了Ordered

DependsOnDatabaseInitializationPostProcessor（DatabaseInitializationDependencyConfigurer的内部类）

2.6.3、没实现排序

EventListenerMethodProcessor
PreserveErrorControllerTargetClassPostProcessor（ErrorMvcAutoConfiguration的内部类）
ClassProxyingConfiguration（AopAutoConfiguration的内部类）

三、注册拦截bean创建的BeanPostProcessor

3.1、registerBeanPostProcessors

此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext

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

方法所在类的具体路径：org.springframework.context.support.PostProcessorRegistrationDelegate

final class PostProcessorRegistrationDelegate {public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {// 此方法最重要的是要确保注册和调用按照指定的顺序，比如PriorityOrdered和Ordered // 获取实现了BeanPostProcessor接口的postProcessorName列表String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// 当BeanPostProcessor实例化期间创建bean时，注册BeanPostProcessorChecker// 一个bean不能被所有的BeanPostProcessor处理// 现在有4个BeanPostProcessor：ApplicationContextAwareProcessor，ApplicationListenerDetector，         //WebApplicationContextServletContextAwareProcessor，ImportAwareBeanPostProcessor（ConfigurationClassPostProcessor的内部类）// postProcessorNames.length=6int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;// 再加一个BeanPostProcessor，此时是5个了beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// 在实现PriorityOrdered、Ordered和rest的BeanPostProcessor之间进行分离。List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// 实现了PriorityOrdered接口，获取对应的BeanPostProcessorBeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);// 加入到列表priorityOrderedPostProcessorspriorityOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessorsinternalPostProcessors.add(pp);}} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {// 实现了Ordered接口，加入到列表orderedPostProcessorNamesorderedPostProcessorNames.add(ppName);} else {// 都没有实现，加入到列表nonOrderedPostProcessorNamesnonOrderedPostProcessorNames.add(ppName);}}// 首先，对实现了PriorityOrdered接口的BeanPostProcessor进行处理// 排序sortPostProcessors(priorityOrderedPostProcessors, beanFactory);// 注册实现PriorityOrdered的BeanPostProcessorregisterBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// 接下来，对实现了Ordered接口的BeanPostProcessor进行处理List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String ppName : orderedPostProcessorNames) {// 根据名称获取实现了Ordered接口的BeanPostProcessor BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);// 加入到列表orderedPostProcessorsorderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessorsinternalPostProcessors.add(pp);}}// 排序sortPostProcessors(orderedPostProcessors, beanFactory);// 注册实现Ordered的BeanPostProcessorregisterBeanPostProcessors(beanFactory, orderedPostProcessors);// 然后，对所有常规BeanPostProcessor进行注册List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String ppName : nonOrderedPostProcessorNames) {// 根据名称获取常规的BeanPostProcessorBeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);// 加入到列表nonOrderedPostProcessorsnonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessorsinternalPostProcessors.add(pp);}}// 注册所有常规BeanPostProcessorregisterBeanPostProcessors(beanFactory, nonOrderedPostProcessors);// 最后，重新注册所有内部BeanPostProcessor// 排序sortPostProcessors(internalPostProcessors, beanFactory);// 重新注册所有内部BeanPostProcessorregisterBeanPostProcessors(beanFactory, internalPostProcessors);// 添加ApplicationListenerDetector，将用于检测内部bean的后处理器重新注册为ApplicationListenerbeanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));}
}

获取实现了BeanPostProcessor接口的后处理器名称列表（postProcessorNames）
给beanFactory添加一个BeanPostProcessor（BeanPostProcessorChecker）
定义BeanPostProcessor列表priorityOrderedPostProcessors和internalPostProcessors，以及BeanPostProcessor的名称列表orderedPostProcessorNames和nonOrderedPostProcessorNames
遍历列表postProcessorNames，如果实现了PriorityOrdered就加入到priorityOrderedPostProcessors；实现了Ordered的就加入orderedPostProcessorNames；实现了PriorityOrdered，并且是MergedBeanDefinitionPostProcessor 的一个实例就加入到internalPostProcessors，其他的就都加入到nonOrderedPostProcessorNames
对列表priorityOrderedPostProcessors进行排序，然后通过调用方法registerBeanPostProcessors，把后置处理器加入到beanFactory
定义BeanPostProcessor列表orderedPostProcessors，遍历列表orderedPostProcessorNames，通过名称获取BeanPostProcessor，并加入到列表orderedPostProcessors，如果还是MergedBeanDefinitionPostProcessor 的一个实例就加入到internalPostProcessors
对列表orderedPostProcessors进行排序，然后通过调用方法registerBeanPostProcessors，把后置处理器加入到beanFactory
定义BeanPostProcessor列表nonOrderedPostProcessors，遍历列表nonOrderedPostProcessorNames，通过名称获取BeanPostProcessor，并加入到列表nonOrderedPostProcessors，如果还是MergedBeanDefinitionPostProcessor 的一个实例就加入到internalPostProcessors，然后通过调用方法registerBeanPostProcessors，把后置处理器加入到beanFactory
对列表internalPostProcessors进行排序，然后通过调用方法registerBeanPostProcessors，把后置处理器加入到beanFactory
给beanFactory添加一个BeanPostProcessor（ApplicationListenerDetector）

多看两遍代码注释就能看懂了

3.2、常用的调用方法

方法所在类的具体路径：org.springframework.context.support.PostProcessorRegistrationDelegate

 private static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {// 是否是AbstractBeanFactory的实例if (beanFactory instanceof AbstractBeanFactory) {// 批量添加((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);} else {// 遍历后单个添加for (BeanPostProcessor postProcessor : postProcessors) {beanFactory.addBeanPostProcessor(postProcessor);}}}

3.3、BeanPostProcessor类

其实这里的流程和之前是查不多的，大家需要关注的是他们的结果值，那将是后面解析的核心内容。

3.3.1、实现了PriorityOrdered

ConfigurationPropertiesBindingPostProcessor
CommonAnnotationBeanPostProcessor
AutowiredAnnotationBeanPostProcessor

3.3.2、实现了Ordered

InfrastructureAdvisorAutoProxyCreator

3.3.3、没实现排序

WebServerFactoryCustomizerBeanPostProcessor
ErrorPageRegistrarBeanPostProcessor

3.3.4、MergedBeanDefinitionPostProcessor

CommonAnnotationBeanPostProcessor
AutowiredAnnotationBeanPostProcessor

3.3.5、最终beanFactory里的BeanPostProcessor

ApplicationContextAwareProcessor
WebApplicationContextServletContextAwareProcessor （重要）
ImportAwareBeanPostProcessor（ConfigurationClassPostProcessor的内部类）（重要）
BeanPostProcessorChecker（PostProcessorRegistrationDelegate的内部类）
ConfigurationPropertiesBindingPostProcessor（核心）
InfrastructureAdvisorAutoProxyCreator（核心）
WebServerFactoryCustomizerBeanPostProcessor
ErrorPageRegistrarBeanPostProcessor
CommonAnnotationBeanPostProcessor（核心）
AutowiredAnnotationBeanPostProcessor （核心）
ApplicationListenerDetector

四、初始化消息源

此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext

 // 工厂中MessageSourc(消息资源) bean的名称// 如果未提供任何消息，则将消息解析委托给父级public static final String MESSAGE_SOURCE_BEAN_NAME = "messageSource";protected void initMessageSource() {// 此处得到的beanFactory 是DefaultListableBeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();// 判断本地beanFactory是否含有beanName为messageSource的beanif (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {// 本地beanFactory含有beanName为messageSource的bean，直接从beanFactory里获取this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);// 使MessageSource知道父MessageSourceif (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;if (hms.getParentMessageSource() == null) {// 仅当尚未注册父MessageSource时，才将父上下文设置为父MessageSourcehms.setParentMessageSource(getInternalParentMessageSource());}}if (logger.isTraceEnabled()) {logger.trace("Using MessageSource [" + this.messageSource + "]");}} else {// 使用空MessageSource接收getMessage调用DelegatingMessageSource dms = new DelegatingMessageSource();// 将父上下文设置为父MessageSource,此处为nulldms.setParentMessageSource(getInternalParentMessageSource());this.messageSource = dms;// 注册messageSource单例对象beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);// 日志记录if (logger.isTraceEnabled()) {logger.trace("No '" + MESSAGE_SOURCE_BEAN_NAME + "' bean, using [" + this.messageSource + "]");}}}

获取beanFactory ，此处得到的是DefaultListableBeanFactory
判断beanFactory本地工厂是否含有beanName为messageSource的bean，如果含有就从beanFactory里获取，否则就创建一个空MessageSource，并且注册单例对象到beanFactory

五、初始化SimpleApplicationEventMulticaster

此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext

 // 工厂中ApplicationEventMulticaster(应用程序事件广播器) bean的名称// 如果未提供，则使用默认的SimpleApplicationEventMulticastpublic static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";protected void initApplicationEventMulticaster() {// 此处得到的beanFactory 是DefaultListableBeanFactoryConfigurableListableBeanFactory beanFactory = getBeanFactory();// 判断本地beanFactory是否含有beanName为applicationEventMulticaster的beanif (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {// 含有就直接从beanFactory里获取this.applicationEventMulticaster =beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);if (logger.isTraceEnabled()) {logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");}} else {// 不含有就创建SimpleApplicationEventMulticaster，并且注册单例对象this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);// 日志记录if (logger.isTraceEnabled()) {logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");}}}

获取beanFactory ，此处得到的是DefaultListableBeanFactory
判断beanFactory本地工厂是否含有beanName为applicationEventMulticaster的bean，如果含有就从beanFactory里获取，否则就创建一个SimpleApplicationEventMulticaster，并且注册单例对象到beanFactory

结语

本文主要是解读了调用后处理器及注册拦截bean创建的后处理器，是非常核心的内容，讲的主要是流程，关于后处理器的具体操作，讲完这个刷新流程，我后面会分单节去解读，期待您的关注。