文章目录

Pre
源码解读
- 总体流程
- 源码分析
细节解析
- 【初始化对应的集合 & 遍历用户自己手动添加的后置处理器】
- 【调用实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor】
- 【调用实现了Ordered接口的BeanDefinitionRegistryPostProcessor】
- 【调用剩余的BeanDefinitionRegistryPostProcessor】
- 【开始调用BeanDefinitionRegistryPostProcessor的父类方法】
- 【寻找BeanFactoryPostProcessor】
- 【执行BeanFactoryPostProcessor】
小结

Pre

接上文 Spring5源码 - 04 invokeBeanFactoryPostProcessors 源码解读_1

源码解读

总体流程

我们知道了 BeanFactoryPostProcessors的执行时机是：在扫描完成之后，Bean实例化之前 , 那Spring是如何去回调BeanFactoryPostProcessors的呢？

invokeBeanFactoryPostProcessors就是扫描项目将扫描到的类转换成BeanDefinition 然后回调BeanFactoryPostProcessors的地方，故这个方法很重要。

源码分析

/****调用bean工厂的后置处理器* 1)BeanDefinitionRegistryPostProcessor(先被执行)*   所有的bean定义信息将要被加载到容器中，Bean实例还没有被初始化* 2)BeanFactoryPostProcessor(后执行)*   所有的Bean定义信息已经加载到容器中，但是Bean实例还没有被初始化.* 该方法的作用就是用于ioc容器加载bean定义前后进行处理* BeanDefinitionRegistryPostProcessor是bean定义解析前调用*      1)实现了PriorityOrdered接口的*        2)实现了Ordered接口的*        3)没有实现任何的优先级接口的*        4)因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor接口的子接口，实现BeanFactoryPostProcessor的方法* BeanFactoryPostProcessor是bean定义解析后调用*     1)实现了PriorityOrdered接口的*     2)实现了Ordered接口的*        3)没有实现任何的优先级接口的* @author Juergen Hoeller* @since 4.0*/
final class PostProcessorRegistrationDelegate {public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {//第一步:首先调用BeanDefinitionRegistryPostProcessor的后置处理器Set<String> processedBeans = new HashSet<>();//判断我们的beanFacotry实现了BeanDefinitionRegistryif (beanFactory instanceof BeanDefinitionRegistry) {//强行把我们的bean工厂转为BeanDefinitionRegistryBeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;//保存BeanFactoryPostProcessor类型的后置List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();//保存BeanDefinitionRegistryPostProcessor类型的后置处理器List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();//循环我们传递进来的beanFactoryPostProcessorsfor (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {//判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessorif (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {//进行强制转化BeanDefinitionRegistryPostProcessor registryProcessor =(BeanDefinitionRegistryPostProcessor) postProcessor;//调用他作为BeanDefinitionRegistryPostProcessor的处理器的后置方法registryProcessor.postProcessBeanDefinitionRegistry(registry);//添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中registryProcessors.add(registryProcessor);}else {//若没有实现BeanDefinitionRegistryPostProcessor 接口，那么他就是BeanFactoryPostProcessor//把当前的后置处理器加入到regularPostProcessors中regularPostProcessors.add(postProcessor);}}//定义一个集合用户保存当前准备创建的BeanDefinitionRegistryPostProcessorList<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();//第一步:去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称for (String ppName : postProcessorNames) {//判断是否实现了PriorityOrdered接口的if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));//同时也加入到processedBeans集合中去processedBeans.add(ppName);}}//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序sortPostProcessors(currentRegistryProcessors, beanFactory);//把他加入到用于保存到registryProcessors中registryProcessors.addAll(currentRegistryProcessors);/*** 在这里典型的BeanDefinitionRegistryPostProcessor就是ConfigurationClassPostProcessor* 用于进行bean定义的加载 比如我们的包扫描，@import  等等。。。。。。。。。*/invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);//调用完之后，马上clea掉currentRegistryProcessors.clear();//去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称for (String ppName : postProcessorNames) {//表示没有被处理过,且实现了Ordered接口的if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));//同时也加入到processedBeans集合中去processedBeans.add(ppName);}}//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序sortPostProcessors(currentRegistryProcessors, beanFactory);//把他加入到用于保存到registryProcessors中registryProcessors.addAll(currentRegistryProcessors);//调用他的后置处理方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);//调用完之后，马上clea掉currentRegistryProcessors.clear();//调用没有实现任何优先级接口的BeanDefinitionRegistryPostProcessor//定义一个重复处理的开关变量 默认值为trueboolean reiterate = true;//第一次就可以进来while (reiterate) {//进入循环马上把开关变量给改为faslereiterate = false;//去容器中获取BeanDefinitionRegistryPostProcessor的bean的处理器名称postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);//循环上一步获取的BeanDefinitionRegistryPostProcessor的类型名称for (String ppName : postProcessorNames) {//没有被处理过的if (!processedBeans.contains(ppName)) {//显示的调用getBean()的方式获取出该对象然后加入到currentRegistryProcessors集合中去currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));//同时也加入到processedBeans集合中去processedBeans.add(ppName);//再次设置为truereiterate = true;}}//对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序sortPostProcessors(currentRegistryProcessors, beanFactory);//把他加入到用于保存到registryProcessors中registryProcessors.addAll(currentRegistryProcessors);//调用他的后置处理方法invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);//进行clearcurrentRegistryProcessors.clear();}//调用实现了BeanDefinitionRegistryPostProcessor的接口 他是他也同时实现了BeanFactoryPostProcessor的方法invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);//调用BeanFactoryPostProcessor成品的不是通过getBean的invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}else { //若当前的beanFacotory没有实现了BeanDefinitionRegistry 直接调用 beanFacotoryPostProcessor接口的方法进行后置处理invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);}//获取容器中所有的 BeanFactoryPostProcessorString[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);//保存BeanFactoryPostProcessor类型实现了priorityOrderedList<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();//保存BeanFactoryPostProcessor类型实现了Ordered接口的List<String> orderedPostProcessorNames = new ArrayList<>();//保存BeanFactoryPostProcessor没有实现任何优先级接口的List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {//processedBeans包含的话，表示在上面处理BeanDefinitionRegistryPostProcessor的时候处理过了if (processedBeans.contains(ppName)) {// skip - already processed in first phase above}//判断是否实现了PriorityOrderedelse if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));}//判断是否实现了Orderedelse if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}//没有实现任何的优先级接口的else {nonOrderedPostProcessorNames.add(ppName);}}// 先调用BeanFactoryPostProcessor实现了 PriorityOrdered接口的sortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);//再调用BeanFactoryPostProcessor实现了 Ordered.List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();for (String postProcessorName : orderedPostProcessorNames) {orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}sortPostProcessors(orderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);//调用没有实现任何方法接口的List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();for (String postProcessorName : nonOrderedPostProcessorNames) {nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));}invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);// Clear cached merged bean definitions since the post-processors might have// modified the original metadata, e.g. replacing placeholders in values...beanFactory.clearMetadataCache();}......
}

是不是发现这个方法中的好几个部分的代码很相似？

细节解析

我们说这个BeanFactoryPostProcessors 大部分情况下是没有值的，那什么场景下会有有值呢？

举个例子

addBeanFactoryPostProcessor

所以

就取到值了。

那继续分段来解读Spring的设计思想

【初始化对应的集合 & 遍历用户自己手动添加的后置处理器】

来分解下代码

判断当前的beanFactory是不是 BeanDefinitionRegistry。这个绝大部分情况是成立的，除非开发者继承整个工厂的顶级接口AliasRegistry去实现一个完全由自己实现的工厂，这个判断才不会成立。
紧接着定义了2个集合：第一个集合 List<BeanFactoryPostProcessor> regularPostProcessors 看List中的类型 BeanFactoryPostProcessor ，这个地方是存放我们手动提供给Spring的后置处理器，注意这个手动，并不是又Spring扫描得到的。比如下面这种方式ac.addBeanFactoryPostProcessor

AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();ac.addBeanFactoryPostProcessor(new ArtisanTest04());ac.register();ac.refresh();

第二个集合是干啥的呢？ List<BeanDefinitionRegistryPostProcessor> registryProcessors 同样的看类型 BeanDefinitionRegistryPostProcessor ，这个就是存放执行过程中找到的BeanDefinitionRegistryPostProcessor

存放它的意图是什么呢？

因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor的子类，在整个执行调用过程中，我们会先执行BeanDefinitionRegistryPostProcessor类型的后置处理器，在执行BeanFactoryPostProcessor类型的，但是因为是子类和父类的关系，为了避免后面重复的获取，就也把BeanDefinitionRegistryPostProcessor存储起来，等待BeanDefinitionRegistryPostProcessor的方法执行完毕之后，就直接执行它父类的方法，这也能够从侧面证明BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法是优先于BeanFactoryPostProcessor的postProcessBeanFactory方法先执行的

紧接着就是循环处理开发人员手工添加的BeanFactoryPostProcessor . 如果是BeanDefinitionRegistryPostProcessor的就先调用，如果是BeanFactoryPostProcessor类型的，就先放到regularPostProcessors集合中，等待BeanDefinitionRegistryPostProcessor执行完毕后，在进行BeanFactoryPostProcessor的调用 .

【调用实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor】

这是第一个重点的Code , 首先会先去在整个bean工厂寻找BeanDefinitionRegistryPostProcessor类型的并且实现了类PriorityOrdered的类 .

注意此时没有任何人向beanFactory中放置该类型的类，只有一个实现，就是Spring在开天辟地的时候初始化的几个BeanDefinition，其中有一个符合条件

ConfigurationClassPostProcessor,这个类是Spring初始化的时候就放置到容器里面的,主要作用就是解析Spring配置类，然后扫描项目，将项目内符合条件的类，比如@Server、@Bean之流加了注解的类，转换成BeanDefinition，然后存放到容器，请注意一点，此时经过ConfigurationClassPostProcessor的执行之后 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());，Spring容器中就有值了，有了我们配置的所有的应该被Spring管理的类！此时再去寻找就会寻找我们自己定义的一些后置处理器了！

【调用实现了Ordered接口的BeanDefinitionRegistryPostProcessor】

我们看下找到了啥

继续看是否符合条件

这里不会处理，因为已经处理过了 !processedBeans.contains(ppName)

这段代码的含义就是：基本和上面的代码一样，唯一不同的就是本次寻找的是实现了Ordered了的接口，因为上面ConfigurationClassPostProcessor的执行，此时容器内部就有了我们自己定义的类信息，所以如果我们有一个类实现了BeanDefinitionRegistryPostProcessor且实现了Ordered接口，那么此时就能够被执行了。

【调用剩余的BeanDefinitionRegistryPostProcessor】

经过上面两个实现了PriorityOrdered、Ordered接口两种BeanDefinitionRegistryPostProcessor之后，优先级别最高的已经执行完毕了，后续只需要去执行剩余的BeanDefinitionRegistryPostProcessor就可以了 .

这里为什么有个循环呢？

因为，BeanDefinitionRegistryPostProcessor是一个接口，在回调他的方法的时候，里面的方法可能又注册了一些BeanDefinition，这些BeanDefinition也是BeanDefinitionRegistryPostProcessor类型的。

举个例子就像俄罗斯套娃一样，每一个里面都会进行一些注册，不知道会套多少层，所以要进行一个死循环，只要有，就一直遍历寻找，直到执行完为止！类似于下图这样：

【开始调用BeanDefinitionRegistryPostProcessor的父类方法】

第一行：执行BeanDefinitionRegistryPostProcessor的父类方法，也就是BeanFactoryPostProcessor的接口方法，因为BeanDefinitionRegistryPostProcessor是BeanFactoryPostProcessor类型的，为了避免重复查询就事先执行了，他的优先级高于普通的BeanFactoryPostProcessor

第二行：执行用户手动添加的BeanFactoryPostProcessor

【寻找BeanFactoryPostProcessor】

看下找到了谁？

判断是否有处理

主要流程

先寻找所有的BeanFactoryPostProcessor类
初始化三个集合，实现PriorityOrdered的集合、实现了Ordered的集合、剩余的BeanFactoryPostProcessor集合
遍历寻找到的所有的BeanFactoryPostProcessor类
判断当 processedBeans集合已经存在，也就是被BeanDefinitionRegistryPostProcessor处理过的直接跳过，避免重复执行！
如果是实现了PriorityOrdered接口，直接getBean()提前实例化后,加入到对应的集合，注意此时已经进行实例化！
如果是实现了Ordered接口，那么将他的名字放到对应的集合中，注意此时他没有实例化！
将普通的BeanFactoryPostProcessor放到对应的集合，注意也没有实例化

通过上述， 只有PriorityOrdered类型的BeanFactoryPostProcessor被实例化了，然后放置到了集合中去！

【执行BeanFactoryPostProcessor】

先对实现了PriorityOrdered的集合进行排序后执行，注意，因为上面在添加到集合的时候已经通过igetBean()实例化了，所以，此时可以直接执行
遍历实现了Ordered的beanName集合，然后通过getBean,实例化对应的BeanFactoryPostProcessor,放到对应的集合orderedPostProcessors，排序后进行执行
遍历剩余的BeanFactoryPostProcessor,然后getBean实例化后，直接执行

小结

至此invokeBeanFactoryPostProcessors 所有的Code就分析了，方法执行完以后就完成了对所有符合条件的对象的扫描 ，如果有符合条件的，会通过getBean方法提前实例化。

Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_2相关推荐

Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_3细说invokeBeanDefinitionRegistryPostProcessors
文章目录 Pre 细说invokeBeanDefinitionRegistryPostProcessors 流程图源码分析解析配置类 parser.parse(candidates) 配置类注册到 ...
Spring5源码 - 04 invokeBeanFactoryPostProcessors 源码解读_1
文章目录 Pre refresh() Spring的设计源码验证 Pre 接上文 Spring5源码 - 03 普通对象对应的BeanDefinition是如何存入DefaultListableBe ...
面试官系统精讲Java源码及大厂真题 - 05 ArrayList 源码解析和设计思路
05 ArrayList 源码解析和设计思路耐心和恒心总会得到报酬的. --爱因斯坦引导语 ArrayList 我们几乎每天都会使用到,但真正面试的时候,发现还是有不少人对源码细节说不清楚,给面试 ...
【ElasticSearch】Es 源码之 CcrRestoreSourceService 源码解读
文章目录 1.概述 2.构造方法 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件的CcrRestoreSourceSe ...
【ElasticSearch】Es 源码之 AutoFollowCoordinator 源码解读
文章目录 1.概述 2.构造方法 3. start方法 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件的AutoFol ...
【ElasticSearch】Es 源码之 CleanerService 源码解读
文章目录 1.概述 2.构造方法 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件的CleanerService ,其中 ...
【ElasticSearch】Es 源码之 Exporters 源码解读
文章目录 1.概述 2.start 2.1 initExporters 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件 ...
【ElasticSearch】Es 源码之 CacheService 源码解读
文章目录 1.概述 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件的LifecycleComponent ,其中初始化 ...
【ElasticSearch】Es 源码之 AsyncSearchMaintenanceService 源码解读
文章目录 1.概述 1.概述在博客 [ElasticSearch]Es 源码之 LifecycleComponent 源码解读中初始化了相关插件的LifecycleComponent ,其中初始化 ...

Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_2