流程图

代码

1. public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
2.    Set<String> processedBeans = new HashSet<>();
3.    // beanFactory 默认使用的是 DefaultListableBeanFactory，属于 BeanDefinitionRegistry
4.    if (beanFactory instanceof BeanDefinitionRegistry) {
5.        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
6.        // 两个后处理器列表
7.        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
8.        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
9.        // 硬编码注册的后处理器
10.        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
11.            // 分类处理
12.        }
13.        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
14.        // 首先，调用实现 priorityOrder 的 beanDefinition 这就是前面提到过的优先级概念，这一步跟下面的优先级不一样之处，这一步的优先级是带有权重
15.        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
16.        for (String ppName : postProcessorNames) {
17.            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
18.                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
19.                processedBeans.add(ppName);
20.            }
21.        }
22.        // 对后处理器进行排序
23.        sortPostProcessors(currentRegistryProcessors, beanFactory);
24.        registryProcessors.addAll(currentRegistryProcessors);
25.        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
26.        currentRegistryProcessors.clear();
27.        // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
28.        postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
29.        for (String ppName : postProcessorNames) {
30.            if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
31.                currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
32.                processedBeans.add(ppName);
33.            }
34.        }
35.        sortPostProcessors(currentRegistryProcessors, beanFactory);
36.        registryProcessors.addAll(currentRegistryProcessors);
37.        // 执行 definitionRegistryPostProcessor 接口的方法 ：postProcessBeanDefinitionRegistry
38.        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
39.        currentRegistryProcessors.clear();
40.        // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.最后，调用所有其他后处理器，直到不再出现其他 bean 为止
41.        boolean reiterate = true;
42.        while (reiterate) {
43.            reiterate = false;
44.            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
45.            for (String ppName : postProcessorNames) {
46.                if (!processedBeans.contains(ppName)) {
47.                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
48.                    processedBeans.add(ppName);
49.                    reiterate = true;
50.                }
51.            }
52.            sortPostProcessors(currentRegistryProcessors, beanFactory);
53.            registryProcessors.addAll(currentRegistryProcessors);
54.            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
55.            currentRegistryProcessors.clear();
56.        }
57.        // 执行 postProcessBeanFactory 回调方法
58.        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
59.        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
60.    }
61.    else {
62.        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
63.    }
64.    // 不要在这里初始化 factoryBean:我们需要保留所有常规 bean 未初始化，以便让 bean 工厂后处理程序应用于它们
65.    // 注释 6.4 在这个步骤中，我们自定义的 carBeanFactoryPostProcessor 才真正注册并执行
66.    String[] postProcessorNames =
67.            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);.
68.    // 跳过分类的逻辑
69.    // 首先执行的是带有权重顺序的后处理器
70.    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
71.    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
72.    // 下一步执行普通顺序的后处理器
73.    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
74.    for (String postProcessorName : orderedPostProcessorNames) {
75.        orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
76.    }
77.    sortPostProcessors(orderedPostProcessors, beanFactory);
78.    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
79.    // 最后执行的是普通的后处理器
80.    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
81.    for (String postProcessorName : nonOrderedPostProcessorNames) {
82.        nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
83.    }
84.    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
85.    // 清除缓存的合并bean定义，因为后处理程序可能已经修改了原始元数据，例如替换值中的占位符
86.    beanFactory.clearMetadataCache();
87. }

从上面贴的代码中能够看到，对于 beanFactoryPostProcessor 的处理主要分两种情况：

• beanFactory 是 BeanDefinitionRegistry 类型：需要特殊处理
• beanFactory 不是 BeanDefinitionRegistry 类型：进行普通处理

对于每种情况都需要考虑硬编码注入注册的后处理器（上面已经提到如何进行硬编码）以及通过配置注入的后处理器

对于 BeanDefinitionRegistry 类型的处理器的处理主要包括以下内容：

1. 处理硬编码注册的后处理器
2. 记录后处理器主要使用以下三个 List

• registryPostProcessors：记录通过硬编码方式注册的 BeanDefinitionRegistryPostProcessor
• regularPostProcessors：记录通过硬编码方式注册的 BeanFactoryPostProcessor
• regitstryPostProcessorBeans：记录通过配置方式注册的 BeanDefinitionRegistryPostProcessor

3. 对于以上后处理器列表，统一调用 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法
4. 对 beanFactoryPostProcessors 中非 BeanDefinitionRegistryPostProcessor 类型的后处理器进行统一的 postProcessBeanFactory 方法
5. 普通 beanFactory 处理：其实在这一步中，就是忽略了 BeanDefinitionRegistryPostProcessor 类型，对BeanFactoryPostProcessor 进行直接处理。

流程图中描述了整体调用链路，具体调用方法在代码中的注释也描述出来了，所以结合起来看应该能够理解整体流程~

总结

本次分析了 beanFactory 的后处理器 BeanFactoryPostProcessor，了解了 Spring 给我们提供的这个扩展接口使用用途和在源码中如何进行激活执行。

由于个人技术有限，如果有理解不到位或者错误的地方，请留下评论，我会根据朋友们的建议进行修正

代码和注释都在里面，小伙伴们可以下载我上传的代码，亲测可运行~

Gitee 地址：https://gitee.com/vip-augus/spring-analysis-note.git

Github 地址：https://github.com/Vip-Augus/spring-analysis-note

参考资料

1. Bean 定义
2. Sping 的 BeanFactory 容器
3. Spring拓展接口之BeanFactoryPostProcessor，占位符与敏感信息解密原理