Spring源码之五postProcessBeanFactory

Spring源码之BeanFactoryPostProcessor(后置处理器)。

有点水平的Spring开发人员想必都知道BeanFactoryPostProcessor也就是常说的后置管理器，这是Spirng生命周期中的一个接口，实现这个接口可以在beanFactory初始化前做一些事。

我们熟知的Spring和Mybatis的结合，正是因为Mybatis实现了BeanFactoryPostProcessor，它的重要性不言而喻，深入理解他对于切入Mybatis源码有着深刻的意义。

如下图是简单的应用：

image-20220301094331881

还是先贴上refresh()的源码

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
@Override
public void refresh() throws BeansException, IllegalStateException {
	synchronized (this.startupShutdownMonitor) {
		// Prepare this context for refreshing.
		//1、刷新前的准备
		prepareRefresh();

		// Tell the subclass to refresh the internal bean factory.
		//2、将会初始化 BeanFactory、加载 Bean、注册 Bean
		ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

		// Prepare the bean factory for use in this context.
		//3、设置 BeanFactory 的类加载器，添加几个 BeanPostProcessor，手动注册几个特殊的 bean
		prepareBeanFactory(beanFactory);

		try {
			//4、模板方法
			// Allows post-processing of the bean factory in context subclasses.
			postProcessBeanFactory(beanFactory);

			// Invoke factory processors registered as beans in the context.
			//执行BeanFactory后置处理器
			invokeBeanFactoryPostProcessors(beanFactory);

			// 5、Register bean processors that intercept bean creation.
			//注册bean后置处理器
			registerBeanPostProcessors(beanFactory);

			// Initialize message source for this context.
			//国际化
			initMessageSource();

			// Initialize event multicaster for this context.
			initApplicationEventMulticaster();

			// Initialize other special beans in specific context subclasses.
			//6、模板方法--springboot实现了这个方法
			onRefresh();

			// Check for listener beans and register them.
			//7、注册监听器
			registerListeners();

			// Instantiate all remaining (non-lazy-init) singletons.
			//8、完成bean工厂的初始化**方法**********************************************
			finishBeanFactoryInitialization(beanFactory);

			//9、 Last step: publish corresponding event.
			finishRefresh();
		}

		catch (BeansException ex) {
			if (logger.isWarnEnabled()) {
				logger.warn("Exception encountered during context initialization - " +
						"cancelling refresh attempt: " + ex);
			}

			// Destroy already created singletons to avoid dangling resources.
			destroyBeans();

			// Reset 'active' flag.
			cancelRefresh(ex);

			// Propagate exception to caller.
			throw ex;
		}

		finally {
			// Reset common introspection caches in Spring's core, since we
			// might not ever need metadata for singleton beans anymore...
			resetCommonCaches();
		}
	}
}

benafactory源码的处理位于第三个位置。

主要涉及到两个方法postProcessBeanFactory(beanFactory);

和invokeBeanFactoryPostProcessors(beanFactory);

image-20220301100307555

postProcessBeanFactory(beanFactory)点进去发现是一个空方法，具体的执行在invokeBeanFactoryPostProcessors(beanFactory);中

image-20220301100448919

我们在invokeBeanFactoryPostProcessors方法上打断点一探究竟。第一次看的时候觉得这是什么玩意，这么长，耐住性子一步步的往下看。

方法虽长大概总结一下就是，判断beanFactory类型，然后将注册的BeanPostFactory放入、排好顺序、执行。

invokeBeanFactoryPostProcessors 方法的内容其实比较少，大部分过程在注释都已经写清楚，这边在稍微总结一下。

整个 invokeBeanFactoryPostProcessors 方法围绕两个接口，BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor，其中 BeanDefinitionRegistryPostProcessor 继承了 BeanFactoryPostProcessor 。

BeanDefinitionRegistryPostProcessor 主要用来在常规 BeanFactoryPostProcessor 检测开始之前注册其他 Bean 定义，说的简单点，就是 BeanDefinitionRegistryPostProcessor 具有更高的优先级，执行顺序在 BeanFactoryPostProcessor 之前。

具体的过程看注释吧

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
public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

	// Invoke BeanDefinitionRegistryPostProcessors first, if any.
	Set<String> processedBeans = new HashSet<>();


	// 1.判断beanFactory是否为BeanDefinitionRegistry，beanFactory为DefaultListableBeanFactory,
	// 而DefaultListableBeanFactory实现了BeanDefinitionRegistry接口，因此这边为true
	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		// 用于存放普通的BeanFactoryPostProcessor
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		// 用于存放BeanDefinitionRegistryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		// 2.首先处理入参中的beanFactoryPostProcessors
		// 遍历所有的beanFactoryPostProcessors, 将BeanDefinitionRegistryPostProcessor和普通BeanFactoryPostProcessor区分开
		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				// 2.1 如果是BeanDefinitionRegistryPostProcessor
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				// 2.1.1 直接执行BeanDefinitionRegistryPostProcessor接口的postProcessBeanDefinitionRegistry方法
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				// 2.1.2 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
				registryProcessors.add(registryProcessor);
			}
			else {
				// 2.2 否则，只是普通的BeanFactoryPostProcessor
				// 2.2.1 添加到regularPostProcessors(用于最后执行postProcessBeanFactory方法)
				regularPostProcessors.add(postProcessor);
			}
		}

		// Do not initialize FactoryBeans here: We need to leave all regular beans
		// uninitialized to let the bean factory post-processors apply to them!
		// Separate between BeanDefinitionRegistryPostProcessors that implement
		// PriorityOrdered, Ordered, and the rest.
		// 用于保存本次要执行的BeanDefinitionRegistryPostProcessor
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		// 3.调用所有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor实现类
		// 3.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的Bean的beanName
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		// 3.2 遍历postProcessorNames
		for (String ppName : postProcessorNames) {
			// 3.3 校验是否实现了PriorityOrdered接口
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				// 3.4 获取ppName对应的bean实例, 添加到currentRegistryProcessors中,
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				// 3.5 将要被执行的加入processedBeans，避免后续重复执行
				processedBeans.add(ppName);
			}
		}
		// 3.6 进行排序(根据是否实现PriorityOrdered、Ordered接口和order值来排序)
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		// 3.7 添加到registryProcessors(用于最后执行postProcessBeanFactory方法)
		registryProcessors.addAll(currentRegistryProcessors);
		// 3.8 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		// 3.9 执行完毕后, 清空currentRegistryProcessors
		currentRegistryProcessors.clear();

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		// 4.调用所有实现了Ordered接口的BeanDefinitionRegistryPostProcessor实现类（过程跟上面的步骤3基本一样）
		// 4.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类, 这边重复查找是因为执行完上面的BeanDefinitionRegistryPostProcessor,
		// 可能会新增了其他的BeanDefinitionRegistryPostProcessor, 因此需要重新查找
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			// 校验是否实现了Ordered接口，并且还未执行过
			if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		// 4.2 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		// 5.最后, 调用所有剩下的BeanDefinitionRegistryPostProcessors
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			// 5.1 找出所有实现BeanDefinitionRegistryPostProcessor接口的类
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				// 5.2 跳过已经执行过的
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					// 5.3 如果有BeanDefinitionRegistryPostProcessor被执行, 则有可能会产生新的BeanDefinitionRegistryPostProcessor,
					// 因此这边将reiterate赋值为true, 代表需要再循环查找一次
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			// 5.4 遍历currentRegistryProcessors, 执行postProcessBeanDefinitionRegistry方法
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		// 6.调用所有BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法(BeanDefinitionRegistryPostProcessor继承自BeanFactoryPostProcessor)
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		// 7.最后, 调用入参beanFactoryPostProcessors中的普通BeanFactoryPostProcessor的postProcessBeanFactory方法
		invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
	}

	else {
		// Invoke factory processors registered with the context instance.
		invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
	}

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// 到这里 , 入参beanFactoryPostProcessors和容器中的所有BeanDefinitionRegistryPostProcessor已经全部处理完毕,
	// 下面开始处理容器中的所有BeanFactoryPostProcessor

	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// 8.找出所有实现BeanFactoryPostProcessor接口的类
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	// 用于存放实现了PriorityOrdered接口的BeanFactoryPostProcessor
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	// 用于存放实现了Ordered接口的BeanFactoryPostProcessor的beanName
	List<String> orderedPostProcessorNames = new ArrayList<>();
	// 用于存放普通BeanFactoryPostProcessor的beanName
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	// 8.1 遍历postProcessorNames, 将BeanFactoryPostProcessor按实现PriorityOrdered、实现Ordered接口、普通三种区分开
	for (String ppName : postProcessorNames) {
		// 8.2 跳过已经执行过的
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			// 8.3 添加实现了PriorityOrdered接口的BeanFactoryPostProcessor
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			// 8.4 添加实现了Ordered接口的BeanFactoryPostProcessor的beanName
			orderedPostProcessorNames.add(ppName);
		}
		else {
			// 8.5 添加剩下的普通BeanFactoryPostProcessor的beanName
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	// 9.调用所有实现PriorityOrdered接口的BeanFactoryPostProcessor
	// 9.1 对priorityOrderedPostProcessors排序
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	// 9.2 遍历priorityOrderedPostProcessors, 执行postProcessBeanFactory方法
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	// 10.调用所有实现Ordered接口的BeanFactoryPostProcessor
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		// 10.1 获取postProcessorName对应的bean实例, 添加到orderedPostProcessors, 准备执行
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 10.2 对orderedPostProcessors排序
	sortPostProcessors(orderedPostProcessors, beanFactory);
	// 10.3 遍历orderedPostProcessors, 执行postProcessBeanFactory方法
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// Finally, invoke all other BeanFactoryPostProcessors.
	// 11.调用所有剩下的BeanFactoryPostProcessor
	List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : nonOrderedPostProcessorNames) {
		// 11.1 获取postProcessorName对应的bean实例, 添加到nonOrderedPostProcessors, 准备执行
		nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	// 11.2 遍历nonOrderedPostProcessors, 执行postProcessBeanFactory方法
	invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

	// Clear cached merged bean definitions since the post-processors might have
	// modified the original metadata, e.g. replacing placeholders in values...
	// 12.清除元数据缓存（mergedBeanDefinitions、allBeanNamesByType、singletonBeanNamesByType），
	// 因为后处理器可能已经修改了原始元数据，例如， 替换值中的占位符...
	beanFactory.clearMetadataCache();
}

安利时刻：

image-20220714114938715

Spring
#Spring源码 #IOC
Spring源码之五postProcessBeanFactory
http://www.sky1998.cn/2022/03/17/Spring/Spring源码之五postProcessBeanFactory/
作者
程序员田同学
发布于
2022年3月17日
许可协议