- 一、背景
- 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
@Override
public 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创建的BeanPostProcessor
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 为此上下文初始化消息源，也就是注册DelegatingMessageSource
initMessageSource();
// 为此上下文初始化事件multicaster
initApplicationEventMulticaster();
// 初始化特定上下文子类中的其他特殊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创建的BeanPostProcessor
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 为此上下文初始化消息源，也就是注册DelegatingMessageSource
initMessageSource();
// 为此上下文初始化事件multicaster
initApplicationEventMulticaster();
// 后面省略，本文解读到此处
} 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 beanFactoryPostProcessors) {
// 定义Set集合processedBeans
Set processedBeans = new HashSet<>();
// beanFactory 就是DefaultListableBeanFactory,它实现了接口BeanDefinitionRegistry
// 故此处是BeanDefinitionRegistry的实例
if (beanFactory instanceof BeanDefinitionRegistry) {
// 转为BeanDefinitionRegistry
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 定义BeanFactoryPostProcessor列表
List regularPostProcessors = new ArrayList<>();
// 定义BeanDefinitionRegistryPostProcessor列表，属于BeanDefinitionRegistryPostProcessor的实例的
List registryProcessors = new ArrayList<>();
// 从上一步我们知道beanFactoryPostProcessors有两个：
// CachingmetadataReaderFactoryPostProcessor 和 ConfigurationWarningsPostProcessor
// 开始遍历后置处理器beanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 都实现了BeanDefinitionRegistryPostProcessor接口
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 转为BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
// 调用后置处理器的postProcessBeanDefinitionRegistry
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 加入到BeanDefinitionRegistryPostProcessor列表
registryProcessors.add(registryProcessor);
} else {
// 加入到BeanFactoryPostProcessor列表
regularPostProcessors.add(postProcessor);
}
}
// 定义当前调用的BeanDefinitionRegistryPostProcessor列表
// 同样不要在这里初始化FactoryBeans：需要确保所有常规Bean未初始化以使beanFactory后处理器应用于它们
List currentRegistryProcessors = new ArrayList<>();
// 首先，调用实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor
String[] 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集合processedBeans
processedBeans.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集合processedBeans
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 把当前实现了Ordered接口BeanDefinitionRegistryPostProcessor列表都加入到BeanDefinitionRegistryPostProcessor列表
registryProcessors.addAll(currentRegistryProcessors);
// 循环调用postProcessBeanDefinitionRegistry()方法（实现了Ordered接口）
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 清空当前调用的BeanDefinitionRegistryPostProcessor列表
currentRegistryProcessors.clear();
// 最后，调用所有没有实现PriorityOrdered接口或Ordered接口的BeanDefinitionRegistryPostProcessor
boolean 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 priorityOrderedPostProcessors = new ArrayList<>();
List orderedPostProcessorNames = new ArrayList<>();
List 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接口的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 接下来
List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
// 通过beanFactory和后处理器名称获取后处理器（实现Ordered接口），并添加到列表
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 对实现了Ordered接口的后处理器进行排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 调用实现Ordered接口的BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后
// 调用所有其他BeanFactoryPostProcessor
List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
// 通过beanFactory和后处理器名称获取后处理器，并添加到列表
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 调用所有其他BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(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 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 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 的内部类）
这里先找出所有实现BeanDefinitionRegistryPostProcessor类的对象，然后分成三类进行解析调用。我这里整理了，也把结果贴出来了。
2.5.1、实现了PriorityOrdered- ConfigurationClassPostProcessor
没有获取到
2.5.3、没实现排序没有获取到
2.5.4、结果到这里时此步骤得到的结果（registryProcessors）如下：
- CachingmetadataReaderFactoryPostProcessor（ SharedmetadataReaderFactoryContextInitializer 的内部类）
- ConfigurationWarningsPostProcessor（ConfigurationWarningsApplicationContextInitializer 的内部类）
- ConfigurationClassPostProcessor
同样的这里先找出所有实现BeanFactoryPostProcessor类的对象，然后分成三类进行解析调用。这里我也整理了，也把结果贴出来了。
2.6.1、实现了PriorityOrdered- PropertySourcesPlaceholderConfigurer
- DependsOnDatabaseInitializationPostProcessor（DatabaseInitializationDependencyConfigurer的内部类）
- EventListenerMethodProcessor
- PreserveErrorControllerTargetClassPostProcessor（ErrorMvcAutoConfiguration的内部类）
- ClassProxyingConfiguration（AopAutoConfiguration的内部类）
此方法所在类的具体路径：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=6
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 再加一个BeanPostProcessor，此时是5个了
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// 在实现PriorityOrdered、Ordered和rest的BeanPostProcessor之间进行分离。
List priorityOrderedPostProcessors = new ArrayList<>();
List internalPostProcessors = new ArrayList<>();
List orderedPostProcessorNames = new ArrayList<>();
List nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 实现了PriorityOrdered接口，获取对应的BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 加入到列表priorityOrderedPostProcessors
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessors
internalPostProcessors.add(pp);
}
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 实现了Ordered接口，加入到列表orderedPostProcessorNames
orderedPostProcessorNames.add(ppName);
} else {
// 都没有实现，加入到列表nonOrderedPostProcessorNames
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先，对实现了PriorityOrdered接口的BeanPostProcessor进行处理
// 排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 注册实现PriorityOrdered的BeanPostProcessor
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 接下来，对实现了Ordered接口的BeanPostProcessor进行处理
List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String ppName : orderedPostProcessorNames) {
// 根据名称获取实现了Ordered接口的BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 加入到列表orderedPostProcessors
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessors
internalPostProcessors.add(pp);
}
}
// 排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 注册实现Ordered的BeanPostProcessor
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// 然后，对所有常规BeanPostProcessor进行注册
List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String ppName : nonOrderedPostProcessorNames) {
// 根据名称获取常规的BeanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
// 加入到列表nonOrderedPostProcessors
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
// 如果是MergedBeanDefinitionPostProcessor的实例，加入到列表internalPostProcessors
internalPostProcessors.add(pp);
}
}
// 注册所有常规BeanPostProcessor
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// 最后，重新注册所有内部BeanPostProcessor
// 排序
sortPostProcessors(internalPostProcessors, beanFactory);
// 重新注册所有内部BeanPostProcessor
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// 添加ApplicationListenerDetector，将用于检测内部bean的后处理器重新注册为ApplicationListener
beanFactory.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, List3.3、BeanPostProcessor类postProcessors) { // 是否是AbstractBeanFactory的实例 if (beanFactory instanceof AbstractBeanFactory) { // 批量添加 ((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors); } else { // 遍历后单个添加 for (BeanPostProcessor postProcessor : postProcessors) { beanFactory.addBeanPostProcessor(postProcessor); } } }
其实这里的流程和之前是查不多的，大家需要关注的是他们的结果值，那将是后面解析的核心内容。
3.3.1、实现了PriorityOrdered- ConfigurationPropertiesBindingPostProcessor
- CommonAnnotationBeanPostProcessor
- AutowiredAnnotationBeanPostProcessor
- InfrastructureAdvisorAutoProxyCreator
- WebServerFactoryCustomizerBeanPostProcessor
- ErrorPageRegistrarBeanPostProcessor
- CommonAnnotationBeanPostProcessor
- AutowiredAnnotationBeanPostProcessor
- 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 是DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断本地beanFactory是否含有beanName为messageSource的bean
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
// 本地beanFactory含有beanName为messageSource的bean，直接从beanFactory里获取
this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
// 使MessageSource知道父MessageSource
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
if (hms.getParentMessageSource() == null) {
// 仅当尚未注册父MessageSource时，才将父上下文设置为父MessageSource
hms.setParentMessageSource(getInternalParentMessageSource());
}
}
if (logger.isTraceEnabled()) {
logger.trace("Using MessageSource [" + this.messageSource + "]");
}
} else {
// 使用空MessageSource接收getMessage调用
DelegatingMessageSource dms = new DelegatingMessageSource();
// 将父上下文设置为父MessageSource,此处为null
dms.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
此方法所在类的具体路径：org.springframework.context.support.AbstractApplicationContext
// 工厂中ApplicationEventMulticaster(应用程序事件广播器) bean的名称
// 如果未提供，则使用默认的SimpleApplicationEventMulticast
public static final String APPLICATION_EVENT_MULTICASTER_BEAN_NAME = "applicationEventMulticaster";
protected void initApplicationEventMulticaster() {
// 此处得到的beanFactory 是DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
// 判断本地beanFactory是否含有beanName为applicationEventMulticaster的bean
if (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创建的后处理器，是非常核心的内容，讲的主要是流程，关于后处理器的具体操作，讲完这个刷新流程，我后面会分单节去解读，期待您的关注。
