前言

在 Spring IoC：invokeBeanFactoryPostProcessors 详解 中我们介绍了 invokeBeanFactoryPostProcessors 方法，而本文将介绍另一个类似的方法——registerBeanPostProcessors。
invokeBeanFactoryPostProcessors 方法主要用于处理 BeanFactoryPostProcessor 接口，而 registerBeanPostProcessors 方法主要用于处理BeanPostProcessor接口。BeanFactoryPostProcessor 和 BeanPostProcessor，相信大家很容易从命名看出来这两个接口“长得很像”。BeanFactoryPostProcessor 是针对 BeanFactory 的扩展，主要用在 bean 实例化之前，读取 bean 的定义，并可以修改它。BeanPostProcessor 是针对 bean 的扩展，主要用在 bean 实例化之后，执行初始化方法前后，允许开发者对 bean 实例进行修改。

概述

本方法会注册所有的BeanPostProcessor，将所有实现了BeanPostProcessor 接口的类加载到 BeanFactory中。
BeanPostProcessor 接口是 Spring初始化bean 时对外暴露的扩展点，Spring IoC容器允许 BeanPostProcessor在容器初始化 bean 的前后，添加自己的逻辑处理。在registerBeanPostProcessors方法只是注册到BeanFactory 中，具体调用是在 bean 初始化的时候。

具体的：在所有 bean实例化时，执行初始化方法前会调用所有 BeanPostProcessor 的 postProcessBeforeInitialization 方法，在执行初始化方法后会调用所有 BeanPostProcessor的 postProcessAfterInitialization 方法。

正文

首先我们回到 AbstractApplicationContext.refresh() 方法，找到代码：registerBeanPostProcessors(beanFactory)，单击该行代码跳转到具体的实现。

  1. protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
  2.     // 1.注册BeanPostProcessor
  3.     PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
  4. }

详细代码

  1. public static void registerBeanPostProcessors(
  2.         ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
  4.     // 1.找出所有实现BeanPostProcessor接口的类
  5.     String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
  7.     // Register BeanPostProcessorChecker that logs an info message when
  8.     // a bean is created during BeanPostProcessor instantiation, i.e. when
  9.     // a bean is not eligible for getting processed by all BeanPostProcessors.
  10.     // BeanPostProcessor的目标计数
  11.     int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
  12.     // 2.添加BeanPostProcessorChecker(主要用于记录信息)到beanFactory中
  13.     beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
  15.     // Separate between BeanPostProcessors that implement PriorityOrdered,
  16.     // Ordered, and the rest.
  17.     // 3.定义不同的变量用于区分: 实现PriorityOrdered接口的BeanPostProcessor、实现Ordered接口的BeanPostProcessor、普通BeanPostProcessor
  18.     // 3.1 priorityOrderedPostProcessors: 用于存放实现PriorityOrdered接口的BeanPostProcessor
  19.     List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
  20.     // 3.2 internalPostProcessors: 用于存放Spring内部的BeanPostProcessor
  21.     List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
  22.     // 3.3 orderedPostProcessorNames: 用于存放实现Ordered接口的BeanPostProcessor的beanName
  23.     List<String> orderedPostProcessorNames = new ArrayList<String>();
  24.     // 3.4 nonOrderedPostProcessorNames: 用于存放普通BeanPostProcessor的beanName
  25.     List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
  26.     // 4.遍历postProcessorNames, 将BeanPostProcessors按3.1 - 3.4定义的变量区分开
  27.     for (String ppName : postProcessorNames) {
  28.         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
  29.             // 4.1 如果ppName对应的Bean实例实现了PriorityOrdered接口, 则拿到ppName对应的Bean实例并添加到priorityOrderedPostProcessors
  30.             BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  31.             priorityOrderedPostProcessors.add(pp);
  32.             if (pp instanceof MergedBeanDefinitionPostProcessor) {
  33.                 // 4.2 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
  34.                 // 则将ppName对应的Bean实例添加到internalPostProcessors
  35.                 internalPostProcessors.add(pp);
  36.             }
  37.         }
  38.         else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
  39.             // 4.3 如果ppName对应的Bean实例没有实现PriorityOrdered接口, 但是实现了Ordered接口, 则将ppName添加到orderedPostProcessorNames
  40.             orderedPostProcessorNames.add(ppName);
  41.         }
  42.         else {
  43.             // 4.4 否则, 将ppName添加到nonOrderedPostProcessorNames
  44.             nonOrderedPostProcessorNames.add(ppName);
  45.         }
  46.     }
  48.     // First, register the BeanPostProcessors that implement PriorityOrdered.
  49.     // 5.首先, 注册实现PriorityOrdered接口的BeanPostProcessors
  50.     // 5.1 对priorityOrderedPostProcessors进行排序
  51.     sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
  52.     // 5.2 注册priorityOrderedPostProcessors
  53.     registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
  55.     // Next, register the BeanPostProcessors that implement Ordered.
  56.     // 6.接下来, 注册实现Ordered接口的BeanPostProcessors
  57.     List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
  58.     for (String ppName : orderedPostProcessorNames) {
  59.         // 6.1 拿到ppName对应的BeanPostProcessor实例对象
  60.         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  61.         // 6.2 将ppName对应的BeanPostProcessor实例对象添加到orderedPostProcessors, 准备执行注册
  62.         orderedPostProcessors.add(pp);
  63.         if (pp instanceof MergedBeanDefinitionPostProcessor) {
  64.             // 6.3 如果ppName对应的Bean实例也实现了MergedBeanDefinitionPostProcessor接口,
  65.             // 则将ppName对应的Bean实例添加到internalPostProcessors
  66.             internalPostProcessors.add(pp);
  67.         }
  68.     }
  69.     // 6.4 对orderedPostProcessors进行排序
  70.     sortPostProcessors(orderedPostProcessors, beanFactory);
  71.     // 6.5 注册orderedPostProcessors
  72.     registerBeanPostProcessors(beanFactory, orderedPostProcessors);
  74.     // Now, register all regular BeanPostProcessors.
  75.     // 7.注册所有常规的BeanPostProcessors（过程与6类似）
  76.     List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
  77.     for (String ppName : nonOrderedPostProcessorNames) {
  78.         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  79.         nonOrderedPostProcessors.add(pp);
  80.         if (pp instanceof MergedBeanDefinitionPostProcessor) {
  81.             internalPostProcessors.add(pp);
  82.         }
  83.     }
  84.     registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
  86.     // Finally, re-register all internal BeanPostProcessors.
  87.     // 8.最后, 重新注册所有内部BeanPostProcessors（相当于内部的BeanPostProcessor会被移到处理器链的末尾）
  88.     // 8.1 对internalPostProcessors进行排序
  89.     sortPostProcessors(internalPostProcessors, beanFactory);
  90.     // 8.2注册internalPostProcessors
  91.     registerBeanPostProcessors(beanFactory, internalPostProcessors);
  93.     // Re-register post-processor for detecting inner beans as ApplicationListeners,
  94.     // moving it to the end of the processor chain (for picking up proxies etc).
  95.     // 9.重新注册ApplicationListenerDetector（跟8类似，主要是为了移动到处理器链的末尾）
  96.     beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
  97. }

registerBeanPostProcessors

  1. private static void registerBeanPostProcessors(
  2.         ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
  3.     // 1.遍历postProcessors
  4.     for (BeanPostProcessor postProcessor : postProcessors) {
  5.         // 2.将PostProcessor添加到BeanFactory中的beanPostProcessors缓存
  6.         beanFactory.addBeanPostProcessor(postProcessor);
  7.     }
  8. }

代码块3：beanFactory.addBeanPostProcessor

  1. @Override
  2. public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
  3.     Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
  4.     // 1.如果beanPostProcessor已经存在则移除（可以起到排序的效果，beanPostProcessor可能本来在前面，移除再添加，则变到最后面）
  5.     this.beanPostProcessors.remove(beanPostProcessor);
  6.     // 2.将beanPostProcessor添加到beanPostProcessors缓存
  7.     this.beanPostProcessors.add(beanPostProcessor);
  8.     if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
  9.         // 3.如果beanPostProcessor是InstantiationAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
  10.         // 该变量用于指示beanFactory是否已注册过InstantiationAwareBeanPostProcessors
  11.         this.hasInstantiationAwareBeanPostProcessors = true;
  12.     }
  13.     if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
  14.         // 4.如果beanPostProcessor是DestructionAwareBeanPostProcessor, 则将hasInstantiationAwareBeanPostProcessors设置为true,
  15.         // 该变量用于指示beanFactory是否已注册过DestructionAwareBeanPostProcessor
  16.         this.hasDestructionAwareBeanPostProcessors = true;
  17.     }
  18. }

该方法作用就是将 BeanPostProcessor添加到beanPostProcessors缓存，这边的先移除再添加，主要是起一个排序的作用。而hasInstantiationAwareBeanPostProcessors 和 hasDestructionAwareBeanPostProcessors变量用于指示beanFactory 是否已注册过InstantiationAwareBeanPostProcessors 和 DestructionAwareBeanPostProcessor，在之后的 IoC 创建过程会用到这两个变量，这边先有个印象。

总结

如同 invokeBeanFactoryPostProcessors 方法一样，registerBeanPostProcessors 方法的内容也比较少，核心过程在代码块1的注释已经写清楚，这边稍微总结一下。
1.整个 registerBeanPostProcessors 方法围绕 BeanPostProcessor 接口展开，和 invokeBeanFactoryPostProcessors 不同的是，invokeBeanFactoryPostProcessors 方法会直接调用 BeanFactoryPostProcessor 实现类的方法，而 registerBeanPostProcessors 方法只是将 BeanPostProcessor 实现类注册到 BeanFactory 的 beanPostProcessors 缓存中。这是因为，此时还未到 BeanPostProcessor 实现类“出场的时候”。

2.BeanPostProcessor 实现类具体的 “出场时机” 在创建 bean 实例时，执行初始化方法前后。postProcessBeforeInitialization 方法在执行初始化方法前被调用，postProcessAfterInitialization 方法在执行初始化方法后被调用。

3.BeanPostProcessor 实现类和 BeanFactoryPostProcessor 实现类一样，也可以通过实现 PriorityOrdered、Ordered 接口来调整自己的优先级。

4.registerBeanPostProcessors 方法和 invokeBeanFactoryPostProcessors 也会触发 bean 实例的创建，创建 Bean 实例是 IoC 的核心内容，之后会单独解析，目前暂不深入解析。