概述

BeanFactoryPostProcessor是Spring中一个相当重要的扩展点，扩展点就是能让我们在Spring容器以及Bean生命周期的各个阶段中可以进行修改扩展。

什么是BeanFactoryPostProcessor

BeanFactoryPostProcessor, 翻译过来大致是Bean的工厂处理器，顾名思义，可以理解为它对Bean工厂中Bean定义（BeanDefintion）进行修改， 它的执行时机：BeanFactory标准初始化之后，所有的Bean定义已经被加载，但标准Bean的实例还没被创建（不包括BeanFactoryPostProcessor类型）。该方法通常用于修改bean的定义，Bean的属性值等，甚至可以在此快速初始化Bean。
而另外一个相关的扩展接口的BeanDefinitionRegistryPostProcessor，继承自BeanFactoryPostProcessor，所有的Bean定义即将被加载，但Bean的实例还没被创建时，也就是说，BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法执行时机先于BeanFactoryPostProcessor的postProcessBeanFactory方法。
区别于一个很类似的扩展接口BeanPostProcessor, 它的执行时机实在Bean初始化前后，添加一些自己想要的逻辑。
小结一下，上面关联的扩展接口执行顺序如下：1.BeanDefinitionRegistryPostProcessor，2.BeanFactoryPostProcessor，3.BeanPostProcessor。而BeanFactoryPostProcessor主要是在标准的BeanDefinition已经准备完毕，可以去修改已有的BeanDefinition的相关属性等。

如何使用BeanFactoryPostProcessor

  1. 新建一个测试bean

    1. @Data
    2. @Component
    3. public class Student {
    5.  @Value("${user.username:alvin}")
    6.  private String username;
    8.  @Value("${user.age:12}")
    9.  private int age;
    10. }

  2. 新建处理器实现**BeanFactoryPostProcessor** ```java @Component @Slf4j public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

    @Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {

    1.  log.info("******************** TestBeanFactoryPostProcessor#postProcessBeanFactory ****************");
    2.  log.info("******************** bean的数量：[{}] ****************", beanFactory.getBeanDefinitionCount());
    3.  // 修改bean definition属性信息
    4.  BeanDefinition userBeanDef = beanFactory.getBeanDefinition("student");
    5.  userBeanDef.getPropertyValues().add("username", "cxw");
    7.  // 快速初始化Bean
    8.  User user = (User)beanFactory.getBean("student");
    9.  log.info("student name: [{}]", user.getUsername());

    } }

  2. 3. **验证结论**
  4. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/384158/1654850398275-592eb0cd-4b59-4880-98d8-32e2c4de7a07.png#clientId=u6871ecff-da1d-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=199&id=PkQlJ&margin=%5Bobject%20Object%5D&name=image.png&originHeight=199&originWidth=1089&originalType=binary&ratio=1&rotation=0&showTitle=false&size=50251&status=done&style=none&taskId=u0a687fa5-925a-4f50-96f8-a8312006cf4&title=&width=1089)<br />bean的属性被成功被修改了。
  5. <a name="HKEwX"></a>
  6. # 源码解析
  7. <a name="WOBrY"></a>
  8. ## 接口定义
  9. ```java
  10. /**
  11.  * Factory hook that allows for custom modification of an application context's
  12.  * bean definitions, adapting the bean property values of the context's underlying
  13.  * bean factory.
  14.  *
  15.  * <p>Useful for custom config files targeted at system administrators that
  16.  * override bean properties configured in the application context. See
  17.  * {@link PropertyResourceConfigurer} and its concrete implementations for
  18.  * out-of-the-box solutions that address such configuration needs.
  19.  *
  20.  * <p>A {@code BeanFactoryPostProcessor} may interact with and modify bean
  21.  * definitions, but never bean instances. Doing so may cause premature bean
  22.  * instantiation, violating the container and causing unintended side-effects.
  23.  * If bean instance interaction is required, consider implementing
  24.  * {@link BeanPostProcessor} instead.
  25.  *
  26.  * <h3>Registration</h3>
  27.  * <p>An {@code ApplicationContext} auto-detects {@code BeanFactoryPostProcessor}
  28.  * beans in its bean definitions and applies them before any other beans get created.
  29.  * A {@code BeanFactoryPostProcessor} may also be registered programmatically
  30.  * with a {@code ConfigurableApplicationContext}.
  31.  *
  32.  * <h3>Ordering</h3>
  33.  * <p>{@code BeanFactoryPostProcessor} beans that are autodetected in an
  34.  * {@code ApplicationContext} will be ordered according to
  35.  * {@link org.springframework.core.PriorityOrdered} and
  36.  * {@link org.springframework.core.Ordered} semantics. In contrast,
  37.  * {@code BeanFactoryPostProcessor} beans that are registered programmatically
  38.  * with a {@code ConfigurableApplicationContext} will be applied in the order of
  39.  * registration; any ordering semantics expressed through implementing the
  40.  * {@code PriorityOrdered} or {@code Ordered} interface will be ignored for
  41.  * programmatically registered post-processors. Furthermore, the
  42.  * {@link org.springframework.core.annotation.Order @Order} annotation is not
  43.  * taken into account for {@code BeanFactoryPostProcessor} beans.
  44.  *
  45.  * @author Juergen Hoeller
  46.  * @author Sam Brannen
  47.  * @since 06.07.2003
  48.  * @see BeanPostProcessor
  49.  * @see PropertyResourceConfigurer
  50.  */
  51. @FunctionalInterface
  52. public interface BeanFactoryPostProcessor {
  54.     /**
  55.      * Modify the application context's internal bean factory after its standard
  56.      * initialization. All bean definitions will have been loaded, but no beans
  57.      * will have been instantiated yet. This allows for overriding or adding
  58.      * properties even to eager-initializing beans.
  59.      * @param beanFactory the bean factory used by the application context
  60.      * @throws org.springframework.beans.BeansException in case of errors
  61.      */
  62.     void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
  64. }

接口的注释很清楚的说明了它的作用和细节，大致有下面几点：

  • 该接口允许用户自定义修改工厂bean中的BeanDefinition, 调整BeanDefinition的属性值，甚至初始化Bean。比如内置的PropertyResourceConfigurer，就是修改beanDefinition的属性为配置文件的属性。

  • 该接口主要是用于修改BeanDefinition, 虽然也可以直接进行实例化Bean, 但是不建议这么做，可能会造成其他未知的错误。

    执行流程

    Spring Boot 扩展之BeanFactoryPostProcessor接口源码解析 - 图1其中核心逻辑是PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors方法，该方法的前面部分逻辑主要是处理BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，也就是想BeanDefinition注册中中心添加新的BeanDefinition。 ```java public static void invokeBeanFactoryPostProcessors(

    1.       ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    3.   .......... 该部分是处理BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry相关逻辑，跳过， 可以看BeanDefinitionRegistryPostProcessor的解析
  1.     // Do not initialize FactoryBeans here: We need to leave all regular beans
  2.     // uninitialized to let the bean factory post-processors apply to them!
  3.     // 获取所有实现了BeanFactoryPostProcessor接口的bean name列表，前提是在BeanFactory的BeanDefinitions列表中包含对应的bean定义信息。
  4.     String[] postProcessorNames =
  5.             beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
  7.     // Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
  8.     // Ordered, and the rest.
  9.     // 存放实现了PriorityOrdered接口的processor
  10.     List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
  11.     // 存放实现了Ordered接口的processor
  12.     List<String> orderedPostProcessorNames = new ArrayList<>();
  13.     // 存放没有实现排序的processor
  14.     List<String> nonOrderedPostProcessorNames = new ArrayList<>();
  15.     // 遍历前面全量的bean name，将他们归类，放到上面的容器中
  16.     for (String ppName : postProcessorNames) {
  17.         // 如果在第一阶段已经被调用过，就不调用，第一阶段主要是BeanDefinitionRegistryPostProcessor，它继承了BeanFactoryPostProcessor，它会在第一阶段调用。
  18.         if (processedBeans.contains(ppName)) {
  19.             // skip - already processed in first phase above
  20.         }
  21.         else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  22.             priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
  23.         }
  24.         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  25.             orderedPostProcessorNames.add(ppName);
  26.         }
  27.         else {
  28.             nonOrderedPostProcessorNames.add(ppName);
  29.         }
  30.     }
  32.     // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
  33.     // 首先执行实现了PriorityOrdered接口的processor，对它们进行排序
  34.     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  35.     // 真实执行processor中的逻辑。
  36.     invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
  38.     // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
  39.     // 其次执行实现了Ordered接口的processor，对它们进行排序后执行processor中的逻辑。
  40.     List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
  41.     for (String postProcessorName : orderedPostProcessorNames) {
  42.         orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  43.     }
  44.     sortPostProcessors(orderedPostProcessors, beanFactory);
  45.     invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
  47.     // 最后执行，没有顺序要求的processor
  48.     List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
  49.     for (String postProcessorName : nonOrderedPostProcessorNames) {
  50.         nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
  51.     }
  52.     invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
  54.     // Clear cached merged bean definitions since the post-processors might have
  55.     // modified the original metadata, e.g. replacing placeholders in values...
  56.     beanFactory.clearMetadataCache();
  57. }

//调用processors中的postProcessBeanFactory方法 private static void invokeBeanFactoryPostProcessors( Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {

  1.     for (BeanFactoryPostProcessor postProcessor : postProcessors) {
  2.         StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process")
  3.                 .tag("postProcessor", postProcessor::toString);
  4.         postProcessor.postProcessBeanFactory(beanFactory);
  5.         postProcessBeanFactory.end();
  6.     }
  7. }

```

小结

整个执行流程的源码还是比较清晰并且简单的。重点提下下面两个点：

  1. 我们自定义的BeanFactoryProcessor需要加上**@Component**等注解，为什么？

看源码得知，String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);获取所有实现了BeanFactoryPostProcessor的Bean Name, 前提所有的Bean都要被注册到BeanDefinitionRegistry, 通过添加@Component, @Service等注解，可以将对应的Bean定义信息注册到BeanFactory中，方便后面实例化Bean。 那么它是在什么地方注册的呢？可以看下ConfigurationClassPostProcessor类，它实现了BeanDefinitionRegistryPostProcessor,会扫描所有@Component, @Service等注解，将对应的Bean Definition注册到BeanFactory中。

  1. 执行顺序问题

我们可以通过实现PriorityOrdered, Ordered接口，控制BeanFactoryProcessor的执行顺序,， 优先执行实现了PriorityOrdered接口，其次是Ordered，最后是没有实现任何排序接口的processor。

内置的BeanFactoryPostProcessor

Spring内置了一个比较重要的BeanFactoryPostProcessor是PlaceholderConfigurerSupport, 实现从配置文件中获取属性。
image.png

参考

https://fangjian0423.github.io/2017/06/24/spring-embedded-bean-post-processor/