Spring5源码 - 05 invokeBeanFactoryPostProcessors 源码解读_2

文章目录

• Pre
• 源码解读
• 细节解析

---

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的设计思想

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

来分解下代码

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

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

存放它的意图是什么呢？

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

---

3. 紧接着就是循环处理开发人员手工添加的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】

看下找到了谁？

判断是否有处理

主要流程

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

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

---

【执行BeanFactoryPostProcessor】

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

支持所有的流程就走完了 ，对象也被实例化完成 。

---