Spring源码深度解析（四）：Spring框架后置处理器PostProcessor详解

前言：

为什么Spring叫做框架？–因为可以直接拿来用，可以直接构建自己的应用，Spring已经实现好了IoC容器的全部功能，拿来即用。

为什么Spring能够脱颖而出并且长盛不衰？–因为Spring除了实现了IoC容器的全部功能外，还提供了大量的接口扩展点，能够轻松地扩展功能。

这些接口扩展点叫做：后置处理器。

正文：

1、Bean生命周期

我们已经在 Spring源码深度解析（二）：IOC容器启动过程详解 这篇文章中已经见到过各种后置处理器xxxPostProcessor，我们先不要直接去分析各种后置处理器，那样会对第一次接触Spring源码的同学造成很多困惑。我们先来看下容器启动过程中Bean的生命周期：

扫描BeanDefinition --> Bean实例化 --> 属性赋值 --> Bean初始化 --> Bean销毁
1

上面这些阶段走完，容器也就启动好了。而在上面每个阶段前后，都可以作为扩展点，从而对Bean的状态进行改变，Spring的强大之处就在于此。

2、后置处理器总览图

这里先展示一张总览图，展示的是整个启动过程中涉及到的后置处理器。

我们看到，从上到下是整个Bean生命周期，在中间穿插着各种后置处理器xxxPostProcessor，这些接口的方法（在连线上）分别在箭头所指向的阶段生效。

3、各种后置处理器详解

我们再次回顾refresh()方法的启动过程

3.1 创建好Bean工厂后

创建好Bean工厂后到Bean实例化前，有2个扩展点（BeanFactoryPostProcessor、BeanDefinitionRegistryPostProcessor）
这2个接口的作用是提供一个扩展点，在Bean工厂建好后进行操作。

a) BeanDefinitionRegistryPostProcessor

该接口是BeanFactoryPostProcessor接口的子接口。

在refresh()方法的invokeBeanFactoryPostProcessors(beanFactory)方法中执行。

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
}
1
2
3

该方法提供一个扩展点：Bean工厂创建好后，可以进一步注册BeanDefinition。方法的入参传入的就是Bean工厂本身，但是形参是上层接口，只能做注册BeanDefinition的动作。

b) BeanFactoryPostProcessor

同样是在refresh()方法的invokeBeanFactoryPostProcessors(beanFactory)方法中执行。

@FunctionalInterface
public interface BeanFactoryPostProcessor {
	void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
1
2
3
4

该方法入参传入的bean工厂本身，可以执行Bean工厂所有方法。

3.2 Bean实例化前后

执行完BeanFactory的后置处理器后，该执行BeanPostProcessor后置处理器了。

在执行Bean实例化之前，有一个专门注册BeanPostProcessor的方法，在refresh() --> registerBeanPostProcessors(beanFactory)。

然后经过下列步骤，来到了实例化Bean的方法createBean()。

DefaultListableBeanFactory#preInstantiateSingletons() -->
AbstractBeanFactory#getBean(String name) -->
AbstractBeanFactory#doGetBean(4) -->
DefaultSingletonBeanRegistry#getSingleton(2) -->
AbstractAutowireCapableBeanFactory#createBean(3)
1
2
3
4
5

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {
	...
	try {
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}
	...
	try {
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

下面是简化了的源码，可以看到在真正实例化Bean之前，有一个扩展点：resolveBeforeInstantiation（），这个就是实例化前的扩展点。

a) InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation（）

resolveBeforeInstantiation方法最终就是调用了InstantiationAwareBeanPostProcessor接口的下面这个方法：

@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
	return null;
}
1
2
3
4

此时我们看到入参的类型是Class，而不是Object，因为此时尚未实例化。返回值类型是Object，也就是说你可以在这个方法中进行实例化操作。我们再回来看resolveBeforeInstantiation方法：

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
	Object bean = null;
	if (...) {
		// Make sure bean class is actually resolved at this point.
		if (...)) {
			Class<?> targetType = determineTargetType(beanName, mbd);
			if (targetType != null) {
				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
				// 重点！！！
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
		}
		mbd.beforeInstantiationResolved = (bean != null);
	}
	return bean;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

如果调用了postProcessBeforeInstantiation方法返回的值不为null，也即用户自行实例化了对象，那么Spring就会跳过后续的Bean生命周期步骤（属性赋值、初始化），而直接执行初始化的后置步骤，然后返回bean。

接下来我们进入doCreateBean方法看一下：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
		throws BeanCreationException {

	...
	if (...) {
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}

	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
		}
	}

	try {
		populateBean(beanName, mbd, instanceWrapper);
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

createBeanInstance()方法就把Bean对象创建出来了。

b) MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition()

applyMergedBeanDefinitionPostProcessors()方法也是一个扩展点，调用的是MergedBeanDefinitionPostProcessor接口的postProcessMergedBeanDefinition()方法，是在Bean实例化后，对相应的BeanDefinition进行处理。

c) InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()

populateBean()方法是装配Bean，但是里面有一个重要扩展点：Bean实例化后后置处理器。下面这个方法返回一个boolean类型变量，如果返回false，就不再往下走了。该扩展点貌似没怎么使用。

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
	return true;
}
1
2
3

3.3 Bean属性赋值

属性赋值也是通过后置处理器来实现的，是在下面这个扩展点实现的。

a) InstantiationAwareBeanPostProcessor#postProcessProperties()

@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
		throws BeansException {
	return null;
}
1
2
3
4
5

3.4 Bean初始化前后

initializeBean()就是对Bean对象进行初始化，并且初始化前后也有扩展点。

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
	Object wrappedBean = bean;
	if (...) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	...
	if (...) {
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

a) BeanPostProcessor#postProcessBeforeInitialization()

在初始化前这个扩展点，可以对已经进行了依赖注入的Bean进行处理。

@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}
1
2
3
4

其中，InitDestroyAnnotationBeanPostProcessor子类的postProcessBeforeInitialization方法会在这个阶段执行@PostConstruct注解标注的方法。

b) InitializingBean#afterPropertiesSet()

这个接口其实不算严格意义上的后置处理器，它是用来指定初始化方法的。

public interface InitializingBean {
	void afterPropertiesSet() throws Exception;
}
1
2
3

c) BeanPostProcessor#postProcessAfterInitialization()

这个是Bean生命周期的最后一个扩展点了，对Bean进行最终的处理。Spring中的AOP就是基于初始化后后置处理器实现的，最终返回一个代理对象。

@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	return bean;
}
1
2
3
4

总结：

建议亲自debug一下源代码，体会一下各种后置处理器的强大功能。