spring 源码个人浅浅分析（4）--- bean生命周期之InstantiationAwarePostProcessor、BeanPostProcessor

Bean生命周期之InstantiationAwarePostProcessor、BeanPostProcessor，

且这两个接口可以给用户来扩展。

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

public interface BeanPostProcessor {
    //初始化bean之前调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //初始化bean之后调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

package org.springframework.beans.factory.config;

import java.beans.PropertyDescriptor;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;

public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

	//实例化bean之前
	Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
    //实例化bean 之后
	boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
    //实例化bean的一些属性
	PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
			throws BeansException;

}

查看AbstractAutoWireCapableBeanFactory源码

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                //调用实例化前置处理器
				bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
                //如果实例化前置返回不为空，则直接调用初始化后处理器来直接返回bean
				if (bean != null) {
					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

方法resolveBeforeInstantiation  s实例化前置处理对BeanDefinition中的属性做些前置处理。当经过实例化前置处理后的结果返回b不为空，那么就会直接略过后续的Bean的创建而直接返回结果。这一特性很容易被忽略，但是起这至关的重要作用，其中AOP功能就是基于这里的判断。

 

第一部分：当调用InstantiationAwarePostProcessor的接口实例化前置处理器postProcessBeforeInstantiation的方法，返回的结果不为null，则接下来直接调用BeanPostProcessor接口的初始化后处理postProcessAfterInitialization方法，之后直接返回bean，无需在执行下面的创建bean过程。

postProcessBeforeInstantiation（实例化前置处理器{前提是返回不为空}）--->postProcessAfterInitialization（初始化后处理器）

第二部分：当调用InstantiationAwarePostProcessor的接口实例化前置处理器postProcessBeforeInstantiation的方法，返回的结果为null，则直接返回null，继续执行下面的创建bean过程。那么就是下面的执行顺序：

postProcessBeforeInstantiation（实例化前置处理器{前提是返回null}）--->  postProcessAfterInstantiation（实例化后置处理器） ---> postProcessPropertyValues（实例化的属性值） ---> postProcessBeforeInitialization（初始化前处理器） ---> postProcessAfterInitialization（初始化后处理器）

继续创建bean，进入populateBean方法对bean实例的属性填充，以及调用实例化后置处理、实例化属性处理。

protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
		PropertyValues pvs = mbd.getPropertyValues();

		//....省略其他

		// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
		// state of the bean before properties are set. This can be used, for example,
		// to support styles of field injection.
		boolean continueWithPropertyPopulation = true;
        //开始调用实例化后处理器
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof InstantiationAwareBeanPostProcessor) {
					InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
					if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
						continueWithPropertyPopulation = false;
						break;
					}
				}
			}
		}

		//。。。省略部分代码
        //开始对属性作最后的修改，调用postProcessPropertyValues对属性进行操作
		if (hasInstAwareBpps || needsDepCheck) {
			PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
			if (hasInstAwareBpps) {
				for (BeanPostProcessor bp : getBeanPostProcessors()) {
					if (bp instanceof InstantiationAwareBeanPostProcessor) {
						InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
						pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
						if (pvs == null) {
							return;
						}
					}
				}
			}
		}
        
		applyPropertyValues(beanName, mbd, bw, pvs);
	}

属性填充后，开始初始化bean。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
		//开始调用初始化bean的前置处理器
		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
            //注意：这里面方法实现两个功能：
            //1、调用InitializingBean接口实现的方法afterPropertiesSet。 
            //2、执行init-method的方法，xml配置的初始化方法。
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
        //调用初始化后置处理器
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}
		return wrappedBean;
	}