上接
Spring事务处理时自我调用的解决方案及一些实现方式的风险
继续分析，在分析上篇的问题之前，我们需要了解下BeanPostProcessor概念和Spring容器创建Bean的流程。
一、BeanPostProcessor是什么
接口定义
package org.springframework.beans.factory.config;
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
BeanPostProcessor 是 Spring 容器的一个扩展点，可以进行自定义的实例化、初始化、依赖装配、依赖检查等流程，即可以覆盖默认的实例化，也可以增强初始化、依赖注入、依赖检查等流程，其 javadoc 有如下描述：
e.g. checking for marker interfaces or wrapping them with proxies.
大体意思是可以检查相应的标识接口完成一些自定义功能实现，如包装目标对象到代理对象。
我们可以看到 BeanPostProcessor 一共有两个回调方法 postProcessBeforeInitialization 和 postProcessAfterInitialization ，那这两个方法会在什么 Spring 执行流程中的哪个步骤执行呢？还有目前 Spring 提供哪些相应的实现呢？
Spring 还提供了 BeanPostProcessor 一些其他接口实现，来完成除实例化外的其他功能，后续详细介绍。
二、通过源代码看看创建一个Bean实例的具体执行流程：
AbstractApplicationContext 内部使用 DefaultListableBeanFactory ，且 DefaultListableBeanFactory 继承 AbstractAutowireCapableBeanFactory ，因此我们此处分析 AbstractAutowireCapableBeanFactory 即可。
一、 AbstractAutowireCapableBeanFactory 的 createBean 方法代码如下：
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) throws BeanCreationException {
resolveBeanClass(mbd, beanName); /1解析Bean的class
mbd.prepareMethodOverrides(); //2 方法注入准备
Object bean = resolveBeforeInstantiation(beanName, mbd); //3 第一个BeanPostProcessor扩展点
if (bean != null) { //4 如果3处的扩展点返回的bean不为空，直接返回该bean，后续流程不需要执行
return bean;
}
Object beanInstance = doCreateBean(beanName, mbd, args); //5 执行spring的创建bean实例的流程啦
return beanInstance;
}
0.3 第一个 BeanPostProcessor 扩展点（只有 InstantiationAwareBeanPostProcessor 接口的实现才会被调用）
二、 AbstractAutowireCapableBeanFactory 的 resolveBeforeInstantiation 方法代码如下：
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()) {
//3.1、执行InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation回调方法
bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
if (bean != null) {
//3.2、执行InstantiationAwareBeanPostProcessor的postProcessAfterInitialization回调方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
通过如上代码可以进行实例化的预处理（自定义实例化 bean ，如创建相应的代理对象）和后处理（如进行自定义实例化的 bean 的依赖装配）。
三、 AbstractAutowireCapableBeanFactory 的 doCreateBean 方法 代码如下：
// 6、通过BeanWrapper实例化Bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
//7、执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition流程
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
// 8、及早暴露单例Bean引用，从而允许setter注入方式的循环引用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
//省略log
addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
//8.1、调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference返回一个需要暴露的Bean（例如包装目标对象到代理对象）
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper); //9、组装-Bean依赖
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd); //10、初始化Bean
}
}
catch (Throwable ex) {
//省略异常
}
//11如果是及早暴露单例bean，通过getSingleton触发3.1处的getEarlyBeanReference调用获取要及早暴露的单例Bean
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
//12、注册Bean的销毁回调
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
四、 AbstractAutowireCapableBeanFactory 的 populateBean 方法代码如下：
//9、组装-Bean
protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
//省略部分代码
//9.1、通过InstantiationAwareBeanPostProcessor扩展点允许自定义装配流程（如@Autowired支持等）
//执行InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation
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;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// 9. 2、自动装配（根据name/type）
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
//9. 3、执行InstantiationAwareBeanPostProcessor的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;
}
}
}
}
//9. 4、执行依赖检查
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
//9. 5、应用依赖注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
五、 AbstractAutowireCapableBeanFactory 的 initializeBean 方法代码如下：
//10、实例化Bean
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
//10.1、调用Aware接口注入（BeanNameAware、BeanClassLoaderAware、BeanFactoryAware）
invokeAwareMethods(beanName, bean);//此处省略部分代码
//10.2、执行BeanPostProcessor扩展点的postProcessBeforeInitialization进行修改实例化Bean
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
//10.3、执行初始化回调（1、调用InitializingBean的afterPropertiesSet 2、调用自定义的init-method）
try {
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
//异常省略
}
//10.4、执行BeanPostProcessor扩展点的postProcessAfterInitialization进行修改实例化Bean
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
三、创建一个Bean实例的执行流程简化：
protected Object createBean(final String beanN am e, final RootBeanDefinition mbd, fi nal Object[] args); 创建 Be an
（ 1 、 resolveBeanClass(mbd, beanName); 解析 Bean class ，若 class 配置错误将抛出 CannotLoadBeanClassException ；
（ 2 、 mbd.prepareMethodOverrides(); 准备和验证配置的方法注入，若验证失败抛出 BeanDefinitionValidationException
有关方法注入知识请参考 【第三章】 DI 之 3.3 更多DI的知识 ——跟我学spring3 3.3.5 方法注入；
（ 3 、 Object bean = resolveBeforeInstantiation(beanName, mbd); 第一个 BeanPostProcessor 扩展点，此处只执行 InstantiationAwareBeanPostProcessor 类型的 BeanPostProcessor Bean ；
（ 3. 1 、 bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBe anClass(), beanName); 执行 InstantiationAwareBeanPostProcessor 的实例化的预处理回调方法 postProcessBeforeInstantiation （自定义的实例化，如创建代理）；
（ 3.2 、 bean = applyBeanPostProcessorsAft erInitia lization(bean, beanName); 执行 InstantiationAwareBeanPostProcessor 的实例化的后处理回调方法 postProcessAfterInitialization （如依赖注入），如果 3.1 处返回的 Bean 不为 null 才执行；
（ 4 、如果 3 处的扩展点返回的 bean 不为空，直接返回该 bean ，后续流程不需要执行；
（ 5 、 Object beanInstance = doCreateBean(beanName, mbd, args); 执行 spring 的创建 bean 实例的流程；
（ 6 、 createBeanInstance(beanName, mbd, args); 实例化 Bean
（ 6.1 、 insta ntiateUsingFactoryMethod 工厂方法实例化；请参考【 http://jinnianshilongnian.iteye.com/blog/1413857 】
（ 6.2 、构造器实例化 ，请参考【 http://jinnianshilongnian.iteye.com/blog/1413857 】；
（ 6.2.1 、 如果之前已经解析过构造器
（ 6.2.1.1 auto wireConstructor ：有参调用 autowireConstructor 实例化
（ 6.2.1.2 、 instantiateBe an ：无参调用 instantiateBean 实例化；
（ 6.2.2 、 如果之前没有解析过构造器：
（ 6.2.2.1 、通过 SmartInstantiationAwareBeanPostProcessor 的 determineCandidateConstructors 回调方法解析构造器，第二个 BeanPostProcessor 扩展点，返回第一个解析成功（返回值不为 null ）的构造器组，如 AutowiredAnnotationBeanPostProcessor 实现将自动扫描通过 @Autowired/@Value 注解的构造器从而可以完成构造器注入，请参考 【第十二章】零配置 之 12.2 注解实现Bean依赖注入 ——跟我学spring3 ；
（ 6.2.2.2 、 au towireConstructor ：如果（ 6.2.2.1 返回的不为 null ，且是有参构造器，调用 autowireConstructor 实例化；
（ 6.2.2.3 、 instantiat eBean ： 否则调用无参构造器实例化；
（ 7 、 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 第三个 BeanPostProcessor 扩展点，执行 Bean 定义的合并；
（ 7.1 、执行 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition 回调方法，进行 bean 定义的合并；
（ 8 、 addSingletonFactory(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
}); 及早暴露单例 Bean 引用，从而允许 setter 注入方式的循环引用
（ 8.1 、 SmartInstantiationAwareBeanPostProcessor 的 getE arlyBeanReference ；第四个 BeanPostProcessor 扩展点，当存在循环依赖时，通过该回调方法获取及早暴露的 Bean 实例；
（ 9 、 populateBean(beanName, mbd, instanceWrapper); 装配 Bean 依赖
（ 9.1 、 InstantiationAwareBeanPostProcessor 的 p ostProcessAfterInstantiation ；第五个 BeanPostProcessor 扩展点，在实例化 Bean 之后，所有其他装配逻辑之前执行，如果 false 将阻止其他的 InstantiationAwareBeanPostProcessor 的 postProcessAfterInstantiation 的执行和从（ 9.2 到（ 9.5 的执行，通常返回 true ；
（ 9.2 、 autowireByName 、 autowireB yType ：根据名字和类型进行自动装配，自动装配的知识请参考 【第三章】 DI 之 3.3 更多 DI 的知识 —— 跟我学 spring3 3.3.3 自动装配；
（ 9.3 、 InstantiationAwareBeanPostProcessor 的 postProc essPropertyValues ：第六个 BeanPostProcessor 扩展点，完成其他定制的一些依赖注入，如 AutowiredAnnotationBeanPostProcessor 执行 @Autowired 注解注入， CommonAnnotationBeanPostProcessor 执行 @Resource 等注解的注入， PersistenceAnnotationBeanPostProcessor 执行 @ PersistenceContext 等 JPA 注解的注入， RequiredAnnotationBeanPostProcessor 执行 @ Required 注解的检查等等，请参考 【第十二章】零配置 之 12.2 注解实现Bean依赖注入 ——跟我学spring3 ；
（ 9.4 、 check Dependencies ：依赖检查，请参考 【第三章】 DI 之 3.3 更多 DI 的知识 —— 跟我学 spring3 3.3.4 依赖检查；
（ 9.5 、 applyProperty Values ：应用明确的 setter 属性注入，请参考 【第三章】 DI 之 3.1 DI的配置使用 ——跟我学spring3 ；
（ 10 、 exposedObject = initializeBean(beanName, exposedObject, mbd); 执行初始化 Bean 流程；
（ 10.1 、 invokeAwareMethods （ BeanNameAware 、 BeanClassLoaderAware 、 BeanFactoryAware ） ：调用一些 Aware 标识接口注入如 BeanName 、 BeanFactory ；
（ 10.2 、 BeanPostProcessor 的 po stProcessBeforeInitialization ：第七个扩展点，在调用初始化之前完成一些定制的初始化任务，如 BeanValidationPostProcessor 完成 JSR-303 @Valid 注解 Bean 验证， InitDestroyAnnotationBeanPostProcessor 完成 @PostConstruct 注解的初始化方法调用， ApplicationContextAwareProcessor 完成一些 Aware 接口的注入（如 EnvironmentAware 、 ResourceLoaderAware 、 ApplicationContextAware ），其返回值将替代原始的 Bean 对象；
（ 10.3 、 invokeInitMethods ： 调用初始化方法；
（ 10.3.1 、 InitializingBean 的 afterProperties Set ：调用 InitializingBean 的 afterPropertiesSet 回调方法；
（ 10.3.2 、通过 xml 指定的自定义 init-metho d ：调用通过 xml 配置的自定义 init-method
（ 10.3.3 、 BeanPostProcessor 的 postProcessAfterInitializati on ：第八个扩展点， AspectJAwareAdvisorAutoProxyCreator （完成 xml 风格的 AOP 配置 (<aop:config>) 的目标对象包装到 AOP 代理对象）、 AnnotationAwareAspectJAutoProxyCreator （完成 @Aspectj 注解风格（ <aop:aspectj-autoproxy> @Aspect ）的 AOP 配置的目标对象包装到 AOP 代理对象），其返回值将替代原始的 Bean 对象；
（ 11 、 if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
……
} ：如果是 earlySingleExposure ，调用 getSingle 方法获取 Bean 实例；
earlySingleExposure =(mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName))
只要单例 Bean 且允许循环引用（默认 true ）且当前单例 Bean 正在创建中
（ 11.1 、如果是 earlySingletonExposure 调用 getSingleton 将触发【 8 】处 ObjectFactory.getObject() 的调用，通过【 8.1 】处的 getEarlyBeanReference 获取相关 Bean （如包装目标对象的代理 Bean ）；（在循环引用 Bean 时可能引起 Spring事务处理时自我调用的解决方案及一些实现方式的风险 ）；
（ 12 、 registerDisposableBeanIfNecessary(beanName, bean, mbd) ： 注册 Bean 的销毁方法（只有非原型 Bean 可注册）；
（ 12.1 、单例 Bean 的销毁流程
（ 12.1.1 、 DestructionAwareBeanPostProcessor 的 post ProcessBeforeDestruction ： 第九个扩展点，如 InitDestroyAnnotationBeanPostProcessor 完成 @PreDestroy 注解的销毁方法注册和调用；
（ 12.1.2 、 DisposableBean 的 de stroy ：注册 / 调用 DisposableBean 的 destroy 销毁方法；
（ 12.1.3 、通过 xml 指定的自定义 destroy-m ethod ： 注册 / 调用通过 XML 指定的 destroy-method 销毁方法；
（ 12.1.2 、 Scope 的 regis terDestructionCallback ：注册自定义的 Scope 的销毁回调方法，如 RequestScope 、 SessionScope 等；其流程和【 12.1 单例 Bean 的销毁流程一样】，关于自定义 Scope 请参考 【第三章】 DI 之 3.4 Bean的作用域 ——跟我学spring3
（ 13 、到此 Bean 实例化、依赖注入、初始化完毕可以返回创建好的 bean 了。
从上面的流程我们可以看到 BeanPostProcessor 一个使用了九个扩展点，其实还一个扩展点（ SmartInstantiationAwareBeanPostProcessor 的 predictBeanType 在下一篇介绍），接下来我们看看 BeanPostProcessor 这些扩展点都主要完成什么功能及常见的 BeanPostProcessor 。
我将在下一帖子中使用例子来解析这八个扩展点的主要功能，及一些Spring默认提供的BeanPostProcessor主要作用。
上接
Spring事务处理时自我调用的解决方案及一些实现方式的风险
继续分析，在分析上篇的问题之前，我们需要了解下BeanPostProcessor概念和Spring容器创建Bean的流程。
