一、前言
本方法会实例化和调用所有 BeanFactoryPostProcessor（包括其子类 BeanDefinitionRegistryPostProcessor）。
BeanFactoryPostProcessor 接口是 Spring 初始化 BeanFactory 时对外暴露的扩展点，Spring IoC 容器允许 BeanFactoryPostProcessor 在容器实例化任何 bean 之前读取 bean 的定义，并可以修改它。
BeanDefinitionRegistryPostProcessor 继承自 BeanFactoryPostProcessor，比 BeanFactoryPostProcessor 具有更高的优先级，主要用来在常规的 BeanFactoryPostProcessor 检测开始之前注册其他 bean 定义。特别是，你可以通过 BeanDefinitionRegistryPostProcessor 来注册一些常规的 BeanFactoryPostProcessor，因为此时所有常规的 BeanFactoryPostProcessor 都还没开始被处理。
注：这边的 “常规 BeanFactoryPostProcessor” 主要用来跟 BeanDefinitionRegistryPostProcessor 区分。
二、正文
首先我们回到 AbstractApplicationContext.refresh() 方法,找到代码：invokeBeanFactoryPostProcessors(beanFactory) ,单击该行代码跳转到具体的实现.
// AbstractApplicationContext 类中的方法
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 1、getBeanFactoryPostProcessors():获取 IOC 容器中所有的 BeanFactoryPostProcessors ---- (详情见代码块一)
// 2、invokeBeanFactoryPostProcessors:调用所有的 BeanFactoryPostProcessor ---- (详情见代码块二)
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
代码块一、getBeanFactoryPostProcessors()
// AbstractApplicationContext 类中的方法
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
默认情况下, return this.beanFactoryPostProcessors 返回的 size 是 0 ,因为我们没有向 IOC 容器中添加任何的 BeanFactoryPostProcessor
那么我们应该怎么添加 BeanFactoryPostProcessor 到 IOC 容器中呢?
在容器刷新容器之前有一个初始化的操作,customizeContext 方法,该方法是 Spring 提供给开发者的一个扩展点,用于自定义应用上下文,并且在 refresh() 方法前就被调用.在这边就可以通过该方法来添加自定义的 BeanFactoryPostProcessor.
在自定义 BeanFactoryPostProcessor 之前,我们先看一个类 BeanDefinitionRegistryPostProcessor ,这个类会在后面的步骤中使用到
从上面的代码中我们可以看到 BeanDefinitionRegistryPostProcessor 是 BeanFactoryPostProcessor 的一个子接口,在调用 BeanFactoryPostProcessor 之前会先调用 BeanDefinitionRegistryPostProcessor
1、自定义 MyBeanFactoryPostProcessor 实现 BeanFactoryPostProcessor 接口
2、自定义 MyBeanDefinitionRegistryPostProcessor 实现 BeanDefinitionRegistryPostProcessor 接口
3、自定义类 SpringApplicationContextInitializer 实现 ApplicationContextInitializer 接口,并且添加自定义的 MyBeanFactoryPostProcessor 和 MyBeanDefinitionRegistryPostProcessor 到 IOC 容器中
4、web.xml 中配置 SpringApplicationContextInitializer
完成上述配置之后我们可以看到我们自定义的 MyBeanFactoryPostProcessor 和 MyBeanDefinitionRegistryPostProcessor 就添加到了 IOC 容器中了(XmlWebApplicationContext)
代码块二、
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
// 1、初始化一个 Set 集合 processedBeans
Set<String> processedBeans = new HashSet<String>();
// 2、这里的 beanFactory 是 DefaultListableBeanFactory ,它实现了 BeanDefinitionRegistry 接口,所以判断条件为 true
if (beanFactory instanceof BeanDefinitionRegistry) {
// 2.1、将 beanFactory(DefaultListableBeanFactory) 向上转型
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 2.2、创建一个 List 集合用来存放 BeanFactoryPostProcessor 的实现类
List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
// 2.3、创建一个 List 集合用来存放 BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryPostProcessors =
new LinkedList<BeanDefinitionRegistryPostProcessor>();
// 2.4、循环遍历所有的 BeanFactoryPostProcessor
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 2.4.1、如果当前的 BeanFactoryPostProcessor 是 BeanDefinitionRegistryPostProcessor 接口的实现类
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 2.4.2、向上转型为 BeaDefinitionRegistryPostProcessor
BeaDefinitionRegistryPostProcessor registryPostProcessor
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 2.4.3、回调 BeanDefinitionRegistryPostProcessor 接口的实现类的 postProcessBeanDefinitionRegistry 方法
registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
// 2.4.4、将当前 BeanDefinitionRegistryPostProcessor 存放到 List<BeanDefinitionRegistryPostProcessor> 集合中
registryPostProcessors.add(registryPostProcessor);
}
else {
// 2.4.5、将非 BeanDefinitionRegistryPostProcessor 的实现类存放到 List<BeanFactoryPostProcessor> 集合中
// (用于最后执行 postProcessBeanFactory 方法)
regularPostProcessors.add(postProcessor);
}
}
// 3、调用所有的实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessors
// 3.1、获取 beanFactory 中所有的 BeanDefinitionRegistryPostProcessor 类型的 beanName
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 3.2、创建一个集合用来存放实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessors
List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
// 3.3、循环遍历
for (String ppName : postProcessorNames) {
// 3.4、判断是否实现了 PriorityOrdered 接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 3.5、获取 ppName 对应的 bean 实例,,添加到集合 currentRegistryProcessors 中
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 3.6、将要被执行的加入集合 processedBeans,避免后续重复执行
processedBeans.add(ppName);
}
}
// 3.7、进行排序(根据是否实现 PriorityOrdered 接口和 order 值来进行排序) ---- (详细见代码块三)
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 3.8、添加到 registryProcessors (用于最后执行 postProcessBeanFactory 方法)
registryPostProcessors.addAll(priorityOrderedPostProcessors);
// 3.9、遍历所有实现了 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 的实现类
// 然后调用各个实现了的 postProcessBeanDefinitionRegistry() 方法
invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
// 4、调用所有的实现了 Ordered 接口的 BeanDefinitionRegistryPostProcessors,和上面实现了 PriorityOrdered 接口一样
// PriorityOrdered 接口是 Ordered 的子接口,所以会先调用子接口,然后再调用 Ordered 接口
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
List<BeanDefinitionRegistryPostProcessor> orderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(beanFactory, orderedPostProcessors);
registryPostProcessors.addAll(orderedPostProcessors);
invokeBeanDefinitionRegistryPostProcessors(orderedPostProcessors, registry);
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
// 5、然后执行剩余的 BeanDefinitionRegistryPostProcessors (没有实现 PriorityOrdered 接口和 Ordered 接口的),知道没有新的出现
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
BeanDefinitionRegistryPostProcessor pp = beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class);
registryPostProcessors.add(pp);
processedBeans.add(ppName);
pp.postProcessBeanDefinitionRegistry(registry);
reiterate = true;
}
}
}
// 6、回调所有实现了 BeanDefinitionRegistryPostProcessor 的实现类的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(registryPostProcessors, beanFactory);
// 7、回调所有实现了 BeanFactoryPostProcessor 的实现类的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 到这里为止,入参 beanFactoryPostProcessors 和容器中的所有 BeanDefinitionRegistryPostProcessor 已经全部处理完毕.
// 下面开始处理容器中的所有 BeanFactoryPostProcessor
// 8、找出所有实现 BeanFactoryPostProcessor 接口的类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 8.1、存放所有实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
// 8.2、存放所有实现了 Ordered 接口的 BeanFactoryPostProcessor
List<String> orderedPostProcessorNames = new ArrayList<String>();
// 8.3、存放未实现 Ordered 及 Ordered 子接口的普通 BeanFactoryPostProcessor
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
// 8.4、循环遍历
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
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.
// 8.5、对所有实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor 排序
sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
// 8.6、回调所有的 priorityOrderedPostProcessors 的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 8.7、对所有实现了 Ordered 接口的 BeanFactoryPostProcessor 排序
sortPostProcessors(beanFactory, orderedPostProcessors);
// 8.8、遍历 orderedPostProcessors,回调 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanFactoryPostProcessor>();
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 8.9、回调普通的 BeanFactoryPostProcessor 的 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
// 8.10、清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType）
// 因为后处理器可能已经修改了原始元数据,例如:替换值中的占位符...
beanFactory.clearMetadataCache();
}
代码块三、sortPostProcessors
private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
Comparator<Object> comparatorToUse = null;
if (beanFactory instanceof DefaultListableBeanFactory) {
// 1、获取设置的比较器
comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
}
if (comparatorToUse == null) {
// 2、如果没有设置比较器,则使用默认的 OrderComparator
comparatorToUse = OrderComparator.INSTANCE;
}
// 3、使用比较器对 postProcessors 进行排序
Collections.sort(postProcessors, comparatorToUse);
}
三、总结
invokeBeanFactoryPostProcessors 方法的内容其实比较少，大部分过程在代码块2的注释都已经写清楚，这边在稍微总结一下。
1.整个 invokeBeanFactoryPostProcessors 方法围绕两个接口，BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor，其中 BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor 。BeanDefinitionRegistryPostProcessor 主要用来在常规 BeanFactoryPostProcessor 检测开始之前注册其他 Bean 定义，说的简单点，就是 BeanDefinitionRegistryPostProcessor 具有更高的优先级，执行顺序在 BeanFactoryPostProcessor 之前。
2.整个 invokeBeanFactoryPostProcessors 方法操作了 3 种 bean 对象：
- 入参 beanFactoryPostProcessors：这个我们在代码块1中解析过，拿的是 AbstractApplicationContext 类的 beanFactoryPostProcessors 属性值，也就是在之前已经添加到 beanFactoryPostProcessors 中的 BeanFactoryPostProcessor。
- BeanDefinitionRegistryPostProcessor 接口实现类：实现了 BeanDefinitionRegistryPostProcessor 接口，并且注册到 Spring IoC容器中。
- 常规 BeanFactoryPostProcessor 接口实现类：实现了 BeanFactoryPostProcessor 接口，并且注册到 Spring IoC容器中。
3.操作3种 bean 对象具体指的是调用它们重写的方法，调用实现方法时会遵循以下的优先级：
- 第一优先级：入参 beanFactoryPostProcessors 中的 BeanDefinitionRegistryPostProcessor， 调用 postProcessBeanDefinitionRegistry 方法（2.1.1）。
- 第二优先级：BeanDefinitionRegistryPostProcessor 接口实现类，并且实现了 PriorityOrdered 接口，调用 postProcessBeanDefinitionRegistry 方法（3.8）。
- 第三优先级：BeanDefinitionRegistryPostProcessor 接口实现类，并且实现了 Ordered 接口，调用 postProcessBeanDefinitionRegistry 方法（4.2）。
- 第四优先级：除去第二优先级和第三优先级，剩余的 BeanDefinitionRegistryPostProcessor 接口实现类，调用 postProcessBeanDefinitionRegistry 方法（5.4）。
- 第五优先级：所有 BeanDefinitionRegistryPostProcessor 接口实现类，调用 postProcessBeanFactory 方法（6）。
- 第六优先级：入参 beanFactoryPostProcessors 中的常规 BeanFactoryPostProcessor，调用 postProcessBeanFactory 方法（7）。
- 第七优先级：常规 BeanFactoryPostProcessor 接口实现类，并且实现了 PriorityOrdered 接口，调用 postProcessBeanFactory 方法（9.2）。
- 第八优先级：常规 BeanFactoryPostProcessor 接口实现类，并且实现了 Ordered 接口，调用 postProcessBeanFactory 方法（10.3）。
- 第九优先级：除去第七优先级和第八优先级，剩余的常规 BeanFactoryPostProcessor 接口的实现类，调用 postProcessBeanFactory 方法（11.2）。
4.本文还引入了两个用于排序的重要接口：PriorityOrdered 和 Ordered，其中 PriorityOrdered 继承了 Ordered，并且 PriorityOrdered 的优先级要高于 Ordered，这跟 BeanDefinitionRegistryPostProcessor 继承 BeanFactoryPostProcessor 有点类似。实现 Ordered 接口需要重写 getOrder 方法，返回一个用于排序的 order 值，order 值的范围为 Integer.MIN_VALUE ~ Integer.MAX_VALUE，order 值越小优先级越高，Integer.MIN_VALUE 拥有最高优先级，而 Integer.MAX_VALUE 则对应的拥有最低优先级。
5.常见的 Java EE 相关的框架或者中间件，经常使用 BeanFactoryPostProcessor 来进行扩展，例如上面的 Mybatis，因此了解 BeanFactoryPostProcessor 的原理会对之后理解其他中间件的原理有帮助。
差不多看懂了,有点细节没仔细看,以后再来翻