/**
*　　BeanPostProcessor 為每個bean實例化時提供個性化的修改，做些包裝等
*/
package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

public interface BeanPostProcessor {

    /**
     * 在bean實例化前調用*/
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    
 
/**
     * 在bean實例化後調用，如果bean實現了InitializingBean，則在執行完* 該接口的afterPropertiesSet方法後調用 ，如果實現了init-method則 * 在執行完init-method後調用*/
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

package org.springframework.beans.factory;

/**
 /* *InitializingBean 為實現該接口的bean提供默認的初始化方法 *也可以在xml配置bean的使用init-method來實現初始化方法 */
 
*/
public interface InitializingBean {

    void afterPropertiesSet() throws Exception;

}

InitializingBean和BeanPostProcessor的執行順序：構造方法-->BeanPostProcessor-->InitializingBean-->bean中的初始化方法

bean的最終初始化是由AbstractAutowireCapableBeanFactory的initializeBean方法來完成的，下面是該方法的源碼

protected Object initializeBean(final
 
 String beanName, final Object bean, RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged(new PrivilegedAction<Object>() {
                public Object run() {
                    **invokeAwareMethods**(beanName, bean);
                    return null;
                }
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }

        Object wrappedBean = bean;
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = **applyBeanPostProcessorsBeforeInitialization**(wrappedBean, beanName);
        }

        try {
            **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;
    }

可以看到initializeBean主要有四步驟
1. invokeAwareMethods 調用實現Aware接口方法，這裏只針對三種Aware接口BeanNameAware，BeanClassLoaderAware，BeanFactoryAware，方法如下

private void invokeAwareMethods(final String beanName, final Object bean) {
        if (bean instanceof Aware) {
            if (bean instanceof BeanNameAware) {
                ((BeanNameAware) bean).setBeanName(beanName);
            }
            if (bean instanceof BeanClassLoaderAware) {
                ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
            }
            if (bean instanceof BeanFactoryAware) {
                ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
            }
        }
    }

1. applyBeanPostProcessorsBeforeInitialization 調用所有實現BeanPostProcessor類 的 postProcessBeforeInitialization方法，源碼如下

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;
    }

1. invokeInitMethods 調用bean的初始化方法，如果bean實現了InitializingBean 接口，則調用afterPropertiesSet方法，如果有配置init-method,則調用配置的初始化方法，源碼如下：

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
            throws Throwable {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            if (logger.isDebugEnabled()) {
                logger.debug("Invoking afterPropertiesSet() on bean with name ‘" + beanName + "‘");
            }
            if (System.getSecurityManager() != null) {
                try {
                    AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                        public Object run() throws Exception {
                            ((InitializingBean) bean).afterPropertiesSet();
                            return null;
                        }
                    }, getAccessControlContext());
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }               
            else {
                ((InitializingBean) bean).**afterPropertiesSet**();
            }
        }

        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                **invokeCustomInitMethod**(beanName, bean, mbd);
            }
        }
    }

1. applyBeanPostProcessorsAfterInitialization 調用所有實現BeanPostProcessor類 的 postProcessAfterInitialization方法，源碼如下

    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;
    }

註：https://blog.csdn.net/zhaiyang1992/article/details/52200602

Spring註解之BeanPostProcessor與InitializingBean