Spring源码解析 BeanPostProcessor的实现

BeanPostProcessor是使用IoC容器时经常使用会遇到的一个特性，这个Bean的后置处理器是一个监听器，它可以监听容器触发的事件。把它向IoC容器注册以后，使得容器中管理的Bean具备接收IoC 容器事件回调的能力。具体的后置处理器需要实现接口BeanPostProcessor，然后设置到XML的Bean的配置文件中。这个BeanPostProcessor是一个接口类，它有两个接口方法，一个是Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;，为在Bean 的初始化前提供回调入口。另一个：Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;，为在Bean的初始化以后提供回调入口，这两个回调的触发都是和容器管理Bean的生命周期相关。

AbstractAutowireCapableBeanFactory的doCreateBean方法中

 

// Initialize the bean instance.
		Object exposedObject = bean;
		try {
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
				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);
			}
		}

 在对Bead的生成和依赖注入完成后，开始对bean进行初始化，这个初始化过程包含了对后置处理器的调用

 

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方法里，需要Bean的名字，完成依赖注入以后的bean对象，以及这个Bean对应的Beandefinition。在这些输入的帮助下完成Bean的初始化的工作，包括为类型是BeanNameAware的Bean设置Bean的名字，为类型BeanClassLoaderAware的Bean设置类装载器，为类型BeanFactoryAware的Bean设置其自身所在的IoC容器以供回调使用。这些实现在：

private void invokeAwareMethods(final String beanName, final Object bean) {
		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);
		}
	}

 中，接着是对后置处理器BeanPostProcessors的postProcessBeforeInitialization的回调方法的调用：

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

具体的实现过程见applyBeanPostProcessorsBeforeInitialization：

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

 调用Bean的初始化方法吗，这个初始化方法是在BeanDefinition中通过定义init-method属性指定的，同时如果Bean实现了InitializingBean接口，那么Bean的afterPropertiesSet的实现也会被调用。

try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}

 具体的实现步骤如下：

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

 然后就是对后置处理器BeanPostProcessor的postProcessAfterInitialization的回调方法调用

wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

具体的实现步骤如下：

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

 

由上面的源码分析可知：BeanPostProcessors的postProcessBeforeInitialization先于Bean的属性init-method中配置的方法或者是Bean继承的InitializingBean接口后实现afterPropertiesSet方法执行。接着继续执行BeanPostProcessors的postProcessAfterInitialization方法。

 

评论

1 楼 xuhang1128 2013-08-23  

good