Spring BeanPostProcessor,InitializingBean的作用及执行时机

以下源码基于 Spring 5.2.8.RELEASE 版本.

BeanPostProcessor有2个方法,分别是在自定义初始化之前和之后执行的行为.
这是Spring框架中非常重要的一个接口,Spring的AOP也是基于该接口的AbstractAdvisingBeanPostProcessor的抽象实现,其基于观察者设计模式,将需要运用AOP的类的代理添加到观察者的对象列表中,当执行到对应方法,由生成的代理方法去通知观察者然后执行后续行为.
不过AOP考虑其他文章来讲述.

InitializingBean只有一个方法,用于BeanFactory完成属性设置之后,执行自定义的初始化行为.

postProcessBeforeInitialization(Object bean, String beanName)方法会在Bean被Spring容器初始化时使用(在被管理的对象实例化后,由Spring容器进行的注入过程),2个参数分别是当前的bean实例及bean的名字.

看下Bean初始化的方法:

// Spring容器初始化bean
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		// 执行对应的Aware接口的方法,将需要预先准备的信息
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// 在执行InitializingBean方法之前的处理
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 执行InitializingBean初始化方法
		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()) {
		// 在执行InitializingBean方法之后的处理
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

// Spring容器执行Bean实现的Aware的相关方法,将资源注入
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) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

// Bean在执行初始化方法前,执行BeanPostProcessor的postProcessBeforeInitialization
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	// getBeanPostProcessors()返回所有的在Spring容器注册的BeanPostProcessor实现类
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

// Bean在执行初始化方法后,执行BeanPostProcessor的postProcessAfterInitialization
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
		throws BeansException {

	Object result = existingBean;
	// getBeanPostProcessors()返回所有的在Spring容器注册的BeanPostProcessor实现类
	for (BeanPostProcessor processor : getBeanPostProcessors()) {
		Object current = processor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

// Bean的自定义初始化方法
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
		throws Throwable {

	// 是否实现了InitializingBean
	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isTraceEnabled()) {
			logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
					((InitializingBean) bean).afterPropertiesSet();
					return null;
				}, getAccessControlContext());
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		}
		else {
			// 设置属性
			((InitializingBean) bean).afterPropertiesSet();
		}
	}

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

接下来写个例子检查:

package org.lionzhou.spring;

import lombok.Data;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class BeanPostProcessorApp {

    static class MyBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            // 检查对象类型
            if (bean instanceof BeanOne) {
                System.out.println(String.format("before bean %s (%s)", beanName, bean.toString()));
                final BeanOne beanOne = (BeanOne) bean;
                // 对属性自增100
                beanOne.setNo(beanOne.getNo() + 100);
            }
            return bean;
        }

        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            // 答应结果
            if (bean instanceof BeanOne) {
                System.out.println(String.format("after bean %s (%s)", beanName, bean.toString()));
            }
            return bean;
        }
    }

    @Data
    static class BeanOne implements InitializingBean {
        private Integer no = 100;

        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("from afterPropertiesSet.");
        }
    }

    public static void main(String[] args) {
        final AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        context.register(BeanOne.class);

        final ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
        // 注册BeanPostProcessor
        beanFactory.addBeanPostProcessor(new MyBeanPostProcessor());
        context.refresh();
 		// 内部静态类,所以bean的默认生成的名字需要外部对象名
        final BeanOne beanOne = beanFactory.getBean("beanPostProcessorApp.BeanOne", BeanOne.class);

        System.out.println(beanOne);
    }
}

before bean beanPostProcessorApp.BeanOne (BeanPostProcessorApp.BeanOne(no=100))
from afterPropertiesSet.
after bean beanPostProcessorApp.BeanOne (BeanPostProcessorApp.BeanOne(no=200))
BeanPostProcessorApp.BeanOne(no=200)