Spring BeanPostProcessor的实现

BeanPostProcessor接口作用

如果我们需要在Spring容器完成Bean的实例化、配置和其他的初始化前后添加一些自己的逻辑处理，我们就可以定义一个或者多个BeanPostProcessor接口的实现，然后注册到容器中。

源码

BeanPostProcessor中有两个方法，postProcessBeforeInitialization在Bean的初始化前提供回调入口，另一个是postProcessAfterInitialization，在Bean的初始化之后提供回调入口。

public interface BeanPostProcessor {

	Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

	Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

如果你想知道这些方法在哪里被调用的，那就必须了解IoC的依赖注入过程

Title: 依赖注入流程
BeanFactory->AbstractBeanFactory: doGetBean()
AbstractBeanFactory-->AbstractAutowireCapableBeanFactory: doCreateBean()
AbstractAutowireCapableBeanFactory->AbstractAutowireCapableBeanFactory: initializeBean()
AbstractAutowireCapableBeanFactory->AbstractAutowireCapableBeanFactory: applyBeanPostProcessorsBeforeInitialization()
AbstractAutowireCapableBeanFactory->BeanPostProcessor: postProcessBeforeInitialization()
AbstractAutowireCapableBeanFactory->AbstractAutowireCapableBeanFactory: applyBeanPostProcessorsAfterInitialization()
AbstractAutowireCapableBeanFactory->BeanPostProcessor: postProcessBeforeInitialization()

我们可以从源码中知道，这两个方法是在doCreateBean()中被调用

// Initialize the bean instance.
Object exposedObject = bean;
try {
	populateBean(beanName, mbd, instanceWrapper);
	if (exposedObject != null) {
	//在完成对bean的生成和依赖注入以后，开始对Bean进行初始化，这个初始化过程包含了对后置处理器的调用
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
}
catch (Throwable ex) {
	if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
		throw (BeanCreationException) ex;
	}
	else {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
	}
}

初始化过程也是IoC容器完成依赖注入的一个重要部分

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			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 {
	//初始化属性init-method的处理
		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;
}
//为BeanNameAware类型的Bean设置名字、BeanClassLoaderAware类型的Bean设置类装载器、为BeanFactoryAware类型//的Bean设置自身所在的IoC容器
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);
		}
	}
}

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

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

通过以代码 我们可以知道，每个bean初始化的过程都会调用BeanPostProcesser中的两个方法，经过相应的处理，返回的bean是IoC容器管理，可以正常使用的Bean对象。

注意的是：我们实现BeanPostProcessor接口之后，要在XML配置文件中配置这个具体的实现类，也就是

<bean class="xx.xxx.XXBeanPostProcessor"/>