Spring BeanPostProcessor 处理器 - litter-fish/ReadSource GitHub Wiki

// 初始化处理器
public interface BeanPostProcessor {

	// 初始化bean的前处理器，实现该接口的类，当bean在初始化即调用afterPropertiesSet方法或init-method方法之前会先触发该方法的调用
	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	// 初始化bean的后处理器，实现该接口的类，当bean在初始化即调用afterPropertiesSet方法或init-method方法之后会先触发该方法的调用
	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

// 实例化处理器
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {

	// 实例化前置处理器，如果返回非空，将不会进行后续的实例化即初始化操作
	Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;

	// 实例化后置处理器，在创建bean之前后进行属性填充之前会被调用，方法返回false表示停止后续属性设置操作
	boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;

	// 属性后置处理
	PropertyValues postProcessPropertyValues(
			PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)
			throws BeansException;

}

public interface SmartInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessor {

	// 预测Bean的类型，返回第一个预测成功的Class类型，如果不能预测返回null
	Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException;

	// 选择合适的构造器，比如目标对象有多个构造器，在这里可以进行一些定制化，选择合适的构造器
	// beanClass参数表示目标实例的类型，beanName是目标实例在Spring容器中的name
	// 返回值是个构造器数组，如果返回null，会执行下一个PostProcessor的determineCandidateConstructors方法；否则选取该PostProcessor选择的构造器
	Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException;

	// 获得提前暴露的bean引用。主要用于解决循环引用的问题
	// 只有单例对象才会调用此方法
	Object getEarlyBeanReference(Object bean, String beanName) throws BeansException;

}

// org/springframework/beans/factory/support/AbstractBeanFactory.java
protected <T> T doGetBean(
        final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
        throws BeansException {
     // 省略其他逻辑
     prototypeInstance = createBean(beanName, mbd, args);
     // 省略其他逻辑          
    return (T) bean;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    // 省略其他逻辑

    try {
        // 应用实例化之前的后处理器，以解决指定的bean是否存在实例化快捷方式。
        // InstantiationAwareBeanPostProcessor 处理器 postProcessBeforeInstantiation 的应用
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
    }
    catch (Throwable ex) {
    }

    // 实例化后处理器，初始化前、后处理器的应用
    Object beanInstance = doCreateBean(beanName, mbd, args);

    return beanInstance;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
// 应用实例化之前的后处理器，以解决指定的bean是否存在实例化快捷方式。
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的前置处理器 postProcessBeforeInstantiation
            bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
            if (bean != null) {
                // 初始化bean的后置处理器 postProcessAfterInitialization
                bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
            }
        }
        mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // 省略其他代码
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // InstantiationAwareBeanPostProcessor 处理器  postProcessAfterInstantiation及postProcessPropertyValues的应用
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            // 初始化前后处理器BeanPostProcessor的应用
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }
    catch (Throwable ex) {
    }

    // 省略其他代码
    return exposedObject;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
    PropertyValues pvs = mbd.getPropertyValues();

    
    // 给InstantiationAwareBeanPostProcessor 最后一次机会在属性设置之前修改bean
    boolean continueWithPropertyPopulation = true;

    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                // postProcessAfterInstantiation返回值控制是否可以继续进行属性填充
                // 调用实例化后置处理器
                if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                    continueWithPropertyPopulation = false;
                    break;
                }
            }
        }
    }

    // 
    if (hasInstAwareBpps || needsDepCheck) {
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
        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;
                    }
                }
            }
        }
    }
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    //

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) { // BeanPostProcess的前置处理器
        // 应用后处理器
        // BeanPostProcessor 处理器 postProcessBeforeInitialization 的应用
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    // 自定义初始化方法

    if (mbd == null || !mbd.isSynthetic()) { // BeanPostProcess的后置处理器
        // BeanPostProcessor 处理器 postProcessAfterInitialization 的应用
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
        throws BeansException {

    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

// org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // 省略实例化过程
    /**
     * 是否需要提早曝光： 单例&允许循环依赖&当前bean正在创建， 循环依赖的处理
     */
    boolean earlySingletonExposure = (mbd.isSingleton() // 单例
            && this.allowCircularReferences // 允许循环依赖
            && isSingletonCurrentlyInCreation(beanName)); // 当前bean正在创建
    if (earlySingletonExposure) {
        // 为避免后期循环依赖，可以在bean初始化之前将创建实例的ObjectFactory加入工厂
        addSingletonFactory(beanName, new ObjectFactory<Object>() {
            public Object getObject() throws BeansException {
                // 对bean再一次引用， 应用SmartInstantiationAwareBeanPostProcessor
                // AOP在此动态织入bean中，若没有则直接返回bean，不做任何处理
                return getEarlyBeanReference(beanName, mbd, bean);
            }
        });
    }

    // 省略初始化过程
    return exposedObject;
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                if (exposedObject == null) {
                    return null;
                }
            }
        }
    }
    return exposedObject;
}

// org/springframework/beans/factory/support/DefaultSingletonBeanRegistry.java
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 调用getObject获取实例，此处会应用SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference处理器
                    singletonObject = singletonFactory.getObject();
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}