invokeBeanFactoryPostProcessors是Spring启动中一个十分重要的方法，在解析这个方法的源码之前首先我们需要先了解几个概念。
一、BeanDefinition
1.1、普通对象的实例化
我们知道普通的java文件在java运行时会先编译成.class的文件加载到jvm内存中，当我们使用的时候通过new去实例化获取到一个对象，具体如下：
1.2、Spring中bean的实例化
在Spring中实例化一个对象和普通的java文件还是有所不同的，他引入了一个BeanDefinition对象，BeanDefinition是一个接口，他的主要作用是去描述java对象的一些信息的，包括是否是单例、java对象中的方法、属性等等，可以看作是另一个.class对象。BeanDefinition的继承关系图如下：
从图上我们可以得知BeanDefinition的主要由一下几种实现：
- GenericBeanDefinition : 通用的bean实现，自2.5以后新加入的bean文件配置属性定义类，是ChildBeanDefinition和RootBeanDefinition更好的替代者；
- ScannedGenericBeanDefinition : 被包扫描到的bean定义；
- AnnotatedGenericBeanDefinition : 查找类注解初始化的定义；
- RootBeanDefinition : 代表一个从配置源（XML，Java Config等）中生成的BeanDefinition
- ChildBeanDefinition : 可以从父BeanDefinition中集成构造方法，属性等。
Spring的实例化过程可以参考下图：
具体的流程和源码解析可以看我的另一篇文章【Spring】Spring中的三级缓存及循环依赖的问题
这里就不在详细对比和赘述了。
二、invokeBeanFactoryPostProcessors
invokeBeanFactoryPostProcessors的源码在org.springframework.context.support.AbstractApplicationContext#invokeBeanFactoryPostProcessors里，解合我们之前提到的关于BeanDefinition的概念，具体解析如下：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory{
/**
* 此处通过反射调用了BeanFctory后置处理器
* 调用循序为：1.bean定义注册后置处理器，2.bean工厂后置处理器
* 也会调用getBean、doGetBean、createBean、doCreateBean等创建bean的过程
* 注意：getBeanFactoryPostProcessors是初始化对象，里面没有内容
*/
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); // ===>
//检测是否存在loadTimeWeaver
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}从上面代码可以看到，invokeBeanFactoryPostProcessors里面主要实现是PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());这行代码，那么其中又做了些什么呢，我们继续看下去。
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//保存所有后置处理器bean名称的集合
Set<String> processedBeans = new HashSet();
//BeanFactoryPostProcessor集合
ArrayList regularPostProcessors;
//BeanDefinitionRegistryPostProcessor集合
ArrayList registryProcessors;
int var9;
ArrayList currentRegistryProcessors;
String[] postProcessorNames;
//beanFactoryPostProcessors分为BeanFactoryPostProcessor集合与BeanDefinitionRegistryPostProcessor集合
//1.判断beanFactory是否为BeanDefinitionRegistry，普通的beanFactory是DefaultListableBeanFactory,而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry)beanFactory;
regularPostProcessors = new ArrayList();
registryProcessors = new ArrayList();
Iterator var6 = beanFactoryPostProcessors.iterator();
//2.处理入参beanFactoryPostProcessors
while(var6.hasNext()) {
BeanFactoryPostProcessor postProcessor = (BeanFactoryPostProcessor)var6.next();
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor)postProcessor;
//如果是BeanDefinitionRegistryPostProcessor则直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
} else {
regularPostProcessors.add(postProcessor);
}
}
currentRegistryProcessors = new ArrayList();
//3.找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
String[] var16 = postProcessorNames;
var9 = postProcessorNames.length;
int var10;
String ppName;
for(var10 = 0; var10 < var9; ++var10) {
ppName = var16[var10];
//校验是否实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
//获取对应的bean实例, 添加到currentRegistryProcessors中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
//排序(根据是否实现PriorityOrdered(优先顺序)、Ordered(顺序)接口和order(再次之)值来排序)
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
//清空currentRegistryProcessors
currentRegistryProcessors.clear();
//4.与上边3的流程差不多，这是这里处理的是实现Ordered接口
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
var16 = postProcessorNames;
var9 = postProcessorNames.length;
for(var10 = 0; var10 < var9; ++var10) {
ppName = var16[var10];
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();
//5.调用所有剩下的BeanDefinitionRegistryPostProcessors
boolean reiterate = true;
while(reiterate) {
reiterate = false;
//找出所有实现BeanDefinitionRegistryPostProcessor接口的类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
String[] var19 = postProcessorNames;
var10 = postProcessorNames.length;
for(int var26 = 0; var26 < var10; ++var26) {
String ppName = var19[var26];
//跳过已经执行过的
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
//6.遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
//7.调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)registryProcessors, (ConfigurableListableBeanFactory)beanFactory);
//8.最后, 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
} else {
invokeBeanFactoryPostProcessors((Collection)beanFactoryPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
}
//到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕
//下面开始处理容器中的所有BeanFactoryPostProcessor
//9.找出所有实现BeanFactoryPostProcessor接口的类
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
//用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
regularPostProcessors = new ArrayList();
//用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
registryProcessors = new ArrayList();
//用于存放普通BeanFactoryPostProcessor的beanName
currentRegistryProcessors = new ArrayList();
postProcessorNames = postProcessorNames;
int var20 = postProcessorNames.length;
String ppName;
for(var9 = 0; var9 < var20; ++var9) {
ppName = postProcessorNames[var9];
//跳过已经执行过的，遍历，并将BeanFactoryPostProcessor按照实现不同接口添加到对应的集合中
if (!processedBeans.contains(ppName)) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
regularPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
} else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
registryProcessors.add(ppName);
} else {
currentRegistryProcessors.add(ppName);
}
}
}
//10.调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
//10.1对priorityOrderedPostProcessors排序
sortPostProcessors(regularPostProcessors, beanFactory);
//10.2遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)regularPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList();
Iterator var21 = registryProcessors.iterator();
while(var21.hasNext()) {
String postProcessorName = (String)var21.next();
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
//10.3对orderedPostProcessors排序
sortPostProcessors(orderedPostProcessors, beanFactory);
//10.4遍历orderedPostProcessors排序，执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)orderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
// 11.调用所有剩下的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList();
Iterator var24 = currentRegistryProcessors.iterator();
while(var24.hasNext()) {
ppName = (String)var24.next();
// 11.1获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors, 准备执行
nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 11.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
invokeBeanFactoryPostProcessors((Collection)nonOrderedPostProcessors, (ConfigurableListableBeanFactory)beanFactory);
// 12.清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType），
// 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
beanFactory.clearMetadataCache();
}由上方源码解析可知，在invokeBeanFactoryPostProcessors方法中有个条件，如果传入的beanFactory是BeanDefinitionRegistry，其主要流程如下：
- 遍历传入的BeanFactoryPostProcessor集合，查找类型是BeanDefinitionRegistryPostProcessor并执行，然后添加到集合中；
- 在容器中查找所有的实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor集合，对后置处理器集合排序，遍历；
- 在容器中查找所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理的postProcessBeanDefinitionRegistry方法；
- 在容器中查找其它（未实现排序接口）的BeanDefinitionRegistryPostProcessor并添加到集合nonOrderedPostProcessors中，对后置处理器集合排序，遍历，执行后置处理的postProcessBeanDefinitionRegistry方法；
- 当前所有的BeanDefinitionRegistryPostProcessor处理器的方法postProcessBeanDefinitionRegistry 执行完毕后，执行其父类postProcessBeanFactory方法；
- 执行所有非BeanDefinitionRegistryPostProcessor类型的后置处理器的postProcessBeanFactory方法。
如果是传入的beanFactory不是BeanDefinitionRegistry，其主要流程如下：
- 遍历传入的BeanFactoryPostProcessor集合，执行后置处理器的postProcessBeanFactory方法；
- 在容器中（beanFactory.getBeanNamesForType）查找所有的实现了PriorityOrdered接口的BeanFactoryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理；
- 在容器中查找所有实现了Ordered接口的BeanFactoryPostProcessor集合，对后置处理器集合排序，遍历，执行后置处理；
- 在容器中查找其它（未实现排序接口）的BeanFactoryPostProcessor并添加到集合nonOrderedPostProcessors中，对后置处理器集合排序，遍历，执行后置处。
- 注意：Spring中的BeanFactoryPostProcessor实现有多个，每个实现都有不同的作用大家可以自己翻下源码梳理，我们也可以自己实现BeanFactoryPostProcessor。
虽然invokeBeanFactoryPostProcessors中内容很多，但仔细阅读源码可以发现，整个方法主要是围绕BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor两个接口来展开的，其主要作用有以下几点：
- 处理入参beanFactoryPostProcessors(默认是空的)中的BeanFactoryPostProcessor，即执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法；
- 处理容器中所有的BeanDefinitionRegistryPostProcessor；
- 处理容器中剩余的所有BeanFactoryPostProcessor。
