前言
前面几篇关于Spring的文章简单阐述了使用BeanFactory作为容器时bean的初始化过程。然而在实际使用中，我们并不会直接接触和编码BeanFactory，我们通常会使用另外一个功能更强、更完善的容器ApplicationContext。本文粗略讲述了ApplicationContext对于BeanFactory的功能扩展，并将重点放在了Spring在容器启动和初始化过程中提供的扩展点和事件发布上。扩展点让我们能够“插手和干预”Bean的初始化，通过容器发布的事件得以了解容器的一些内部过程。
ApplicationContext的功能扩展
ApplicationContext是“事实上”的容器标准，它基于BeanFactory并对其做了一些功能上的扩展。例如：
- 通过MessageResource支持国际化
- 提供了容器内部的消息发布机制
- 自动添加BeanFactoryPostProcessor、BeanPostProcessor到容器中
等。
由于ApplicationContext对于BeanFactory的扩展不是本文阐述的重点，所以略过。
Spring容器初始化中的扩展点
Spring容器初始化中的扩展点不仅包括了Beanfactory提供的也包含了ApplictionContext增强的。
从前面几篇关于容器初始化的文章可以得出，从xml到实例化并初始化完bean大体上经历了两个过程：
- 容器启动过程：这个过程包括了读取xml文件，并替换一些系统或者自定义变量，将xml标签解析成BeanDefinitionwrapper。
- 容器初始化过程：这个过程包括了解析BeanDefinition中包含的Bean信息，完成Bean的实例化(Instantiation)和初始化(Initialization)过程。
而ApplicationContext将容器启动和初始化过程细化成了一些模板函数，构成以下步骤。
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
}
}
整个过程及其中的扩展点可以表示成下图：
容器启动及初始化过程.jpg
图中表示出了Spring容器中设计到的很多扩展点，主要可以分为以下几类：
- BeanFactoryPostProcessor
- 各种Aware
- BeanPostProcessor
- 隐藏的一些特殊功能
下文将一项一项地进行梳理
BeanFactoryPostProcessor
简介
BeanFactoryPostProcessor是一个很重要的接口，其中只有一个方法
void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;
它起作用的时机发生在解析成BeanDefinition后，实例化之前。从名字可以看出来，BeanFactoryPostProcessor针对的应该是容器级别的扩展，名为“BeanFactory PostProcessor”即对容器中所有的BeanDefinition都起普遍作用。BeanFactoryPostProcessor有几个我们比较常用的子类PropertyPlaceholderConfigurer、CustomEditorConfigurer，前者用于配置文件中的${var}变量替换，后者用于自定义编辑BeanDefinition中的属性值，合理利用CustomEditorConfigurer会有一些意想不到的效果（例如可以通过修改某些属性实现类似aop的功能）。
使用
如果是在BeanFactory中使用，我们需要
PropertyPlaceholderConfigurer configurer = new PropertyPlaceholderConfigurer();
configurer.setLaction("xxx");
configurer.postProcessBeanFactory(beanFactory);
很繁琐，很麻烦，而且通常我们并不喜欢硬编码直接使用BeanFactory。在ApplicationContext中得到了改善，使用BeanFactoryPostProcessor只需要在xml文件中进行相应的配置就行，因为ApplicationContext在初始化过程中会调用invokeBeanFactoryPostProcessors(beanFactory)，该函数会找出所有BeanFactoryPostProcessor类型的bean，调用postProcessBeanFactory方法。
BeanPostProcessor
简介
BeanPostProcessor很容易和BeanFactoryPostProcessor混淆，但从名字上来说，BeanPostProcessor是“Bean PostProcessor”，主要针对于Bean这一级别，关注的主要是Bean实例化后，初始化前后的。为什么说主要呢？因为存在特例，有一个BeanPostProcessor的调用并不是发生在实例化后，初始化前后。BeanPostProcessor接口存在两个方法，从名字可以看粗一个调用在初始化之前，一个调用在初始化之后。
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
BeanPostProcessor在BeanFactory的初始化bean的函数initializeBean中，主要代码为，基本就是取出所有的BeanPostProcessor，然后遍历调用其postProcessBeforeInitialization或者postProcessAfterInitialization方法。
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);
}
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;
}
使用
Spring利用BeanPostProcessor给了我们在bean初始化前后“doSomething”的机会。
在BeanFactory中使用需要编码
beanFactory.addBeanPostProcessor(new SomeBeanPostProcessor);
但是在ApplicationContext中，我们只需要将自定义的BeanPostProcessor配置到xml文件中即可。ApplicationContext在初始化过程中会识别所有的BeanPostProcessors并添加到BeanFactory中。
各种Aware
简介
这种类型的扩展点是我们比较熟悉的了，例如ApplicationContextAware、BeanFactoryAware等，Aware的接口用于标识“我需要这个对象”，例如ApplicationContextAware通知容器我需要“当前的ApplicationContext对象”。这个Spring给我们提供的一种用于获取有用对象的一种好的方式。
使用
需要注意的是，Aware起作用的时机是在Bean已经完成实例化之后，初始化Bean的同时。而且需要注意的是BeanFactory对于Aware的处理和ApplicationContext是不同的。
先看BeanFactory中的处理方式，各种Aware被调用的地方是在初始化bean的函数
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;
}
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);
}
}
}
可以看到其发生在invokeInitMethods之前。而ApplicationContext怎么处理呢？ApplicationContext本身是利用BeanFactory进行容器的初始化，而BeanFactory却硬编码了invokeAwareMethods中Aware的类型，那ApplicationContext究竟是怎么调用ApplicationContextAware的呢，答案就在函数prepareBeanFactory中，
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
ApplicationContext为beanFactory增加了ApplicationContextAwareProcessor，ApplicationContextAwareProcessor是一种BeanPostProcessor。前文提到BeanPostProcessor发生在bean初始化前后，在bean初始化之前将调用postProcessBeforeInitialization方法，ApplicationContextAwareProcessor#postProcessBeforeInitialization如下：
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
if (System.getSecurityManager() != null &&
(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
public Object run() {
invokeAwareInterfaces(bean);
return null;
}
}, acc);
}
else {
invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof Aware) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(
new EmbeddedValueResolver(this.applicationContext.getBeanFactory()));
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}
可以看出ApplicationContext利用ApplicationContextAwareProcessor完成了ApplicationContext中特有的一些Aware的调用，发生的时机在初bean始化之前。
一种特殊的BeanPostProcessor-InstantiationAwareBeanPostProcessor
前文提到BeanPostProcessor主要作用于Bean实例化后，初始化前后，但是存在特例，InstantiationAwareBeanPostProcessor就是特例，其发生在Bean实例化前，
在真正调用doCreate()创建bean实例化之前，调用了resolveBeforeInstantiation进行了短路操作，如果此方法返回值不为空则直接返回bean。spring注释“Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. ”给BeanPostProcessors一个机会返回代理proxy对象。
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
Object bean = resolveBeforeInstantiation(beanName, mbd);
if (bean != null) {
return 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 = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
我们熟知的AOP，对target对象进行代理就是实现了InstantiationAwareBeanPostProcessor接口，在Bean实例化之前短路操作返回代理Proxy对象。
ApplicationContext的事件发布
--待续
总结
本文总结了Spring容器中几种使用较多的扩展机制，Spring作为一个设计良好的框架，遵循了“对修改封闭，对扩展开放”的原则，我们可以根据自己的实际需要来自定义BeanFactoryPostProcessor,BeanPostProcessor来在bean的生命周期里doSomething,实现各种Aware接口拿到容器中提供的一些有用对象，通过自定义监听器监听容器的事件等。
网友评论