BeanFactoryPostProcessor
各种Aware
BeanPostProcessor
隐藏的一些特殊功能
下文将一项一项地进行梳理
BeanFactoryPostProcessor
简介
BeanFactoryPostProcessor是一个很重要的接口，其中只有一个方法
voidpostProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)throwsBeansException;
它起作用的时机发生在解析成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接口存在两个方法，从名字可以看粗一个调用在初始化之前，一个调用在初始化之后。
ObjectpostProcessBeforeInitialization(Objectbean,StringbeanName)throwsBeansException;ObjectpostProcessAfterInitialization(Objectbean,StringbeanName)throwsBeansException;
BeanPostProcessor在BeanFactory的初始化bean的函数initializeBean中，主要代码为，基本就是取出所有的BeanPostProcessor，然后遍历调用其postProcessBeforeInitialization或者postProcessAfterInitialization方法。
if(mbd ==null|| !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); }try{ invokeInitMethods(beanName, wrappedBean, mbd); }catch(Throwable ex) {thrownewBeanCreationException( (mbd !=null? mbd.getResourceDescription() :null), beanName,"Invocation of init method failed", ex); }if(mbd ==null|| !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); }publicObjectapplyBeanPostProcessorsBeforeInitialization(ObjectexistingBean,StringbeanName)throwsBeansException {Objectresult = existingBean;for(BeanPostProcessor beanProcessor : getBeanPostProcessors()) { result = beanProcessor.postProcessBeforeInitialization(result, beanName);if(result ==null) {returnresult; } }returnresult; }
使用
Spring利用BeanPostProcessor给了我们在bean初始化前后“doSomething”的机会。
在BeanFactory中使用需要编码
beanFactory.addBeanPostProcessor(newSomeBeanPostProcessor);
但是在ApplicationContext中，我们只需要将自定义的BeanPostProcessor配置到xml文件中即可。ApplicationContext在初始化过程中会识别所有的BeanPostProcessors并添加到BeanFactory中。
各种Aware
简介
这种类型的扩展点是我们比较熟悉的了，例如ApplicationContextAware、BeanFactoryAware等，Aware的接口用于标识“我需要这个对象”，例如ApplicationContextAware通知容器我需要“当前的ApplicationContext对象”。这个Spring给我们提供的一种用于获取有用对象的一种好的方式。
使用
需要注意的是，Aware起作用的时机是在Bean已经完成实例化之后，初始化Bean的同时。而且需要注意的是BeanFactory对于Aware的处理和ApplicationContext是不同的。
先看BeanFactory中的处理方式，各种Aware被调用的地方是在初始化bean的函数
initializeBean中
protectedObjectinitializeBean(finalStringbeanName,finalObjectbean, RootBeanDefinition mbd) {if(System.getSecurityManager() !=null) { AccessController.doPrivileged(newPrivilegedAction() {publicObjectrun() { invokeAwareMethods(beanName, bean);returnnull; } }, getAccessControlContext()); }else{ invokeAwareMethods(beanName, bean); }ObjectwrappedBean = bean;if(mbd ==null|| !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); }try{ invokeInitMethods(beanName, wrappedBean, mbd); }catch(Throwable ex) {thrownewBeanCreationException( (mbd !=null? mbd.getResourceDescription() :null), beanName,"Invocation of init method failed", ex); }if(mbd ==null|| !mbd.isSynthetic()) { wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); }returnwrappedBean; }privatevoidinvokeAwareMethods(finalStringbeanName,finalObjectbean) {if(beaninstanceofAware) {if(beaninstanceofBeanNameAware) { ((BeanNameAware) bean).setBeanName(beanName); }if(beaninstanceofBeanClassLoaderAware) { ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader()); }if(beaninstanceofBeanFactoryAware) { ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this); } } }
可以看到其发生在invokeInitMethods之前。而ApplicationContext怎么处理呢？ApplicationContext本身是利用BeanFactory进行容器的初始化，而BeanFactory却硬编码了invokeAwareMethods中Aware的类型，那ApplicationContext究竟是怎么调用ApplicationContextAware的呢，答案就在函数prepareBeanFactory中，
beanFactory.addBeanPostProcessor(newApplicationContextAwareProcessor(this));
ApplicationContext为beanFactory增加了ApplicationContextAwareProcessor，ApplicationContextAwareProcessor是一种BeanPostProcessor。前文提到BeanPostProcessor发生在bean初始化前后，在bean初始化之前将调用postProcessBeforeInitialization方法，ApplicationContextAwareProcessor#postProcessBeforeInitialization如下：
publicObjectpostProcessBeforeInitialization(finalObjectbean,StringbeanName)throwsBeansException { AccessControlContext acc =null;if(System.getSecurityManager() !=null&& (beaninstanceofEnvironmentAware || beaninstanceofEmbeddedValueResolverAware || beaninstanceofResourceLoaderAware || beaninstanceofApplicationEventPublisherAware || beaninstanceofMessageSourceAware || beaninstanceofApplicationContextAware)) { acc =this.applicationContext.getBeanFactory().getAccessControlContext(); }if(acc !=null) { AccessController.doPrivileged(newPrivilegedAction() {publicObjectrun() { invokeAwareInterfaces(bean);returnnull; } }, acc); }else{ invokeAwareInterfaces(bean); }returnbean; }privatevoidinvokeAwareInterfaces(Objectbean) {if(beaninstanceofAware) {if(beaninstanceofEnvironmentAware) { ((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment()); }if(beaninstanceofEmbeddedValueResolverAware) { ((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(newEmbeddedValueResolver(this.applicationContext.getBeanFactory())); }if(beaninstanceofResourceLoaderAware) { ((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext); }if(beaninstanceofApplicationEventPublisherAware) { ((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext); }if(beaninstanceofMessageSourceAware) { ((MessageSourceAware) bean).setMessageSource(this.applicationContext); }if(beaninstanceofApplicationContextAware) { ((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{ // GiveBeanPostProcessorsa chance to return a proxy instead of the targetbeaninstance. Objectbean= resolveBeforeInstantiation(beanName,mbd);if(bean!= null) { returnbean;}} protected Object resolveBeforeInstantiation(StringbeanName,RootBeanDefinition mbd) { Objectbean= null;if(!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)){ // Make surebeanclass 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);} returnbean;}
我们熟知的AOP，对target对象进行代理就是实现了InstantiationAwareBeanPostProcessor接口，在Bean实例化之前短路操作返回代理Proxy对象。
ApplicationContext的事件发布
--待续
总结
本文总结了Spring容器中几种使用较多的扩展机制，Spring作为一个设计良好的框架，遵循了“对修改封闭，对扩展开放”的原则，我们可以根据自己的实际需要来自定义BeanFactoryPostProcessor,BeanPostProcessor来在bean的生命周期里doSomething,实现各种Aware接口拿到容器中提供的一些有用对象，通过自定义监听器监听容器的事件等。