Spring源码深度解析（四）：Spring框架后置处理器PostProcessor详解
前言：
为什么Spring叫做框架？–因为可以直接拿来用，可以直接构建自己的应用，Spring已经实现好了IoC容器的全部功能，拿来即用。
为什么Spring能够脱颖而出并且长盛不衰？–因为Spring除了实现了IoC容器的全部功能外，还提供了大量的接口扩展点，能够轻松地扩展功能。
这些接口扩展点叫做：后置处理器。
正文：
1、Bean生命周期
我们已经在 Spring源码深度解析（二）：IOC容器启动过程详解 这篇文章中已经见到过各种后置处理器xxxPostProcessor，我们先不要直接去分析各种后置处理器，那样会对第一次接触Spring源码的同学造成很多困惑。我们先来看下容器启动过程中Bean的生命周期：
扫描BeanDefinition --> Bean实例化 --> 属性赋值 --> Bean初始化 --> Bean销毁
上面这些阶段走完，容器也就启动好了。而在上面每个阶段前后，都可以作为扩展点，从而对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;
}
该方法提供一个扩展点：Bean工厂创建好后，可以进一步注册BeanDefinition。方法的入参传入的就是Bean工厂本身，但是形参是上层接口，只能做注册BeanDefinition的动作。
b) BeanFactoryPostProcessor
同样是在refresh()方法的invokeBeanFactoryPostProcessors(beanFactory)方法中执行。
@FunctionalInterface
public interface BeanFactoryPostProcessor {
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
}
该方法入参传入的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)
@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;
}
}
下面是简化了的源码，可以看到在真正实例化Bean之前，有一个扩展点：resolveBeforeInstantiation（），这个就是实例化前的扩展点。
a) InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation（）
resolveBeforeInstantiation方法最终就是调用了InstantiationAwareBeanPostProcessor接口的下面这个方法：
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
此时我们看到入参的类型是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;
}
如果调用了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);
}
}
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;
}
3.3 Bean属性赋值
属性赋值也是通过后置处理器来实现的，是在下面这个扩展点实现的。
a) InstantiationAwareBeanPostProcessor#postProcessProperties()
@Nullable
default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
throws BeansException {
return null;
}
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;
}
a) BeanPostProcessor#postProcessBeforeInitialization()
在初始化前这个扩展点，可以对已经进行了依赖注入的Bean进行处理。
@Nullable
default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
其中，InitDestroyAnnotationBeanPostProcessor子类的postProcessBeforeInitialization方法会在这个阶段执行@PostConstruct注解标注的方法。
b) InitializingBean#afterPropertiesSet()
这个接口其实不算严格意义上的后置处理器，它是用来指定初始化方法的。
public interface InitializingBean {
void afterPropertiesSet() throws Exception;
}
c) BeanPostProcessor#postProcessAfterInitialization()
这个是Bean生命周期的最后一个扩展点了，对Bean进行最终的处理。Spring中的AOP就是基于初始化后后置处理器实现的，最终返回一个代理对象。
@Nullable
default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
总结：
建议亲自debug一下源代码，体会一下各种后置处理器的强大功能。