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实现了BeanDefinitionRegistry if (beanFactory instanceof BeanDefinitionRegistry) { //强行把我们的bean工厂转为BeanDefinitionRegistry BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory; //保存BeanFactoryPostProcessor类型的后置 List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>(); //保存BeanDefinitionRegistryPostProcessor类型的后置处理器 List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>(); //循环我们传递进来的beanFactoryPostProcessors for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) { //判断我们的后置处理器是不是BeanDefinitionRegistryPostProcessor if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) { //进行强制转化 BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor; //调用他作为BeanDefinitionRegistryPostProcessor的处理器的后置方法 registryProcessor.postProcessBeanDefinitionRegistry(registry); //添加到我们用于保存的BeanDefinitionRegistryPostProcessor的集合中 registryProcessors.add(registryProcessor); } else {//若没有实现BeanDefinitionRegistryPostProcessor 接口，那么他就是BeanFactoryPostProcessor //把当前的后置处理器加入到regularPostProcessors中 regularPostProcessors.add(postProcessor); } } //定义一个集合用户保存当前准备创建的BeanDefinitionRegistryPostProcessor List<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 //定义一个重复处理的开关变量 默认值为true boolean reiterate = true; //第一次就可以进来 while (reiterate) { //进入循环马上把开关变量给改为fasle reiterate = 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); //再次设置为true reiterate = true; } } //对currentRegistryProcessors集合中BeanDefinitionRegistryPostProcessor进行排序 sortPostProcessors(currentRegistryProcessors, beanFactory); //把他加入到用于保存到registryProcessors中 registryProcessors.addAll(currentRegistryProcessors); //调用他的后置处理方法 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry); //进行clear currentRegistryProcessors.clear(); } //调用实现了BeanDefinitionRegistryPostProcessor的接口 他是他也同时实现了BeanFactoryPostProcessor的方法 invokeBeanFactoryPostProcessors(registryProcessors, beanFactory); //调用BeanFactoryPostProcessor成品的不是通过getBean的 invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory); } else { //若当前的beanFacotory没有实现了BeanDefinitionRegistry 直接调用 beanFacotoryPostProcessor接口的方法进行后置处理 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); } //获取容器中所有的 BeanFactoryPostProcessor String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false); //保存BeanFactoryPostProcessor类型实现了priorityOrdered List<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 } //判断是否实现了PriorityOrdered else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class)); } //判断是否实现了Ordered else 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方法提前实例化。
