Spring后置处理器BeanFactoryPostProcessor与BeanPostProcessor源码解析

一、简介

Spring有两种类型的后置处理器，分别是 BeanFactoryPostProcessor 和 BeanPostProcessor ，这里再贴出我画的 Spring 启动过程，可以看看这两种后置处理器在 Spring 启动过程中位置。

1、BeanFactoryPostProcessor

BeanFactoryPostProcessor 的 postProcessBeanFactory 方法在 Spring 容器启动时被调用，可以对整个容器中的 BeanDefinition （Bean 定义）进行处理，BeanFactoryPostProcessor 还有个子接口 BeanDefinitionRegistryPostProcessor ，其 postProcessBeanDefinitionRegistry 方法也可以对 BeanDefinition 进行处理的，但两个的侧重点不一样， BeanDefinitionRegistryPostProcessor 侧重于创建自定义的 BeanDefinition，而 BeanFactoryPostProcessor 侧重于对已有的 BeanDefinition 进行修改。

2、BeanPostProcessor

BeanPostProcessor 是在 Bean 初始化方法调用前后，对 Bean 进行一些预处理或后处理，这个接口有两个方法，分别是 postProcessBeforeInitialization 和 postProcessAfterInitialization，分别用来执行预处理和后处理。

二、BeanFactoryPostProcessor 源码解析

处理 BeanFactoryPostProcessor 的源码在哪里呢，我们先找到 Spring 的核心方法 refresh 方法（在 AbstractApplicationContext 类里），在里面找到 invokeBeanFactoryPostProcessors 方法

跟进去这个方法

在跟进到 PostProcessorRegistrationDelegate 类的 invokeBeanFactoryPostProcessors 方法里，就到了核心处理逻辑了，先列出这个方法的代码

public static void invokeBeanFactoryPostProcessors(
		ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {

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

	if (beanFactory instanceof BeanDefinitionRegistry) {
		BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
		List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
		List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();

		for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
			if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
				BeanDefinitionRegistryPostProcessor registryProcessor =
						(BeanDefinitionRegistryPostProcessor) postProcessor;
				registryProcessor.postProcessBeanDefinitionRegistry(registry);
				registryProcessors.add(registryProcessor);
			}
			else {
				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.
		List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

		// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
		String[] postProcessorNames =
				beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			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);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();

		// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
		boolean reiterate = true;
		while (reiterate) {
			reiterate = false;
			postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
			for (String ppName : postProcessorNames) {
				if (!processedBeans.contains(ppName)) {
					currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
					processedBeans.add(ppName);
					reiterate = true;
				}
			}
			sortPostProcessors(currentRegistryProcessors, beanFactory);
			registryProcessors.addAll(currentRegistryProcessors);
			invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
			currentRegistryProcessors.clear();
		}

		// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
		invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
		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!
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

	// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
	// Ordered, and the rest.
	List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
	List<String> orderedPostProcessorNames = new ArrayList<>();
	List<String> nonOrderedPostProcessorNames = new ArrayList<>();
	for (String ppName : postProcessorNames) {
		if (processedBeans.contains(ppName)) {
			// skip - already processed in first phase above
		}
		else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
		}
		else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
			orderedPostProcessorNames.add(ppName);
		}
		else {
			nonOrderedPostProcessorNames.add(ppName);
		}
	}

	// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
	sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

	// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
	List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>();
	for (String postProcessorName : orderedPostProcessorNames) {
		orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
	}
	sortPostProcessors(orderedPostProcessors, beanFactory);
	invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

	// Finally, invoke all other BeanFactoryPostProcessors.
	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();
}

这段代码比较长，我们可以分成两部分来看，前半部分处理 BeanDefinitionRegistryPostProcessors 接口的实现类，后半部分处理 BeanFactoryPostProcessor 接口的实现类，我们先看 BeanDefinitionRegistryPostProcessors 接口的处理流程

1、BeanDefinitionRegistryPostProcessor 接口实现类的处理流程

首先创建了一个名叫 processedBeans 的 HashSet

是为了记录处理过的 PostProcessor 的名字，目的是防止重复处理，然后下面对 beanFactory 的类型进行了判断，如果是 BeanDefinitionRegistry 类型，会有一大段的处理逻辑，如果不是，就调用 invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory); 方法

if (beanFactory instanceof BeanDefinitionRegistry) {
	...
}

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

这个方法，其实就是循环执行所有 PostProcessor 的 postProcessBeanFactory 方法，我们再来看如果是 BeanDefinitionRegistry 类型，是怎么处理的，先看第一段

这一段是将传进来的参数 BeanFactoryPostProcessor 集合进行区分，分成 BeanDefinitionRegistryPostProcessor 类型（后面简称 BDRPP）和非 BeanDefinitionRegistryPostProcessor 类型，其实就是 BeanFactoryPostProcessor 类型（后面简称 BFPP），并执行了 BDRPP 类型的 postProcessBeanDefinitionRegistry 方法，并且，把两种类型分别添加到了两个集合里 registryProcessors 和 regularPostProcessors，继续往下看

这一段，先声明了一个 BDRPP 类型的集合，用于存放在 Spring 容器里找到的 BDRPP，然后从 Spring 容器里找到所有 BDRPP 的名字，循环并找到实现了 PriorityOrdered 接口的 BDRPP，排序，添加到之前定义区分 BDRPP 和 BFPP 的集合 registryProcessors 里，然后执行了这些实现了 PriorityOrdered 接口的 BDRPP 的 postProcessBeanDefinitionRegistry 方法，下面以同样的方式处理实现了 Ordered 接口的 BDRPP，这里先科普下 PriorityOrdered 和 Ordered

PriorityOrdered 和 Ordered 是 Spring 框架中用于定义 Bean 的加载顺序的接口。而 PriorityOrdered 是 Ordered 的子类，实现了这两个接口的类，需要实现一个 getOrder() 方法，返回一个 int 值，这个值越大，优先级就越低，而实现了 PriorityOrdered 接口的 Bean 的加载顺序会优先于实现了 Ordered 接口的Bean，且两者都优先于没实现这两个接口的 Bean

所以，这里先处理的实现了 PriorityOrdered 接口的 BDRPP ，再处理了实现了 Ordered 接口的 BDRPP ，有的人会好奇哦，为什么上面已经调用过一次 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);，下面为什么还要再调一次，这不是重复代码了吗，其实不是，执行了 BDRPP 的 postProcessBeanDefinitionRegistry 方法，有可能会产生新的 BDRPP ，所以需要再重新取一次，继续看下面的代码

知道了执行了 BDRPP 的 postProcessBeanDefinitionRegistry 方法，有可能会产生新的 BDRPP ，这段就好理解了，一直循环获取 BDRPP，执行其 postProcessBeanDefinitionRegistry 方法，直到不产生新的 BDRPP 为止

最后，因为 BDRPP 是 BFPP 的子类，所以也是需要执行 BFPP 里的 postProcessBeanFactory 方法的，但是 BDRPP 的先执行，BFPP 的后执行。

到此 BDRPP 的处理完了，下面看 BFPP 的

2、BeanFactoryPostProcessor 接口实现类的处理流程

看完 BeanDefinitionRegistryPostProcessor 之后，BeanFactoryPostProcessor（后面简称 BFPP）的处理流程就比较简单了，先看第一段代码

获取 Spring 容器里所有 BFPP 类型的 Bean，然后分成三类，分别是实现了 PriorityOrdered 接口的，实现了 Ordered 接口的，其他（也就是不需要排序的），这里需要注意，因为获取 BFPP 类型的 Bean，会将 BDRPP 类型的也获取到，因为 BDRPP 是 BFPP 的子类嘛，所以之前处理过的 BDRPP 需要跳过，继续看下面

这边就很好理解了，按照 PriorityOrdered > Ordered > 其他，的顺序依次执行 postProcessBeanFactory 方法

3、总结

总结一下执行顺序

1. 先执行了 BeanDefinitionRegistryPostProcessor 的 postProcessBeanDefinitionRegistry 方法，按照顺序 PriorityOrdered > Ordered > 其他；
2. 再执行了 BeanDefinitionRegistryPostProcessor 的 postProcessBeanFactory 方法；
3. 最后执行 BeanFactoryPostProcessor 的 postProcessBeanFactory 方法，按照顺序 PriorityOrdered > Ordered > 其他；

三、BeanPostProcessor 源码解析

处理 BeanPostProcessor （后面简称 BPP）的源码在哪里呢，我们知道 BPP 是在 Bean 实例化过程中，init 方法执行前后调用的，入口在 Spring 的核心方法 refresh 方法中的 finishBeanFactoryInitialization(beanFactory); 方法里，里面嵌套很多方法，我们直接来到创建 Bean 的核心方法里，也就是 AbstractAutowireCapableBeanFactory 类的 doCreateBean 方法，在这个方法里找到 exposedObject = initializeBean(beanName, exposedObject, mbd); 这句

在对 Bean 进行实例化和属性填充之后，就会执行这个方法，进一步完成 Bean 的初始化，我们看看这个方法

可以看到在执行 init 方法前后，分别执行了 applyBeanPostProcessorsBeforeInitialization 和 applyBeanPostProcessorsAfterInitialization 方法，这两个方法里，循环了所有的 BPP，调用了其 postProcessBeforeInitialization 和 postProcessAfterInitialization 方法。