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

......
}

  

 

  
1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
114
  
115
  
116
  
117
  
118
  
119
  
120
  
121
  
122
  
123
  
124
  
125
  
126
  
127
  
128
  
129
  
130
  
131
  
132
  
133
  
134
  
135
  
136
  
137
  
138
  
139
  
140
  
141
  
142
  
143
  
144
  
145
  
146
  
147
  
148
  
149
  
150
  
151
  
152
  
153
  
154
  
155
  
156
  
157
  
158
  
159
  
160
  
161
  
162
  
163
  
164
  
165
  
166
  
167
  
168
  
169
  
170
  
171
  
172
  
173
  
174
  
175
  
176
  
177
  
178
  
179
  
180
  
181
  
182
  
183
  
184
  
185
  
186
  
187
  
188
  
189
  
190
  
191
  
192
  
193
  
194
  
195
  
196
  
197
  
198
  
199
  
200
 

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

细节解析

我们说 这个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();

  

 

  
1
  
2
  
3
  
4
 

第二个集合是干啥的呢？ 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实例化后，直接执行

小结

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

文章来源: artisan.blog.csdn.net，作者：小小工匠，版权归原作者所有，如需转载，请联系作者。

原文链接：artisan.blog.csdn.net/article/details/108656518