概述

  1.     Spring中的每个bean的创建是依赖一个对应的`BeanDefintion`实例，该实例保存了bean对象创建必要的信息，比如bean的class类型，是否是抽象类、属性信息等。`BeanDefinitionRegistry`是一个接口，bean定义信息的注册中心，用于注册、删除、管理`BeanDefintion`。<br />        如果外部想要添加Bean的定义信息，创建新的Bean, 怎么办？ 当然是可以通过Spring提供的扩展接口`BeanDefinitionRegistryPostProcessor`实现，比较典型的一个案例是mybatis-spring，就是通过实现该接口，添加mybatis相关的bean。<br />      所以，`**BeanDefinitionRegistryPostProcessor**`**就是bean定义注册中心的后置处理器，允许我们修改拓展bean定义信息的注册中心，在所有bean定义信息将要被加载，bean实例还未创建的时候执行。**

使用实例

  1. 新建类实现BeanDefinitionRegistryPostProcessor ```java @Component public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor { @Override public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {

    1.  log.info("******************** TestBeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry ****************");
    2.  log.info("******************** bean的数量：[{}] ****************", beanDefinitionRegistry.getBeanDefinitionCount());
    4.  AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition();
    5.  MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
    6.  propertyValues.addPropertyValue("username", "alvin");
    7.  propertyValues.addPropertyValue("age", 12);
    9.  // 注册bean信息
    10.  beanDefinitionRegistry.registerBeanDefinition("beanDefineDemo", beanDefinition);

    }

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

    1.  log.info("******************** TestBeanDefinitionRegistryPostProcessor#postProcessBeanFactory ****************");
    2.  log.info("******************** bean的数量：[{}] ****************", configurableListableBeanFactory.getBeanDefinitionCount());

    } }

  2. 2. 实现类需要添加`@Component`注解
  4. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/384158/1654061737063-3893a070-bcfc-4946-a896-842188179314.png#clientId=ud7accf57-2ef8-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=175&id=u9e84b8fe&margin=%5Bobject%20Object%5D&name=image.png&originHeight=175&originWidth=647&originalType=binary&ratio=1&rotation=0&showTitle=false&size=21448&status=done&style=none&taskId=ue923855d-f826-4be0-b046-8f25c8b03c1&title=&width=647)
  6. 3. 验证注入的bean
  8. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/384158/1654061762922-d7d668a9-56ef-4c0e-9ca5-d0a7c9cb08f8.png#clientId=ud7accf57-2ef8-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=242&id=ue393d30b&margin=%5Bobject%20Object%5D&name=image.png&originHeight=242&originWidth=921&originalType=binary&ratio=1&rotation=0&showTitle=false&size=36749&status=done&style=none&taskId=ua5ad40d1-08c0-4110-a364-d381fbf302b&title=&width=921)<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/384158/1654061772381-da50fa51-2890-4f9e-8e65-6485b6446c65.png#clientId=ud7accf57-2ef8-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=47&id=ufcc92ed2&margin=%5Bobject%20Object%5D&name=image.png&originHeight=47&originWidth=1207&originalType=binary&ratio=1&rotation=0&showTitle=false&size=9943&status=done&style=none&taskId=u32a98b6e-e9cd-4e16-8c3a-2f3e6bdeb84&title=&width=1207)
  9. <a name="nqAkU"></a>
  10. # 源码解析
  11. > 可以通过debug的方式，在postProcessBeanDefinitionRegistry方法中打上断点，查看Deubbger中的Frames记录，快速定位代码的调用链路。
  13. <a name="OAsYd"></a>
  14. ## 接口的定义说明
  15. ```java
  16. /**
  17.  * 扩展到标准的{@link BeanFactoryPostProcessor} SPI
  18.  * 允许在常规BeanFactoryPostProcessor检测开始之前注册更多的bean定义。
  19.  * 特别是，BeanDefinitionRegistryPostProcessor可以注册更多的bean定义，
  20.  * 这些定义反过来又定义了BeanFactoryPostProcessor实例。
  21.  * 
  22.  * Extension to the standard {@link BeanFactoryPostProcessor} SPI, allowing for
  23.  * the registration of further bean definitions <i>before</i> regular
  24.  * BeanFactoryPostProcessor detection kicks in. In particular,
  25.  * BeanDefinitionRegistryPostProcessor may register further bean definitions
  26.  * which in turn define BeanFactoryPostProcessor instances.
  27.  *
  28.  * @author Juergen Hoeller
  29.  * @since 3.0.1
  30.  * @see org.springframework.context.annotation.ConfigurationClassPostProcessor
  31.  */
  32. public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
  34.     /**
  35.      * 在标准初始化之后修改应用程序上下文的内部bean定义注册表。所有常规bean定义都已加载，
  36.      * 但还没有实例化bean。这允许在进入下一个后处理阶段之前添加更多的bean定义。
  37.      * 
  38.      * Modify the application context's internal bean definition registry after its
  39.      * standard initialization. All regular bean definitions will have been loaded,
  40.      * but no beans will have been instantiated yet. This allows for adding further
  41.      * bean definitions before the next post-processing phase kicks in.
  42.      * @param registry the bean definition registry used by the application context
  43.      * @throws org.springframework.beans.BeansException in case of errors
  44.      */
  45.     void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;

通过翻译看，此接口目的是为了提供给开发者向容器中注册更多的BeanDefinition, 实现动态注册bean的目的。

执行流程

Spring Boot 扩展之BeanDefinitionRegistryPostProcessor接口源码解析 - 图1以上是整个执行的序列图，关键点是AbstractApplicationContext#refresh()。

1. AbstractApplicationContext#refresh()

  1. public void refresh() throws BeansException, IllegalStateException {
  2.         synchronized (this.startupShutdownMonitor) {
  3.             StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
  5.             // Prepare this context for refreshing.
  6.             // 刷新上下文的准备阶段，跳过
  7.             prepareRefresh();
  9.             // Tell the subclass to refresh the internal bean factory.
  10.             // 创建beanFacotry工厂
  11.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  13.             // Prepare the bean factory for use in this context.
  14.             // beanFactory准备工作， 跳过
  15.             prepareBeanFactory(beanFactory);
  17.             try {
  18.                 // Allows post-processing of the bean factory in context subclasses.
  19.                 postProcessBeanFactory(beanFactory);
  21.                 StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
  22.                 // Invoke factory processors registered as beans in the context.
  23.                 // 调用注册的BeanFactoryPostProcessors对象
  24.                 invokeBeanFactoryPostProcessors(beanFactory);
  27.         }
  28.     }

2. AbstractApplicationContext#invokeBeanFactoryPostProcessors

  1. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.         // 注册的核心代码， beanFactory代表当前的容器， 第二个参数为内置的参数处理器
  3.         PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
  5.         .....
  6. }

3. PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors

  1. public static void invokeBeanFactoryPostProcessors(
  2.             ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
  4.         // WARNING: Although it may appear that the body of this method can be easily
  5.         // refactored to avoid the use of multiple loops and multiple lists, the use
  6.         // of multiple lists and multiple passes over the names of processors is
  7.         // intentional. We must ensure that we honor the contracts for PriorityOrdered
  8.         // and Ordered processors. Specifically, we must NOT cause processors to be
  9.         // instantiated (via getBean() invocations) or registered in the ApplicationContext
  10.         // in the wrong order.
  11.         //
  12.         // Before submitting a pull request (PR) to change this method, please review the
  13.         // list of all declined PRs involving changes to PostProcessorRegistrationDelegate
  14.         // to ensure that your proposal does not result in a breaking change:
  15.         // https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22
  17.         // Invoke BeanDefinitionRegistryPostProcessors first, if any.
  18.         // 如果存在BeanDefinitionRegistryPostProcessors，那么就会首先调用。
  19.         Set<String> processedBeans = new HashSet<>();
  21.         if (beanFactory instanceof BeanDefinitionRegistry) {
  22.             BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
  23.             // 常规的BeanFactory后置处理器集合
  24.             List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
  25.             // Bean定义注册的后置处理器
  26.             List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
  28.             // 遍历容器优先内置的后置处理器
  29.             for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
  30.                 // 判断是否为Bean定义注册的后置处理器
  31.                 if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
  32.                     BeanDefinitionRegistryPostProcessor registryProcessor =
  33.                             (BeanDefinitionRegistryPostProcessor) postProcessor;
  34.                     // 直接调用postProcessBeanDefinitionRegistry方法
  35.                     registryProcessor.postProcessBeanDefinitionRegistry(registry);
  36.                     registryProcessors.add(registryProcessor);
  37.                 }
  38.                 else {
  39.                     regularPostProcessors.add(postProcessor);
  40.                 }
  41.             }
  43.             // Do not initialize FactoryBeans here: We need to leave all regular beans
  44.             // uninitialized to let the bean factory post-processors apply to them!
  45.             // Separate between BeanDefinitionRegistryPostProcessors that implement
  46.             // PriorityOrdered, Ordered, and the rest.
  47.             // 定义外部实现了BeanDefinitionRegistryPostProcessor扩展的集合
  48.             List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
  50.             // First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
  51.             // 首先，调用实现PriorityOrdered的 BeanDefinitionRegistryPostProcessor。
  52.             // 此处获取的postProcessorNames必须是已经进行注册过的BeanDefinition。
  53.             // 第一次我们无法找到我们写的BeanDefinitionRegistryPostProcessor，是因为它本身并未注册到bean定义注册中心。
  54.             // 但是会发现有ConfigurationClassPostProcessor，它会帮我们写的PostProcessor注册到bean定义注册中心。
  55.             String[] postProcessorNames =
  56.                     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  57.             for (String ppName : postProcessorNames) {
  58.                 // 判断BeanDefinitionRegistryPostProcessor是否实现了PriorityOrdered接口
  59.                 if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  60.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  61.                     processedBeans.add(ppName);
  62.                 }
  63.             }
  64.             // 根据优先级排序
  65.             sortPostProcessors(currentRegistryProcessors, beanFactory);
  66.             registryProcessors.addAll(currentRegistryProcessors);
  67.             // 真正执行后置处理器
  68.             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
  69.             currentRegistryProcessors.clear();
  71.             // Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
  72.             // 再次获取BeanDefinitionRegistryPostProcessor后置处理器，此时可以看到我们写的后置处理器，
  73.             // 那是因为我们写的后置处理器bean定义经过ConfigurationClassPostProcessor注册
  74.             postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  75.             for (String ppName : postProcessorNames) {
  76.                 // 判断是否实现了Ordered接口
  77.                 if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
  78.                     currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  79.                     processedBeans.add(ppName);
  80.                 }
  81.             }
  82.             sortPostProcessors(currentRegistryProcessors, beanFactory);
  83.             registryProcessors.addAll(currentRegistryProcessors);
  84.             // 真正执行后置处理器
  85.             invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
  86.             currentRegistryProcessors.clear();
  88.             // Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
  89.             // 最后执行没有实现Orderd接口的后置处理器
  90.             boolean reiterate = true;
  91.             while (reiterate) {
  92.                 reiterate = false;
  93.                 postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
  94.                 for (String ppName : postProcessorNames) {
  95.                     if (!processedBeans.contains(ppName)) {
  96.                         currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
  97.                         processedBeans.add(ppName);
  98.                         reiterate = true;
  99.                     }
  100.                 }
  101.                 sortPostProcessors(currentRegistryProcessors, beanFactory);
  102.                 registryProcessors.addAll(currentRegistryProcessors);
  103.                 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
  104.                 currentRegistryProcessors.clear();
  105.             }
  107.             // Now, invoke the postProcessBeanFactory callback of all processors handled so far.
  108.             // 因为
  109.             invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  110.             invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
  111.         }
  113.         else {
  114.             // Invoke factory processors registered with the context instance.
  115.             invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
  116.         }
  118.         // 后面的内容是执行BeanFactoryPostProcessor的后置处理器，后面再说
  119.         .....
  120.     }

小结：

  • 自己定义的后置处理器想要生效，前提是必须本身要被注册到BeanDefinitionRegistry注册中心，这也是为什么我们需要加@Component注解。
  • 那我们添加@Component注解的后置处理器在上面时候注册到BeanDefinitionRegistry注册中心呢？ 实在ConfigurationClassPostProcessor中动态注册的，这也是为什么第一次获取BeanDefinitionRegistryPostProcessor相关的bean name时候，没有找到我们写的，因为我们写的还没有注册到BeanDefinitionRegistry注册中心。
  • BeanDefinitionRegistryPostProcessor的执行顺序是，实现了@PriorityOrdered优先执行，其次是实现了@Ordered,最后是没有实现的后置处理器。

    内置的BeanDefinitionRegistryPostProcessor

    SpringBoot比较重要的内置的BeanDefinitionRegistryPostProcessor后置处理器是ConfigurationClassPostProcessor，它主要是帮我们完成注解扫描和类定义注册,然后再由BeanFactory完成实例化以及初始化逻辑，那它本身是在什么时候注册到注册中心的呢，内部原理又是什么样呢？

    参考

    https://juejin.cn/post/6844903874491318280#heading-8
    https://blog.csdn.net/qq_42154259/article/details/108315262
    https://www.cnblogs.com/warrior4236/p/13157671.html
    https://cloud.tencent.com/developer/article/1928593