Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_2

太过爱你忘了你带给我的痛 2022-12-08 05:08 179阅读 0赞

### 文章目录 ###

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center]

--------------------

# Pre #

接上文 [Spring5源码 - 04 invokeBeanFactoryPostProcessors 源码解读\_1][Spring5_ - 04 invokeBeanFactoryPostProcessors _1]

--------------------

# 源码解读 #

## 总体流程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 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();
    	}
    
    ......
    }

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

--------------------

# 细节解析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 2]

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

举个例子  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 4]

addBeanFactoryPostProcessor

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 5]  
所以

![在这里插入图片描述][20200918005601531.png_pic_center]  
就取到值了。

--------------------

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 6]  
来分解下代码

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 7]

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

存放它的意图是什么呢？

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

--------------------

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

--------------------

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 8]  
 这是第一个重点的Code , 首先会先去在整个bean工厂寻找`BeanDefinitionRegistryPostProcessor`类型的并且实现了类`PriorityOrdered`的类 .

注意此时没有任何人向`beanFactory`中放置该类型的类，只有一个实现，就是Spring在开天辟地的时候初始化的几个BeanDefinition，其中有一个符合条件  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 9]

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 10]

--------------------

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 11]

我们看下找到了啥

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 12]  
继续 看是否符合条件

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

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

--------------------

## 【调用剩余的BeanDefinitionRegistryPostProcessor】 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 13]

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

这里为什么有个循环呢？

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 14]

--------------------

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 15]

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

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

--------------------

## 【寻找BeanFactoryPostProcessor】 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 16]  
看下找到了谁？

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 17]

判断是否有处理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 18]

主要流程

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

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

--------------------

## 【执行BeanFactoryPostProcessor】 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 19]

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

--------------------

# 小结 #

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

--------------------

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/d229d0570a7d4a8ba3c984ec2e53c99f.png
[Spring5_ - 04 invokeBeanFactoryPostProcessors _1]: https://artisan.blog.csdn.net/article/details/108620669
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/a66224f7058a4050bce5e4af3cc99e23.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/98125b42ac174249afcd045794f6ad62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/0fb0da8e5580407787e12250718549b1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/5223d5c073f044349fb0cd2f15cc7fab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/c791d2964d8e4d1594451fc0ab63db05.png
[20200918005601531.png_pic_center]: /images/20221123/4d8351ca2a514d2a82e9f4442e802414.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/8f1e1d164fd440a589181466420bd940.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/fc0c0b22f3724cb2af57ce66d44543d9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/91a46758512f42a58cabc711c99415e2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 9]: /images/20221123/6d597b1728d949559ea826c61673f2de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 10]: /images/20221123/271471748c754e1599a69ef9035c70e9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 11]: /images/20221123/73403934bf204dbfb579bda743907865.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 12]: /images/20221123/eeefd481a04f435f8cdba5f4107fbda2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 13]: /images/20221123/55b7b1ec996e4b978a2bca5d1704cf6b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 14]: /images/20221123/5e5a6036d22742c6b0ae814075916293.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 15]: /images/20221123/a0440a35bbd7495ea93e6ba84de552ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 16]: /images/20221123/d7131d66229841bdb8a9123b7e890063.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 17]: /images/20221123/d714429769aa493585c1beb4bd08328f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 18]: /images/20221123/620db60c58034b81890be454096a1072.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3lhbmdzaGFuZ3dlaQ_size_16_color_FFFFFF_t_70_pic_center 19]: /images/20221123/2a3a2504bf504ab3928f457990455e4f.png