Spring 源码阅读笔记（六）主线 registerBeanPostProcessors解读

Spring 源码阅读笔记（六）

前篇导航

Spring 源码阅读笔记(一)
Spring 源码阅读笔记(二)
Spring 源码阅读笔记(三)
Spring 源码阅读笔记(四)
Spring 源码阅读笔记(五)

前篇回顾

在上一篇文章中，有介绍到上方图中的prepareBeanFactory方法，看到这个方法只是为工厂设置了一些成员变量，例如BeanpostProcessors，ignoredDependencyInterfaces，resolvableDependencies。

正式开始

postProcessBeanFactory

protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
}
复制代码

这个方法比较简单，一个模板方法，看一下他的重写类，有没有涉及到我们的类

图中可以看出，都是spring-web模块下的，这里不是我们关注的重点，跳过。

invokeBeanFactoryPostProcessors

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

   // Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime
   // (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)
   if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
      beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
      beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
   }
}
复制代码

上面的代码看的出来，比较关键的地方是。

PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());

首先看一下这个方法额两个入参。

1. beanFactory 这个很容易解释
2. getBeanFactoryPostProcessors() 第二个参数是一个方法，字面意思是获取Bean工厂的后置处理器。先看下这部分的代码。

public List<BeanFactoryPostProcessor> getBeanFactoryPostProcessors() {
   return this.beanFactoryPostProcessors;
}
复制代码

读这个意思是，在applicationContext里有个属性，这个就是get方法。通过他的add方法，我印象中没有方法中调过方法。所以获取到的大概率是一个empty的List。

Debug一下确实是这么回事，这个方法的名字是invokeBeanFactoryPostProcessors，字面意思就是调用Bean工厂后处理器，这里因为我们没获取到，读也只能读哥寂寞，所以这个方法可以跳过。

registerBeanPostProcessors

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
   PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
复制代码

这里的代码只有一行，调用了一个方法registerBeanPostProcessors，这里看入参。

1. beanFactory
2. this

第一个值做什么用的，可以猜得到，注册就是注册到这个Bean工厂中。第二个参数传入了，当前的this就是applicationContext，因为PostProcessor也是Bean，所以这里猜想一下，是用来获取BeanDefinition的。接下来看一下这个方法的实现代码。

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));

   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.
   // 将实现 PriorityOrdered、Ordered 和其余部分的 BeanPostProcessor 分开。
   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);
      }
   }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
   // 首先，注册实现 PriorityOrdered 的 BeanPostProcessor。
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
   // 接下来，注册实现 Ordered 的 BeanPostProcessor。
   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);

   // Now, register all regular BeanPostProcessors.
   // 现在，注册所有常规的 BeanPostProcessor。
   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);

   // Finally, re-register all internal BeanPostProcessors.
   // 最后，重新注册所有内部 BeanPostProcessor。
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // Re-register post-processor for detecting inner beans as ApplicationListeners,
   // moving it to the end of the processor chain (for picking up proxies etc).
   // 重新注册用于将内部 bean 检测为 ApplicationListeners 的后处理器，将其移动到处理器链的末尾（用于拾取代理等）。
   beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
复制代码

由于代码长度过长，阅读方法还是和之前的文章一样，采取分段的方式阅读。

第一段代码

String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
复制代码

由于之前在ObtainBeanFactory方法时，BeanFactory已经把Bean Definition加载进入了BeanFacotry中，所以在上述代码中，第一行获取了所有实现BeanPostProcessor接口的BeanName。

第二行中获取了申明了int的变量，他的组成是当前Bean工厂中的PostProcessor的数量 + 1 + 刚刚从工厂取到的自定义的PostProcess的数量。
这里为什么+1呢，在下一行代码有解释，因为他向BeanFactory中又追加了一个BeanPostProcessorChecker。

这个类是做什么的呢，根据字面意思和他的入参，我的理解是检查Bean什么的。这里后面有涉及的话，再过来看。

第二段代码

// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 将实现 PriorityOrdered、Ordered 和其余部分的 BeanPostProcessor 分开。
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);
   }
}
复制代码

这里相当于做了个分类汇总，把实现PriorityOrdered，Ordered的PostProcessor和其他的区分开来，分别放入不同的List当中去
关于这两个类，我想我就不用介绍了，就是用来Bean加载时排序使用的，应该都用过。
值得注意的是，这里除了PriorityOrdered储存的是实例，其他的都只存了Name，存储的并不是实例。

该方法中有一个getBean的方法，里面代码比较多，暂时就不关注他的细节了，后面单开一个章节讲解。

第三段代码

// First, register the BeanPostProcessors that implement PriorityOrdered.
// 首先，注册实现 PriorityOrdered 的 BeanPostProcessor。
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);


复制代码

两个方法比较简单，这里简单讲解一下，下面的代码中会有复用

sortPostProcessors 排序方法

// 排序方法
private static void sortPostProcessors(List<?> postProcessors, ConfigurableListableBeanFactory beanFactory) {
   // Nothing to sort?
   if (postProcessors.size() <= 1) {
      return;
   }
   Comparator<Object> comparatorToUse = null;
   if (beanFactory instanceof DefaultListableBeanFactory) {
      comparatorToUse = ((DefaultListableBeanFactory) beanFactory).getDependencyComparator();
   }
   if (comparatorToUse == null) {
      comparatorToUse = OrderComparator.INSTANCE;
   }
   postProcessors.sort(comparatorToUse);
}
复制代码

因为传进来的PostProcessor，都实现了Order接口，所以他们具备排序的能力，factory传进来的目的是为了判断，Factory是否有默认的排序器，如果没有的话，默认为排序方法传入Order的排序规则。

registerBeanPostProcessors 注册BeanPostProcessors

private static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {

   if (beanFactory instanceof AbstractBeanFactory) {
      // Bulk addition is more efficient against our CopyOnWriteArrayList there
      ((AbstractBeanFactory) beanFactory).addBeanPostProcessors(postProcessors);
   }
   else {
      for (BeanPostProcessor postProcessor : postProcessors) {
         beanFactory.addBeanPostProcessor(postProcessor);
      }
   }
}
复制代码

这个方法较为简单，只是个简单的封装，防止外部写重复代码的。

第四段代码

// Next, register the BeanPostProcessors that implement Ordered.
// 接下来，注册实现 Ordered 的 BeanPostProcessor。
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);
复制代码

这个代码扫一眼就可以了，做的工作和他的注释说的是一样的。把实现order接口的注册到工厂中。最后两行代码和第三段代码的意思一样。

第五段代码

// Now, register all regular BeanPostProcessors.
// 现在，注册所有常规的 BeanPostProcessor。
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);
复制代码

这一段代码和上面一段代码类似，表达的一样的意思，唯一的区别就是，这里不需要把Bean排序了，因为这里注册的PostProcessor没有排序功能。

第六段代码

// Finally, re-register all internal BeanPostProcessors.
// 最后，重新注册所有内部 BeanPostProcessor。
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
复制代码

在前面的代码中，各位会发现for循环中，有个if，去判断是否MergedBeanDefinitionPostProcessor的，这里就是把那些PostProcessor，注册进容器，这里其实我有个疑惑，就是这个接口是干嘛，于是我好奇的点进去看了下他的实现，一看不得了。

这两个注解大家应该很熟悉，所以看来这个属性了不得，我们后面再来解析这个东西。

第七段代码

// Re-register post-processor for detecting inner beans as ApplicationListeners,
// 重新注册用于将内部 bean 检测为 ApplicationListeners 的后处理器，将其移动到处理器链的末尾（用于拾取代理等）。
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
复制代码

讲真的这个ApplicationListenerDetector类我目前没搞懂是干嘛的，后面读到他什么时候运行的我们再来解析这个类吧。

告一段落

今天看到registerBeanPostProcessors方法，还是有点简单的，这里只是对一些PostProcessor进行注册，还没有到invoke的流程。

结束语

写文章的目的是为了帮助自己巩固知识，写的不好或者错误的地方可以在评论区指出。如果您看了文章觉得对您有所帮助可以点个赞，如果发现有些问题产生了疑惑，或者不明白的可以评论，一定知无不言。当然也希望和大家交个朋友，相互学习。