「这是我参与11月更文挑战的第8天，活动详情查看：2021最后一次更文挑战」
1.前言
本篇文章是续接上篇文章Spring IOC容器初始化原理分析 (第一节）的，如有疑惑可先看下上篇，或者找我探讨都可以。
2.refresh() 源码续讲
这里就贴张图吧，如果需要复制代码，可前往Spring IOC容器初始化原理分析 (第一节）
3. 方法 2.4 postProcessBeanFactory 详解
这个方法官方的定义是：在应用程序上下文的标准初始化之后修改其内部bean工厂。将加载所有bean定义，但还没有实例化bean。这允许在特定的ApplicationContext实现中注册特殊的BeanPostProcessors等
它在 org.springframework.context.support.AbstractApplicationContext 中默认是一个空实现，源码如下
这个类主要是spring官方交给我们自定义去扩展的，可以实现一些自定义的功能，这里我们就不自定义了，看一下通常web项目下即（AbstractRefreshableWebApplicationContext）默认实现
protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
//添加ServletContextAwareProcessor后置处理器
//实现ServletContextAwareProcessor即可 取得servletContext
beanFactory.addBeanPostProcessor(new ServletContextAwareProcessor(this.servletContext, this.servletConfig));
//忽略自动注入，对于自动装配，忽略给定的依赖接口。
beanFactory.ignoreDependencyInterface(ServletContextAware.class);
beanFactory.ignoreDependencyInterface(ServletConfigAware.class);
//注册web
WebApplicationContextUtils.registerWebApplicationScopes(beanFactory, this.servletContext);
//注册和上下文环境相关的bean
WebApplicationContextUtils.registerEnvironmentBeans(beanFactory, this.servletContext, this.servletConfig);
}
4. 方法（ 2.5 invokeBeanFactoryPostProcessors） 详解
这个方法主要的作用就是：实例化和调用所有已注册的BeanFactoryPostProcessor ，按照指定的顺序（即BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类，在执行时，会比BeanFactoryPostProcessor先执行。）
BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在单例bean实例化之前，读取它的配置信息，并可以修改它。
源代码如下：
- 它的核心方法就是 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()) ，在讲他之前 我们先讲一下 getBeanFactoryPostProcessors()
- 后面的if代码块： 判断如果当前beanFactory的临时类加载器为null且beanFactory包含loadTimeWeaver这个bean 就给它添加一个LoadTimeWeaverAwareProcessor处理器，设置一下默认的临时类加载器
- 首先先讲一下 getBeanFactoryPostProcessors() 方法
这个方法的作用主要是：获取自定义的beanFactoryPostProcessor。何为自定义？ 即不通过注解（如 @Autowired)形式扫描获取，而是通过手动context.addBeanFactoryPostProcessor(beanFactoryPostProcessor)完成自定义，默认该列表为null
- 然后我们再来着重分析下 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()) 这个方法
当前的beanFactory 默认是 DefaultListableBeanFactory 至于为啥是这个，上一讲我已经讲过了，这里看一下它的继承关系图，方便下面我们源码分析用。 图一如下：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
Set<String> processedBeans = new HashSet<>();
//判断是否含有BeanDefinitionRegistry这个类型的，如过是则进入，默认情况下是DefaultListableBeanFactory
//如图一可知，它实现了BeanDefinitionRegistry
if (beanFactory instanceof BeanDefinitionRegistry) {
//转成BeanDefinitionRegistry类型
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 记录通过硬编码方式注册的BeanFactoryPostProcessor 类型的处理器
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 记录通过硬编码方式注册的BeanDefinitionRegistryPostProcessor 类型的处理器
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//遍历beanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
//判断是否属于BeanDefinitionRegistryPostProcessor
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 在应用程序上下文的标准初始化之后修改其内部bean定义注册表。将加载所有常规bean定义，但还没有实例化bean。
//仅对 BeanDefinitionRegistry 子类的BeanFactory 起作用
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
//不要在这里初始化FactoryBeans：我们需要保留所有常规Bean
// uninitialized to let the bean factory post-processors apply to them!
//未初始化以让bean工厂后处理器应用于它们
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
// 记录通过配置方式注册的 BeanDefinitionRegistryPostProcessor 类型的处理器
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 首先，调用实现PriorityOrdered的BeanDefinitionRegistryPostProcessor。
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
//获取所有 属于BeanDefinitionRegistryPostProcessor该类型的 beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
//判断它是否实现了PriorityOrdered
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 记录到currentRegistryProcessors中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 对currentRegistryProcessors里面的元素进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//registryProcessors中保存了所有执行过 postProcessBeanDefinitionRegistry方法的bean，
//现在再来执行这些currentRegistryProcessors 中所有bean 的 postProcessBeanDefinitionRegistry 方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空 currentRegistryProcessors
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
//这个和上面的一样只不过把 PriorityOrdered.class换成了Ordered.class这样就保证了 他们的执行顺序 PriorityOrdered, Ordered, and the rest.（ps:最先执行的是BeanDefinitionRegistryPostProcessor，然后在是它们）
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
//最后，调用所有其他的BeanDefinitionRegistryPostProcessors，直到没有调用为止
boolean reiterate = true;
while (reiterate) {
reiterate = false;
//这里获取所有没有实现排序的 BeanDefinitionRegistryPostProcessor 调用它们的 postProcessBeanDefinitionRegistry 方法 进行激活
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);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
// 到这里，所有的 BeanDefinitionRegistryPostProcessor 的postProcessBeanDefinitionRegistry 都已经激活结束，开始激活 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// registryProcessors 记录的是硬编码注入的BeanDefinitionRegistryPostProcessor，这里激活的是 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
// 至此处理完beanFactory是这种类型BeanDefinitionRegistry
}
else {
// Invoke factory processors registered with the context instance.
//调用注册到上下文实例的工厂处理程序。
//当 beanFactory instanceof BeanDefinitionRegistry = false，即
BeanDefinitionRegistryPostProcessor.的postProcessBeanDefinitionRegistry 并不生效，就直接激活postProcessBeanFactory方法即可。
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!
//获取所有的后置处理器的beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
//创建不同的排序集合，按照PriorityOrdered、Ordered、默认 这样的顺序调用
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
// 如果processedBeans包含这个ppName，说明已经处理过了 此处跳过即可
}
// 否则判断它们实现的排序类型，分别加到对应的list中去
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 这里是先排序，然后先执行实现了PriorityOrdered的BeanFactoryPostProcess
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
//处理实现了 Ordered接口的BeanFactoryPostProcess
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
// 最后处理默认的
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
// 清除缓存
beanFactory.clearMetadataCache();
}
5 小结
- BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 区别：
-
它们都属于Spring的后置处理器，可以实现它们以达到动态注册bean定义，动态修改bean定义，以及动态修改bean。
-
BeanDefinitionRegistryPostProcessor 的postProcessBeanDefinitionRegistry 方法针对是BeanDefinitionRegistry类型的ConfigurableListableBeanFactory，可以实现对BeanDefinition的增删改查等操作，但是对于非 ConfigurableListableBeanFactory 类型的BeanFactory，并不起作用。
-
BeanFactoryPostProcessor .postProcessBeanFactory 针对的是所有的BeanFactory。
-
postProcessBeanDefinitionRegistry 的调用时机在postProcessBeanFactory 之前。
-
心理小得 刚开始看这个方法，确实挺长的，吓我一跳，后面慢慢花时间，一点一点去啃，最终也算是把它大概弄懂了，其中有不对的地方，欢迎大家指出来。下一篇将着重讲解 2.6 registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) 方法
