本人本科毕业，21届毕业生，一年工作经验，简历专业技能如下，现根据简历，并根据所学知识复习准备面试。
记录日期：2022.1.4
大部分知识点只做大致介绍，具体内容根据推荐博文链接进行详细复习。
文章目录
框架原理 - Spring（七）之Spring IOC 源码invokeBeanFactoryPostProcessors()
AbstractApplicationContext#invokeBeanFactoryPostProcessors()
我们来看一下代码实现：
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
// 1. getBeanFactoryPostProcessors()：拿到当前应用上下文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 (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}
getBeanFactoryPostProcessors()
这里getBeanFactoryPostProcessors()会拿到当前应用上下文中已经注册的 BeanFactoryPostProcessor，在默认情况下，this.beanFactoryPostProcessors是返回空的。
private final List<BeanFactoryPostProcessor> beanFactoryPostProcessors = new ArrayList<>();
public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
return this.beanFactoryPostProcessors;
}
那么如果我们自己想添加一个BeanFactoryPostProcessor到beanFactory中的话，如下所示。
我们可以在refresh方法之前去添加一个自定义的**BeanFactoryPostProcessor** 到容器中，通常来讲有两种方式：
- 通过注解的方式，将自己实现的
beanFactoryPostProcessor注册到beanFactory中。
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("postProcessBeanFactory");
}
}
- 新建一个
ApplicationContextInitializer的实现类SpringApplicationContextInitializer，并在initialize()方法中写我们的逻辑。
此时我们是通过web容器初始化的时候去做的添加，就要去掉 @Component 注解。
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("postProcessBeanFactory");
}
}
然后在SpringApplicationContextInitializer 中addBeanFactoryPostProcessor()。
public class SpringApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
public void initialize(ConfigurableApplicationContext context) {
MyBeanFactoryPostProcessor myBeanFactoryPostProcessor = new MyBeanFactoryPostProcessor();
context.addBeanFactoryPostProcessor(myBeanFactoryPostProcessor);
}
}
将 SpringApplicationContextInitializer 作为初始化参数 contextInitializerClasses 配置到 web.xml 中。
<context-param>
<param-name>contextInitializerClasses</param-name>
<param-value>com.test.SpringApplicationContextInitializer</param-value>
</context-param>
invokeBeanFactoryPostProcessors()
用于执行BeanFactoryPostProcessors的方法。
我们来看一下代码实现：
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
/*【警告注释翻译】 警告：尽管此方法的主体似乎可以很容易地重构，以避免使用多个循环和多个列表， 但在处理器名称上使用多个列表和多次传递是有意的。 我们必须确保遵守优先订购和订购处理器的合同。 具体来说，我们不能导致处理器被实例化（通过getBean（）调用）或以错误的顺序在ApplicationContext中注册。 在提交更改此方法的请求请求（PR）之前， 请查看所有涉及对后处理程序RegistrationLegate进行更改的被拒绝的PR列表， 以确保您的提案不会导致重大更改： https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22 */
// 首先调用BeanDefinitionRegistryPostProcessors，如果存在的话。
// 前面说过了BeanDefinitionRegistryPostProcessors，它是BeanFactoryPostProcessor的子类
// 执行优先级高
Set<String> processedBeans = new HashSet<>();
// 1. 判断 beanFctory 是否为 BeanDefinitionRegistry
// beanFctory 为 DefaultListableBeanFactory
// 而 DefaultListableBeanFactory 实现了 BeanDefinitionRegistry 接口，所以为true
if (beanFactory instanceof BeanDefinitionRegistry) {
// 进行类型转换 BeanDefinitionRegistry
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 用于存放普通的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 用于存放 BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 2. 首先处理入参的 beanFactoryPostProcessors
// 遍历所有的 beanFactoryPostProcessors
// 将 BeanDefinitionRegistryPostProcessor 和 普通的 BeanFactoryPostProcessor 区分开
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
// 2.1 判断是 BeanDefinitionRegistryPostProcessor 的话
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
// 进行类型转换BeanDefinitionRegistryPostProcessor
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
// 2.1.1 直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
registryProcessor.postProcessBeanDefinitionRegistry(registry);
// 2.1.2 添加到registryProcessors（用于最后执行postProcessBeanFactory方法）
registryProcessors.add(registryProcessor);
}
else {
// 2.2 否则就是普通的 BeanFactoryPostProcessor
// 2.2.1 添加到regularPostProcessors（用于最后执行postProcessBeanFactory方法）
regularPostProcessors.add(postProcessor);
}
}
/*【注释翻译】 不要在这里初始化FactoryBeans：我们需要让所有常规bean保持未初始化状态， 以便让bean factory后处理器应用于它们！ 在实现PriorityOrdered、Ordered和rest的BeanDefinitionRegistryPostProcessor之间进行分离。 */
// 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 【注释翻译】首先，调用实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
// 3. 调用所有实现 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor 实现类
// 3.1 找出实现 BeanDefinitionRegistryPostProcessor 接口的 bean 的 beanName
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 3.2 遍历 postProcessorNames
for (String ppName : postProcessorNames) {
// 3.3 校验是否实现了PriorityOrdered接口
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 3.4 获取ppName对应的bean实例，添加到currentRegistryProcessors中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 3.5 将要被执行的加入processedBeans，避免后续重复执行
processedBeans.add(ppName);
}
}
// 3.6 进行排序（根据PriorityOrdered、Order接口和order值来排序）
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 3.7 添加到registryProcessors（同上）
registryProcessors.addAll(currentRegistryProcessors);
// 3.8 遍历执行currentRegistryProcessors中所有BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 3.9 执行完毕后，清空currentRegistryProcessors
currentRegistryProcessors.clear();
// 【注释翻译】接下来，调用实现Ordered的BeanDefinitionRegistryPostProcessor
// 4. 调用所有实现了Ordered的BeanDefinitionRegistryPostProcessor（步骤和3相同）
// 4.1 找出所有实现了BeanDefinitionRegistryPostProcessor接口的类，这边重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor，可能会新增加了其他的BeanDefinitionRegistryPostProcessor，因此需要重新查找
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 4.2 遍历postProcessorNames
for (String ppName : postProcessorNames) {
// 4.3 检验是否是 未执行过 并且 实现了Ordered接口
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 4.4 获取ppName对应的bean实例，添加到currentRegistryProcessors中
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 4.5 将要被执行的加入processedBeans，避免后续重复执行
processedBeans.add(ppName);
}
}
// 同上...
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 同上...
registryProcessors.addAll(currentRegistryProcessors);
// 同上...
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 同上...
currentRegistryProcessors.clear();
// 【注释翻译】最后，调用所有其他BeanDefinitionRegistryPostProcessor，直到不再出现其他BeanDefinitionRegistryPostProcessor
// 5. 最后调用所有剩下的BeanDefinitionRegistryPostProcessors
boolean reiterate = true;
while (reiterate) {
reiterate = false;
// 5.1 找出所有实现了BeanDefinitionRegistryPostProcessor接口的类
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
// 5.2 遍历
for (String ppName : postProcessorNames) {
// 5.3 跳过已执行过的
if (!processedBeans.contains(ppName)) {
// 5.4 添加到currentRegistryProcessors
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
// 5.5 添加到processedBeans
processedBeans.add(ppName);
// 5.6 如果有BeanDefinitionRegistryPostProcessor被执行了，则有可能产生新的BeanDefinitionRegistryPostProcessor
// 所以这边要将reiterate设置为true，代表需要再循环遍历一次
reiterate = true;
}
}
// 同上...
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 同上...
registryProcessors.addAll(currentRegistryProcessors);
// 同上...
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 同上...
currentRegistryProcessors.clear();
}
// 【注释翻译】现在，调用到目前为止处理的所有处理器的postProcessBeanFactory回调
// 6. 调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
// （前面说过，BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor）
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
// 7. 最后，调用所有入参BeanFactoryPostProcessor的postProcessBeanFactory()方法
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// 当没有实现了 BeanDefinitionRegistry 接口时
// 【注释翻译】调用在上下文实例中注册的工厂处理器
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 【注释翻译】不要在这里初始化FactoryBeans：我们需要让所有常规bean保持未初始化状态，以便让bean factory后处理器应用于它们！
// 到此为止时，我们已经处理完了：
// 入参的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
// 容器中的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
// 所有的BeanDefinitionRegistryPostProcessor的postProcessBeanFactory()方法
// 入参的BeanFactoryPostProcessor的postProcessBeanFactory()方法
// 下面开始处理容器中的所有的BeanFactoryPostProcessor
// 8. 找出所有BeanFactoryPostProcessor接口的类
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 【注释翻译】在实现PriorityOrdered、Ordered和rest的BeanFactory后处理器之间进行分离。
// 用于存放实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 用于存放实现了 Ordered 接口的BeanFactoryPostProcessor的beanName
List<String> orderedPostProcessorNames = new ArrayList<>();
// 用于存放普通的BeanFactoryPostProcessor的beanName
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 8.1 遍历postProcessorNames，将BeanFactoryPostProcessor按实现了PriorityOrdered接口、实现Ordered接口、普通三种分开
for (String ppName : postProcessorNames) {
// 8.1.1 跳过已经执行过的
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
// 8.1.2 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
// 8.1.3 添加实现了Ordered接口的BeanFactoryPostProcessor
orderedPostProcessorNames.add(ppName);
}
else {
// 8.1.4 添加普通的BeanFactoryPostProcessor
nonOrderedPostProcessorNames.add(ppName);
}
}
// 【注释翻译】首先，调用实现PriorityOrdered的BeanFactoryPostProcessor
// 9.调用所有实现了 PriorityOrdered 接口的 BeanFactoryPostProcessor
// 9.1 对priorityOrderedPostProcessors排序
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 9.2 遍历 priorityOrderedPostProcessors 执行 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 【注释翻译】接下来，调用实现Ordered的BeanFactoryPostProcessor
// 10. 调用所有实现了 Ordered 接口的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
// 根据postProcessorName获取对应bean实例，添加到orderedPostProcessors，准备执行
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 10.1 对orderedPostProcessors排序
sortPostProcessors(orderedPostProcessors, beanFactory);
// 10.2 遍历 orderedPostProcessors 执行 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 【注释翻译】最后，调用所有其他BeanFactoryPostProcessor
// 11. 调用剩下的 BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
// 根据postProcessorName获取对应bean实例，添加到nonOrderedPostProcessors，准备执行
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 11.1 不排序了，直接遍历 nonOrderedPostProcessors 执行 postProcessBeanFactory() 方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 【注释翻译】清除缓存的合并bean定义，因为后处理器可能修改了原始元数据，例如替换值中的占位符。。。
// 清楚元数据缓存（mergedBeanDefinitions、allBeanNameByType、singletonBeanNamesByType），
// 因为后处理器可能已经修改了原始元数据，例如替换值中的占位符等......
beanFactory.clearMetadataCache();
}
到此为止，所有实现了 BeanFactoryPostProcessor 接口的 Bean都已经被执行了。
我们再来关注一下 invokeBeanFactoryPostProcessors() 里面几个常出现的方法。
sortPostProcessors()：用来对postProcessors集合进行排序。
private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
// Nothing to sort?
if (postProcessors.size() <= 1) {
return;
}
Comparator<Object> comparatorToUse = null;
if (beanFactory instanceof DefaultListableBeanFactory) {
// 获取设置的比较器
comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
}
if (comparatorToUse == null) {
// 如果没有设置比较器，则使用默认的OrderComparator
comparatorToUse = OrderComparator.INSTANCE;
}
// 使用比较器对postProcessors进行排序。
postProcessors.sort(comparatorToUse);
}
默认情况下，比较器为 OrderComparator，如果配置了 annotation-config，并且值为true，使用的是 AnnotationAwareOrderComparator，AnnotationAwareOrderComparator 继承自 OrderComparator，只是重写了部分方法。
我们来看一下OrderComparator的代码实现：
public class OrderComparator implements Comparator<Object> {
public static final OrderComparator INSTANCE = new OrderComparator();
@Override
public int compare(@Nullable Object o1, @Nullable Object o2) {
return doCompare(o1, o2, null);
}
private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
// 判断o1是否实现了PriorityOrdered接口
boolean p1 = (o1 instanceof PriorityOrdered);
// 判断o2是否实现了PriorityOrdered接口
boolean p2 = (o2 instanceof PriorityOrdered);
// 如果o1实现了PriorityOrdered接口, 而o2没有, 则o1排前面
if (p1 && !p2) {
return -1;
}
// 如果o2实现了PriorityOrdered接口, 而o1没有, 则o2排前面
else if (p2 && !p1) {
return 1;
}
// 如果o1和o2都实现（都没实现）PriorityOrdered接口，走到下面
// 拿到o1的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
int i1 = getOrder(o1, sourceProvider);
// 拿到o2的order值, 如果没实现Ordered接口, 值为Ordered.LOWEST_PRECEDENCE
int i2 = getOrder(o2, sourceProvider);
// 通过order值(order值越小, 优先级越高)排序
return Integer.compare(i1, i2);
}
}
比较器的逻辑很简单，实现 PriorityOrdered 接口的优先级最高，如果两个对象都实现（都没实现）PriorityOrdered 接口，则根据 order 值（实现 Ordered 接口时，需要实现 getOrder() 方法，返回 order 值）来进行比较，order 值越小，优先级越高。
总结执行顺序
首先BeanDefinitionRegistryPostProcessor 具有更高的优先级，执行顺序在 BeanFactoryPostProcessor 之前。
方法中主要处理的是三大对象：
- 入参
beanFactoryPostProcessors BeanDefinitionRegistryPostProcessor接口实现类- 常规
BeanFactoryPostProcessor接口实现类
执行的优先顺序如下：
- 第一优先级：入参
beanFactoryPostProcessors中的BeanDefinitionRegistryPostProcessor， 调用postProcessBeanDefinitionRegistry方法。 - 第二优先级：
BeanDefinitionRegistryPostProcessor接口实现类，并且实现了PriorityOrdered接口，调用postProcessBeanDefinitionRegistry方法。 - 第三优先级：
BeanDefinitionRegistryPostProcessor接口实现类，并且实现了Ordered接口，调用postProcessBeanDefinitionRegistry方法。 - 第四优先级：除去第二优先级和第三优先级，剩余的
BeanDefinitionRegistryPostProcessor接口实现类，调用postProcessBeanDefinitionRegistry方法。 - 第五优先级：所有
BeanDefinitionRegistryPostProcessor接口实现类，调用postProcessBeanFactory方法。 - 第六优先级：入参
beanFactoryPostProcessors中的常规BeanFactoryPostProcessor，调用postProcessBeanFactory方法。 - 第七优先级：常规
BeanFactoryPostProcessor接口实现类，并且实现了PriorityOrdered接口，调用postProcessBeanFactory方法。 - 第八优先级：常规
BeanFactoryPostProcessor接口实现类，并且实现了 Ordered 接口，调用postProcessBeanFactory方法。 - 第九优先级：除去第七优先级和第八优先级，剩余的常规
BeanFactoryPostProcessor接口的实现类，调用postProcessBeanFactory方法。
京公网安备 11010502036488号