Spring IOC 初始化刷新流程五：invokeBeanFactoryPostProcessors(beanFactory)

Spring IOC 初始化刷新流程：https://www.cnblogs.com/jhxxb/p/13609289.html

这一步主要实例化并执行已经在容器中注册过了的 BeanFactory 后置处理器(BeanFactoryPostProcessor)

Bean 工厂：DefaultListableBeanFactory

方法源码

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
        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)
        // 这里就是定制：如果 loadTimeWeaver 这个 Bean 存在，那么就会配置上运行时织入的处理器 LoadTimeWeaverAwareProcessor
        if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
            beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
            beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
        }
    }

    // 不是返回 Spring 容器里面的 Processors，而是自己注册的（手动 set 的），也就是说我们自己手动调用 set 方法添加进去，就能够执行。并不需要自己配置 @Bean 或者在 xml 里配置
    public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
        return this.beanFactoryPostProcessors;
    }

invokeBeanFactoryPostProcessors()

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

        // Invoke BeanDefinitionRegistryPostProcessors first, if any.
        // 这个 doc 说明很清楚：不管怎么样，先执行 BeanDefinitionRegistryPostProcessors
        // 需要注意的是 BeanDefinitionRegistryPostProcessors 为 BeanFactoryPostProcessor 的子接口，它新增了方法：void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)
        // BeanFactoryPostProcessor 的方法为 void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
        // 所以 BeanDefinitionRegistryPostProcessors 也改变 Bean 的一些定义信息
        Set<String> processedBeans = new HashSet<>();

        // 只有此 beanFactory 是 BeanDefinitionRegistry 才能执行 BeanDefinitionRegistryPostProcessor，才能修改 Bean 的定义
        if (beanFactory instanceof BeanDefinitionRegistry) {
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            // 此处安放了两个容器，一个装载普通的 BeanFactoryPostProcessor
            // 另外一个装载和 Bean 定义有关的 BeanDefinitionRegistryPostProcessor
            // 另外都是 ArrayList，所以执行顺序和 set 进去的顺序是一致的
            List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
            List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

            // 这里是我们自己的 set 进去的，若没 set，这里就是空(若是 Sprng 容器里的，下面会处理)
            // 从此处可以看出，我们手动 set 进去的，最优先执行
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                    BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
                    // 这里执行 post 方法，然后把它缓存起来，放在 registryProcessors 里
                    registryProcessor.postProcessBeanDefinitionRegistry(registry);
                    registryProcessors.add(registryProcessor);
                } else {
                    // 缓冲起来常规的处理器
                    regularPostProcessors.add(postProcessor);
                }
            }

            // Do not initialize FactoryBeans here: We need to leave all regular beans
            // uninitialized to let the bean factory post-processors apply to them!
            // Separate between BeanDefinitionRegistryPostProcessors that implement
            // PriorityOrdered, Ordered, and the rest.
            // 接下来，就是去执行 Spring 容器里面的一些 PostProcessor。他们顺序 doc 里也写得很清楚：
            // 先执行实现了 PriorityOrdered 接口的，然后是 Ordered 接口的，最后执行剩下的
            List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

            // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
            // 先从容器中拿出来所有的 BeanDefinitionRegistryPostProcessor，然后先执行 PriorityOrdered
            // 本例中有一个这个类型的处理器：ConfigurationClassPostProcessor（显然是处理 @Configuration 这种 Bean 的）
            // 至于这个 Bean 是什么时候注册进去的，前面有。在 loadBeanDefinitions() 初始化 AnnotatedBeanDefinitionReader 的时候，
            // 调用了 AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry) 方法，注册了 6 个 Bean
            String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
                    currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                    // processedBeans 也顺带保存了一份，保存的是 bean 的 Name
                    processedBeans.add(ppName);
                }
            }
            // 排序
            sortPostProcessors(currentRegistryProcessors, beanFactory);
            // 此处缓存起来（需要注意的是，是排序后，再放进去的，这样是最好的）
            registryProcessors.addAll(currentRegistryProcessors);
            // 这个方法很简单，就是吧 currentRegistryProcessors 里面所有的处理器 for 循环，一个个的执行掉(本处只有 ConfigurationClassPostProcessor)
            invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
            // 此处把当前持有的执行对象给清空了，需要注意。以方便装载后续执行的处理器们
            currentRegistryProcessors.clear();

            // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
            // 此处逻辑完全同上，处理实现 Order 接口的 RegistryProcessors
            postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
            for (String ppName : postProcessorNames) {
                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();

            // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
            // 最后执行，两个排序接口都没有实现的 BeanDefinitionRegistryPostProcessor 们，并且也缓存起来
            boolean reiterate = true;
            while (reiterate) {
                reiterate = false;
                postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
                for (String ppName : postProcessorNames) {
                    if (!processedBeans.contains(ppName)) {
                        currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                        processedBeans.add(ppName);
                        reiterate = true;
                    }
                }
                sortPostProcessors(currentRegistryProcessors, beanFactory);
                registryProcessors.addAll(currentRegistryProcessors);
                invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
                currentRegistryProcessors.clear();
            }

            // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
            // 现在，这里很明显：去执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法
            // 以及顶层接口 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法
            // 我们当前环境 regularPostProcessors 长度为 0，registryProcessors 有一个解析 @Configuration 的处理器
            invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
            invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        } else {
            // Invoke factory processors registered with the context instance.
            // 若是普通的 Bean 工厂，就直接执行 set 进来的后置处理器即可（因为容器里就没有其它 Bean 定义了）
            invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let the bean factory post-processors apply to them!
        // 下面就是开始执行 BeanFactoryPostProcessor，基本也是按照上面的顺序来执行的
        // 本次这里 2 个 Bean，也就 ConfigurationClassPostProcessor 是实现了此接口的。因此本环境下，只有它了，并且它在上面还已经执行了
        String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

        // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
        // Ordered, and the rest.
        List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
        List<String> orderedPostProcessorNames = new ArrayList<>();
        List<String> nonOrderedPostProcessorNames = new ArrayList<>();
        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.
        sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

        // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
        List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
        for (String postProcessorName : orderedPostProcessorNames) {
            orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
        }
        sortPostProcessors(orderedPostProcessors, beanFactory);
        invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

        // Finally, invoke all other BeanFactoryPostProcessors.
        List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
        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();
    }

至此，invokeBeanFactoryPostProcessors(beanFactory) 这一步就完成了。

Bean 工厂已经准备完毕，注册好了所有 Bean 的定义信息（此时 Bean 还并没有创建）。也完成了对配置文件的解析，可以说 Spring IOC 容器的大的准备工作已经完成了，接下来就是对 Bean 的一些初始化、以及操作

postProcessBeanDefinitionRegistry 和 postProcessBeanFactory 方法：两者都存在于 BeanDefinitionRegistryPostProcessor 接口中，表明其既可以自定义 BeanDefinition 并注册进容器中，也可以对 beanFactory 修改。

为什么要先执行 BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry 然后在执行 BeanFactoryPostProcessor#postProcessBeanFactory 呢？

因为 postProcessBeanDefinitionRegistry 是用来创建 bean 定义的，而 postProcessBeanFactory 是修改 BeanFactory，当然 postProcessBeanFactory 也可以修改 bean 定义。

为了保证在修改之前所有的 bean 定义都存在，所以优先执行 postProcessBeanDefinitionRegistry。如不是以上顺序，会出现在修改某个 bean 定义的时候报错，因为此 bean 的定义还没有被创建。

这一步主要做了：

执行了 BeanDefinitionRegistryPostProcessor（此处只有ConfigurationClassPostProcessor）

执行了 BeanFactoryPostProcessor

完成了 @Configuration 配置文件的解析，并且把扫描到的、配置的 Bean 定义信息都加载进容器里

Full 模式下，完成了对 @Configuration 配置文件的加强，使得管理 Bean 依赖关系更加的方便了

这里注册 Bean 定义的时候有个小细节：Spring 支持 FactoryBean 模式，所以这里如果发现注册的 Bean 为 FactoryBean 类型的话，会把自己以及 getObject() 出来的对象的 Bean 定义都注册进去。

并且 FactoryBean 的名称为：beanName = FACTORY_BEAN_PREFIX + beanName

---

https://blog.csdn.net/f641385712/article/details/88095165