前言

BeanFactoryPostProcessor,我们都知道是一个工厂后置处理器,是Spring容器级别的,就是用来修改Spring扫描我们的包后生成BeanDefinitionMap后执行实现BeanFactoryPostProcessor接口重写的postProcessBeanFactory方法!

@Service
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
for (String beanDefinitionName:beanDefinitionNames){
System.out.println(beanDefinitionName);
//BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
//beanDefinition.setBeanClassName();
}
}
}

也就是说我们的Bean实现了BeanFactoryPostProcessor接口后,Spring启动后,解析构建生成BeanDefinitionMaps后,就会获取我们生成好的BeanDefinitionMaps中所有的Bean是否实现了BeanFactoryPostProcessor接口,然后将这些实现了BeanFactoryPostProcessor的BeanDefinition存入为nonOrderedPostProcessorNames的集合中,然后循环nonOrderedPostProcessorNames集合,并完成这些Bean的初始化操作,然后将这些实现了BeanFactoryPostProcessor接口的Bean初始化好add添加到nonOrderedPostProcessors集合中,然后循环nonOrderedPostProcessors调用当前Bean的postProcessBeanFactory方法!那么也就是执行了我们实现BeanFactoryPostProcessor接口后重写的postProcessBeanFactory方法!

源码分析

public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {


Set<String> processedBeans = new HashSet<>();

//判断我们的beanFactory是否实现了BeanDefinitionRegistry
if (beanFactory instanceof BeanDefinitionRegistry) {
//强行把beanFactory转为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;
//调用它的后置方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
//添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中
registryProcessors.add(registryProcessor);
}
else {
//若没有实现BeanDefinitionRegistryPostProcessor接口,那么他就是BeanFactoryPostProcessor 把当前的后置处理器加入到regularPostProcessors中
regularPostProcessors.add(postProcessor);
}
}

//定义一个集合用户保存当前准备创建的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

//第一步:去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//判断是否实现了PriorityOrdered接口的
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//同时也加入到processedBeans集合中去
processedBeans.add(ppName);
}
}
//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序,排序完后通过引用传递还是给了currentRegistryProcessors
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把他加入到用于保存到registryProcessors中
registryProcessors.addAll(currentRegistryProcessors);
//在这里典型的BeanDefinitionRegistryPostProcessor就是ConfigurationClassPostProcessor用于进行bean定义的加载 比如我们的包扫描,@import等
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//调用完之后,马上clear
currentRegistryProcessors.clear();

//下一步 又去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//表示没有被处理过,且实现了Ordered接口的
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//同时也加入到processedBeans集合中去
processedBeans.add(ppName);
}
}
//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把他加入到用于保存到registryProcessors中
registryProcessors.addAll(currentRegistryProcessors);
//调用他的后置处理方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//调用完之后,马上clear
currentRegistryProcessors.clear();

//调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor
//定义一个重复处理的开关变量 默认值为true
boolean reiterate = true;
//第一次就可以进来
while (reiterate) {
//进入循环马上把开关变量给改为false
reiterate = false;
//去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称
for (String ppName : postProcessorNames) {
//没有被处理过的
if (!processedBeans.contains(ppName)) {
//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
//同时也加入到processedBeans集合中去
processedBeans.add(ppName);
//再次设置为true
reiterate = true;
}
}
//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
//把他加入到用于保存到registryProcessors中
registryProcessors.addAll(currentRegistryProcessors);
//调用他的后置处理方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//进行clear
currentRegistryProcessors.clear();
}

//调用实现了BeanDefinitionRegistryPostProcessor的接口 他是他也同时实现了BeanFactoryPostProcessor的方法
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
//调用BeanFactoryPostProcessor
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}

else {//若当前的beanFactory没有实现了BeanDefinitionRegistry 直接调用beanFactoryPostProcessor接口的方法进行后置处理
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}

//最后一步 获取容器中所有的 BeanFactoryPostProcessor
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

//保存BeanFactoryPostProcessor类型实现了priorityOrdered
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
//保存BeanFactoryPostProcessor类型实现了Ordered接口的
List<String> orderedPostProcessorNames = new ArrayList<>();
//保存BeanFactoryPostProcessor没有实现任何优先级接口的
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
//processedBeans包含的话,表示在上面处理BeanDefinitionRegistryPostProcessor的时候处理过了
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
//判断是否实现了PriorityOrdered
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
//判断是否实现了Ordered
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
//没有实现任何的优先级接口的
else {
nonOrderedPostProcessorNames.add(ppName);
}
}

//先调用BeanFactoryPostProcessor实现了PriorityOrdered接口的
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

//再调用BeanFactoryPostProcessor实现了Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

//调用没有实现任何方法接口的
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
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();
}

这里别看代码行数挺多的,我们这里切块分析!

初始化

Set<String> processedBeans = new HashSet<>();

processedBeans 实际上就是存储已经执行过invokeBeanDefinitionRegistryPostProcessors的BeanName

BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();

regularPostProcessors 实际上是存储实现了BeanFactoryPostProcessor接口的Bean

List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

registryProcessors 实际上是存储实现了BeanDefinitionRegistryPostProcessor接口的Bean

循环beanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_sed


这里循环的beanFactoryPostProcessors的size其实是0,所以这里并没有真正执行里面的判断逻辑,里面其实就是区分beanFactoryPostProcessors的item是否实现了BeanDefinitionRegistryPostProcessor的接口或者实现了BeanFactoryPostProcessor接口!

创建要执行invokeBeanDefinitionRegistryPostProcessors方法的集合

BeanFactoryPostProcessor源码分析_spring_02

第一次执行invokeBeanDefinitionRegistryPostProcessors

BeanFactoryPostProcessor源码分析_sed_03


获取postProcessorNames

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

getBeanNamesForType方法的第一个参数是根据类型,第二个参数是否单例,第三个参数是否初始化获取,根据这些参数在BeanDefinitionNames中获取符合条件的Bean的name,此时是从BeanDefinitionNames获取的就是实现了BeanDefinitionRegistryPostProcessor的Beans,​​注意此时的BeanDefinitionNames中还只有Spring启动默认依赖的一些Bean​​,最后得到postProcessorNames 也就只有ConfigurationClassPostProcessor这一项

循环postProcessorNames

这里循环postProcessorNames的item,找到实现了PriorityOrdered接口的item,那么ConfigurationClassPostProcessor又刚好实现了PriorityOrdered接口

BeanFactoryPostProcessor源码分析_初始化_04


然后将当前项通过beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)创建出来后添加到currentRegistryProcessors和processedBeans中

排序
sortPostProcessors(currentRegistryProcessors, beanFactory);

添加
registryProcessors.addAll(currentRegistryProcessors);

执行
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
​​​这次执行完成扫描包,得到Bean,解析成BeanDefinitionMap的操作​

清空
currentRegistryProcessors.clear();
currentRegistryProcessors这个集合后面还要继续利用

第二次执行invokeBeanDefinitionRegistryPostProcessors

BeanFactoryPostProcessor源码分析_spring_05


获取postProcessorNames

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

此时还是从BeanDefinitionNames中获取实现了BeanDefinitionRegistryPostProcessor接口是单例,并且没有初始化的beans,​​注意此时的BeanDefinitionNames中已经将我们自己写的Bean扫描进去了​​ 但是此时得到的还是只有ConfigurationClassPostProcessor符合条件

BeanFactoryPostProcessor源码分析_spring_06


但是循环中if判断条件不满足

if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}

所以currentRegistryProcessors为空!那么下面这些代码都是空执行!

sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();

最后一次执行invokeBeanDefinitionRegistryPostProcessors

BeanFactoryPostProcessor源码分析_spring_07


获取postProcessorNames

postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);

此时依然只有ConfigurationClassPostProcessor符合条件符合条件!但是if判断如下!

if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}

然而processedBeans中在第一次执行invokeBeanDefinitionRegistryPostProcessors的步骤中就已经将ConfigurationClassPostProcessor添加到了processedBeans,所以一下代码也是空执行!

sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();

第一次执行invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_spring_08


此处调用的是循环registryProcessors集合中的item,然后调用item的postProcessBeanFactory方法!那么registryProcessors中存在一个item,也就是ConfigurationClassPostProcessor,是在第一次执行invokeBeanDefinitionRegistryPostProcessors的时候添加进去的

第二次执行invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_spring_09


这次调用其实是空执行!因为regularPostProcessors自始至终都是没有添加item的

数据收集

BeanFactoryPostProcessor源码分析_sed_10


这里显示从BeanDefinitionName是中获取所有实现了BeanFactoryPostProcessor接口的Beans然后通过for迭代postProcessorNames根据if判断将这些实现了BeanFactoryPostProcessor的Beans分为3类,实现了PriorityOrdered的初始化好后存放到priorityOrderedPostProcessors中,实现了Ordered的存放到orderedPostProcessorNames中,二者都没有实现的存放到nonOrderedPostProcessorNames中

第三次执行invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_spring_11


这次执行的是实现了BeanFactoryPostProcessor和PriorityOrdered的Bean的postProcessBeanFactory方法

第四次执行invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_初始化_12

这里循环了orderedPostProcessorNames然后初始化每一个item同时添加给了orderedPostProcessors,那么此时invokeBeanFactoryPostProcessors执行的就是实现了BeanFactoryPostProcessor和Ordered接口的Bean的postProcessBeanFactory方法

最后一次执行invokeBeanFactoryPostProcessors

BeanFactoryPostProcessor源码分析_spring_13


这里循环了nonOrderedPostProcessorNames然后初始化每一个item同时添加给了nonOrderedPostProcessors,那么此时invokeBeanFactoryPostProcessors的就是实现了BeanFactoryPostProcessor接口欧的Bean的postProcessBeanFactory方法,那么文章开始的实例代码中重写的postProcessBeanFactory就是在这里调用的