來源：江南一點雨

今天來和各位小夥伴詳細分析一下 BeanPostProcessor。今天這篇是原理分析，基本用法松哥之前已經講過了，有影片也有文章，對影片感興趣的小夥伴戳這裡：Spring原始碼應該怎麼學？。

不同於前面和大家分享的 BeanFactoryPostProcessor，BeanPostProcessor 從名字上就能看出來，這是一個 Bean 的後置處理器，也就是說，BeanPostProcessor 其實主要是對已經建立出來的 Bean 做一些後置處理，而 BeanFactoryPostProcessor 主要是針對 BeanDefinition 做後置處理（此時 Bean 物件還沒建立出來）。

但是，BeanPostProcessor 家族裡邊也有例外，即 MergedBeanDefinitionPostProcessor，這是一個 BeanPostProcessor，但是卻可以處理 BeanDefinition。

這一切都是咋回事呢？我們今天就來分析分析。

1. BeanPostProcessor

首先我們先來看一下 BeanPostProcessor 介面的定義：

public interface BeanPostProcessor {

 @Nullable
 default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  return bean;
 }

 @Nullable
 default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  return bean;
 }

}

這裡就是兩個方法，理解這兩個方法有一個大的前提，就是此時 Spring 容器已經透過 Java 反射建立出來 Bean 物件了，只不過在初始化這個 Bean 物件的時候，又提供了一些配置介面：

postProcessBeforeInitialization：這個是在 Bean 初始化之前觸發，此時我們已經有一個 Bean 物件了，但是 Bean 中一些生命週期方法如 InitializingBean 介面的 afterPropertiesSet 方法、自定義的 init-method 方法等都尚未執行，在這些方法執行之前觸發 postProcessBeforeInitialization 方法。
postProcessAfterInitialization：類似於上面，在 afterPropertiesSet 和自定義的 init-method 之後觸發該方法。

BeanPostProcessor 的應用非常廣泛，在整個 Spring 體系中，也扮演了非常重要的角色，如 @Bean 註解的解析、AOP 動態代理的生成等等許多我們日常使用的功能，都是透過 BeanPostProcessor 來實現的。

2. MergedBeanDefinitionPostProcessor

MergedBeanDefinitionPostProcessor 算是整個 BeanPostProcessor 家族中比較另類的一個介面了，它雖然是 BeanPostProcessor，但是卻可以處理 BeanDefinition。MergedBeanDefinitionPostProcessor 介入的時機就是 Bean 建立成功之後，Bean 中各個屬性填充之前。

MergedBeanDefinitionPostProcessor 用於在 Bean 定義合併之後對合並後的 Bean 進行後置處理。它的作用是允許開發者在 Bean 定義合併完成後，對合並後的 Bean 進行自定義的修改或擴充套件操作。通常情況下，這個介面用於處理帶有註解的 Bean 定義，例如 @Autowired 或 @Value 等註解的處理。透過實現 MergedBeanDefinitionPostProcessor 介面，開發者可以在 Bean 定義合併後，對這些註解進行解析和處理，以實現自定義的邏輯。

來看下 MergedBeanDefinitionPostProcessor 介面：

public interface MergedBeanDefinitionPostProcessor extends BeanPostProcessor {

 void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);

 default void resetBeanDefinition(String beanName) {
 }

}

這裡就兩個方法，一個是處理合併後的 BeanDefinition，還有一個是重置 Bean 的。

3. 收集 BeanPostProcessor

接下來我們來看 BeanPostProcessor 的處理流程，首先第一步就是在容器啟動的時候，收集到使用者註冊在系統中的 BeanPostProcessor，無論是 Java 配置還是 XML 配置，在 refresh 方法中都會呼叫到 registerBeanPostProcessors，這個方法就是用來收集 BeanPostProcessor 的。

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
 PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
public static void registerBeanPostProcessors(
  ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
 String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
 int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
 beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
 List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
 List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
 List<String> orderedPostProcessorNames = new ArrayList<>();
 List<String> nonOrderedPostProcessorNames = new ArrayList<>();
 for (String ppName : postProcessorNames) {
  if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
   BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
   priorityOrderedPostProcessors.add(pp);
   if (pp instanceof MergedBeanDefinitionPostProcessor) {
    internalPostProcessors.add(pp);
   }
  }
  else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
   orderedPostProcessorNames.add(ppName);
  }
  else {
   nonOrderedPostProcessorNames.add(ppName);
  }
 }
 sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
 List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
 for (String ppName : orderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  orderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
   internalPostProcessors.add(pp);
  }
 }
 sortPostProcessors(orderedPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, orderedPostProcessors);
 List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
 for (String ppName : nonOrderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  nonOrderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
   internalPostProcessors.add(pp);
  }
 }
 registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
 sortPostProcessors(internalPostProcessors, beanFactory);
 registerBeanPostProcessors(beanFactory, internalPostProcessors);
 beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

這裡的程式碼我就不逐行解釋了，我來說一下整體的處理思路。

這裡用來儲存 BeanPostProcessor 的集合一共有四個，分別是：

priorityOrderedPostProcessors：由於 BeanPostProcessor 可能存在多個，所以我們需要給這多個 BeanPostProcessor 進行排序，排序的方式有兩種，一種就是在定義 BeanPostProcessor 的時候，讓其實現 PriorityOrdered 介面，那麼這裡就是把所有實現了 PriorityOrdered 介面的 BeanPostProcessor 收集到一起。
orderedPostProcessors：類似於上面的，這裡是收集所有實現了 Ordered 介面的 BeanPostProcessor。
nonOrderedPostProcessors：這個裡邊儲存了所有不需要排序的 BeanPostProcessor。
internalPostProcessors：這個裡邊儲存了 MergedBeanDefinitionPostProcessor 型別的 BeanPostProcessor，前三種互相之間不會重複，而 internalPostProcessors 可能會和前三種有重複。

將收集並且排序好的 BeanPostProcessor，呼叫 registerBeanPostProcessors 方法進行註冊：

private static void registerBeanPostProcessors(
  ConfigurableListableBeanFactory beanFactory, List<? extends BeanPostProcessor> postProcessors) {
 if (beanFactory instanceof AbstractBeanFactory abstractBeanFactory) {
  // Bulk addition is more efficient against our CopyOnWriteArrayList there
  abstractBeanFactory.addBeanPostProcessors(postProcessors);
 }
 else {
  for (BeanPostProcessor postProcessor : postProcessors) {
   beanFactory.addBeanPostProcessor(postProcessor);
  }
 }
}

這裡最終就是把收集到的 BeanPostProcessor 新增到容器的 beanPostProcessors 變數中。

現在，容器中已經有了 BeanPostProcessor 了，接下來看什麼時候執行。

4. 觸發 BeanPostProcessor

BeanPostProcessor 的執行分為兩種情況，一種是執行 MergedBeanDefinitionPostProcessor 型別的 BeanPostProcessor，還有一種是執行普通的 BeanPostProcessor，我們分別來看。

在建立 Bean 的關鍵方法 AbstractAutowireCapableBeanFactory#doCreateBean 中，有這樣幾個關鍵步驟：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  throws BeanCreationException {
    // 初始化 Bean 例項
 BeanWrapper instanceWrapper = null;
 if (mbd.isSingleton()) {
  instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
 }
 if (instanceWrapper == null) {
  instanceWrapper = createBeanInstance(beanName, mbd, args);
 }
 Object bean = instanceWrapper.getWrappedInstance();
 Class<?> beanType = instanceWrapper.getWrappedClass();
 if (beanType != NullBean.class) {
  mbd.resolvedTargetType = beanType;
 }
 // Allow post-processors to modify the merged bean definition.
 synchronized (mbd.postProcessingLock) {
  if (!mbd.postProcessed) {
   try {
    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
   }
   catch (Throwable ex) {
    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
      "Post-processing of merged bean definition failed", ex);
   }
   mbd.markAsPostProcessed();
  }
 }
    //省略
 try {
  populateBean(beanName, mbd, instanceWrapper);
  exposedObject = initializeBean(beanName, exposedObject, mbd);
 }
    //省略
 return exposedObject;
}

大家看到，在初始化 Bean 例項之後，有一個 applyMergedBeanDefinitionPostProcessors 方法，這個方法就是用來觸發 MergedBeanDefinitionPostProcessor 執行的。

populateBean 方法是給 Bean 的各個屬性填充值的，填充完成之後，呼叫 initializeBean 方法進行剩餘的初始化工作，在 initializeBean 方法中，呼叫了其餘的 BeanPostProcessor。

4.1 觸發 MergedBeanDefinitionPostProcessor

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
 for (MergedBeanDefinitionPostProcessor processor : getBeanPostProcessorCache().mergedDefinition) {
  processor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
 }
}

4.2 觸發其他 BeanPostProcessor

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
 invokeAwareMethods(beanName, bean);
 Object wrappedBean = bean;
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
 }
 try {
  invokeInitMethods(beanName, wrappedBean, mbd);
 }
 catch (Throwable ex) {
  throw new BeanCreationException(
    (mbd != null ? mbd.getResourceDescription() : null), beanName, ex.getMessage(), ex);
 }
 if (mbd == null || !mbd.isSynthetic()) {
  wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
 }
 return wrappedBean;
}

大家看這個順序，先是調 applyBeanPostProcessorsBeforeInitialization，這個裡邊最終就觸發到了 BeanPostProcessor#postProcessBeforeInitialization 方法；然後呼叫 invokeInitMethods，afterPropertiesSet 和自定義的 init-method 都在這裡被觸發；最後呼叫 applyBeanPostProcessorsAfterInitialization，這個裡邊最終就觸發到 BeanPostProcessor#postProcessAfterInitialization 方法。

好啦，這就是和小夥伴們梳理的 BeanPostProcessor 原理了，感興趣的小夥伴可以自己 DEBUG 跑一遍哦～

BeanPostProcessor 是在何時介入 Bean 建立的？