invokeBeanFactoryPostProcessors(beanFactory)；方法详解

在 Spring 容器的启动过程中，invokeBeanFactoryPostProcessors(beanFactory) 是一个非常关键的步骤，它负责调用所有已注册的 BeanFactoryPostProcessor，允许我们在 Bean 实例化之前对 Bean 的定义（BeanDefinition）进行修改。本文将基于 Spring 5.x 源码，详细解析该方法的执行逻辑。

1. 方法调用入口

invokeBeanFactoryPostProcessors(beanFactory) 定义在 AbstractApplicationContext 抽象类中，并在 refresh() 容器刷新方法中被调用：

java 复制代码

// AbstractApplicationContext.java
@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        // ... 其他准备工作
        // 实例化并调用所有注册的 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactory);
        // ... 后续步骤
    }
}

此时，容器的 BeanFactory 已经创建并加载了所有 Bean 定义（通过 BeanDefinitionReader 等），但尚未实例化任何单例 Bean。BeanFactoryPostProcessor 可以在此阶段对 BeanDefinition 进行修改，例如添加属性、替换实现类等。

2. 实际执行委托

AbstractApplicationContext 并未直接实现逻辑，而是将调用委托给 PostProcessorRegistrationDelegate 类的静态方法：

java 复制代码

// AbstractApplicationContext.java
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
}

beanFactory：当前的 ConfigurableListableBeanFactory 实例。
getBeanFactoryPostProcessors()：返回通过 addBeanFactoryPostProcessor() 手动添加的处理器（即应用程序上下文中已经注册的处理器，而不是从 Bean 定义中发现的）。

3. `PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors` 详解

这是整个处理的核心方法。它的主要职责是：

优先处理所有 BeanDefinitionRegistryPostProcessor（BeanFactoryPostProcessor 的子接口）。
然后处理普通的 BeanFactoryPostProcessor。
保证处理顺序符合 PriorityOrdered、Ordered 的要求。

3.1 整体逻辑框架

java 复制代码

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

    // 用于记录已经执行过的处理器，防止重复执行
    Set<String> processedBeans = new HashSet<>();

    // 如果 beanFactory 是 BeanDefinitionRegistry 类型（通常是 DefaultListableBeanFactory），
    // 则需要优先处理 BeanDefinitionRegistryPostProcessor，因为它们可以注册额外的 Bean 定义。
    if (beanFactory instanceof BeanDefinitionRegistry) {
        BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
        // 存放普通的 BeanFactoryPostProcessor（稍后执行）
        List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
        // 存放 BeanDefinitionRegistryPostProcessor
        List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

        // 1. 先处理手动添加的 BeanFactoryPostProcessor（来自 getBeanFactoryPostProcessors()）
        for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                BeanDefinitionRegistryPostProcessor registryProcessor =
                        (BeanDefinitionRegistryPostProcessor) postProcessor;
                // 直接执行 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法
                registryProcessor.postProcessBeanDefinitionRegistry(registry);
                registryProcessors.add(registryProcessor);
            } else {
                regularPostProcessors.add(postProcessor);
            }
        }

        // 2. 处理从 Bean 定义中发现的 BeanDefinitionRegistryPostProcessor
        // 分为三组：PriorityOrdered、Ordered、普通
        List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

        // 第一步：找出所有实现 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
        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.add(ppName);
            }
        }
        // 排序并执行 PriorityOrdered 组的 postProcessBeanDefinitionRegistry
        sortPostProcessors(currentRegistryProcessors, beanFactory);
        registryProcessors.addAll(currentRegistryProcessors);
        invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
        currentRegistryProcessors.clear();

        // 第二步：找出所有实现 Ordered 的 BeanDefinitionRegistryPostProcessor
        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();

        // 第三步：最后执行所有剩余的 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();
        }

        // 3. 现在，所有 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 已经执行完毕
        // 接下来调用它们的 postProcessBeanFactory 方法（因为 BeanDefinitionRegistryPostProcessor 也继承了 BeanFactoryPostProcessor）
        invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
        // 再调用手动添加的普通 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
    } else {
        // 如果 beanFactory 不是 BeanDefinitionRegistry，则直接调用手动添加的 BeanFactoryPostProcessor
        invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
    }

    // 4. 处理所有尚未执行的 BeanFactoryPostProcessor（从 Bean 定义中发现，且不属于 BeanDefinitionRegistryPostProcessor）
    String[] postProcessorNames =
            beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

    // 分别收集 PriorityOrdered、Ordered、普通
    List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
    List<String> orderedPostProcessorNames = new ArrayList<>();
    List<String> nonOrderedPostProcessorNames = new ArrayList<>();
    for (String ppName : postProcessorNames) {
        if (processedBeans.contains(ppName)) {
            // 已经作为 BeanDefinitionRegistryPostProcessor 处理过，跳过
        } 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);
        }
    }

    // 首先执行 PriorityOrdered 的 BeanFactoryPostProcessor
    sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

    // 其次执行 Ordered 的 BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
    for (String ppName : orderedPostProcessorNames) {
        orderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    sortPostProcessors(orderedPostProcessors, beanFactory);
    invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

    // 最后执行普通无优先级的 BeanFactoryPostProcessor
    List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
    for (String ppName : nonOrderedPostProcessorNames) {
        nonOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
    }
    invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

    // 清除元数据缓存，因为 BeanDefinition 可能已被修改
    beanFactory.clearMetadataCache();
}

3.2 关键步骤说明

区分两种类型的处理器：
- BeanDefinitionRegistryPostProcessor：允许在 BeanDefinition 注册阶段添加额外的 Bean 定义。
- BeanFactoryPostProcessor：只允许修改已存在的 Bean 定义。
处理手动添加的处理器 （beanFactoryPostProcessors 参数）：
- 如果属于 BeanDefinitionRegistryPostProcessor，立即调用其 postProcessBeanDefinitionRegistry 方法，并收集起来用于后续调用其 postProcessBeanFactory。
- 其他则暂存到 regularPostProcessors 中，稍后执行。
从容器中查找并执行 BeanDefinitionRegistryPostProcessor：
- 按照 PriorityOrdered → Ordered → 普通的顺序执行。
- 每执行完一组，可能因为处理器的逻辑又注册了新的 BeanDefinitionRegistryPostProcessor，所以最后一组（普通）需要循环处理直到没有新增的为止（通过 reiterate 标志）。
- 所有 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 执行完毕后，再调用它们的 postProcessBeanFactory 方法（因为它们也实现了 BeanFactoryPostProcessor）。
执行所有 BeanFactoryPostProcessor：
- 从容器中找出尚未执行过的 BeanFactoryPostProcessor（排除已作为 BeanDefinitionRegistryPostProcessor 执行过的）。
- 同样按照 PriorityOrdered → Ordered → 普通的顺序调用其 postProcessBeanFactory 方法。
清理元数据缓存 ：由于 Bean 定义可能被修改，清空 beanFactory 的缓存，确保后续获取 Bean 定义时使用最新的。

4. 重要细节

排序：通过 sortPostProcessors 方法实现，底层使用 AnnotationAwareOrderComparator（考虑了 @Order 注解和 Ordered 接口）。
重复执行检查 ：使用 processedBeans 集合记录已经通过 getBean() 获取过的 Bean 名称，避免重复执行。
动态注册 ：BeanDefinitionRegistryPostProcessor 可以在执行过程中动态向容器注册新的 Bean 定义，Spring 会识别这些新增的处理器并再次执行（通过 reiterate 循环）。
非注册中心场景 ：如果 beanFactory 没有实现 BeanDefinitionRegistry（极少见），则只能执行普通的 BeanFactoryPostProcessor，且无法处理 BeanDefinitionRegistryPostProcessor。

5. 典型应用

1. `ConfigurationClassPostProcessor`（处理 `@Configuration` 类）

实现了 BeanDefinitionRegistryPostProcessor。
在 postProcessBeanDefinitionRegistry() 中，它会解析所有已注册的 @Configuration 类，扫描 @ComponentScan、@Import、@Bean 等注解，并将解析出的新 BeanDefinition 注册到容器。
这是注解驱动配置的基石。

2. `PropertySourcesPlaceholderConfigurer`（解析占位符）

实现了 BeanFactoryPostProcessor（通常通过 postProcessBeanFactory 工作）。
遍历所有 BeanDefinition，将其中的占位符（如 ${db.url}）替换为 Environment 中对应的属性值。
它通常被注册为 @Bean 静态方法，或通过 <context:property-placeholder/> 自动注册。

3. `CustomScopeConfigurer`（注册自定义作用域）

实现了 BeanFactoryPostProcessor。
在 postProcessBeanFactory 中向 beanFactory 注册自定义的 Scope 实现。

4. `EventListenerMethodProcessor`（处理 `@EventListener`）

实现了 BeanFactoryPostProcessor 和 SmartInitializingSingleton。
它的 postProcessBeanFactory 阶段会扫描所有 Bean，找出带有 @EventListener 注解的方法，并将其注册为 ApplicationListener。

6. 总结

invokeBeanFactoryPostProcessors(beanFactory) 是 Spring 容器生命周期中的一个关键扩展点。通过深入源码，我们可以看到 Spring 如何精心组织不同优先级、不同类型的处理器，确保它们在合适的时机被调用，并允许在 Bean 定义加载完成后、Bean 实例化之前进行灵活的定制。理解这一过程有助于我们更好地掌握 Spring 容器的启动原理，以及编写高效可靠的 BeanFactoryPostProcessor。

invokeBeanFactoryPostProcessors(beanFactory)； 方法详解

1. 方法调用入口

2. 实际执行委托

3. PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors 详解

3.1 整体逻辑框架

3.2 关键步骤说明

4. 重要细节

5. 典型应用

1. ConfigurationClassPostProcessor（处理 @Configuration 类）

2. PropertySourcesPlaceholderConfigurer（解析占位符）

3. CustomScopeConfigurer（注册自定义作用域）

4. EventListenerMethodProcessor（处理 @EventListener）

6. 总结

invokeBeanFactoryPostProcessors(beanFactory)；方法详解

3. `PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors` 详解

1. `ConfigurationClassPostProcessor`（处理 `@Configuration` 类）

2. `PropertySourcesPlaceholderConfigurer`（解析占位符）

3. `CustomScopeConfigurer`（注册自定义作用域）

4. `EventListenerMethodProcessor`（处理 `@EventListener`）