前言
BeanPostProcessor也稱為Bean后置處理器，它是Spring中定義的接口入挣，在Spring容器的創(chuàng)建過程中（具體為Bean初始化前后）會(huì)回調(diào)BeanPostProcessor中定義的兩個(gè)方法。BeanPostProcessor的源碼如下
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
其中postProcessBeforeInitialization方法會(huì)在每一個(gè)bean對(duì)象的初始化方法調(diào)用之前回調(diào)您朽；postProcessAfterInitialization方法會(huì)在每個(gè)bean對(duì)象的初始化方法調(diào)用之后被回調(diào)黑界。具體執(zhí)行時(shí)期可以參考Spring中Bean的生命周期源碼探究劳澄。
自定義BeanPostProcessor
查看BeanPostProcessor源碼稍走，可以看到它兩個(gè)方法的參數(shù)都相同袁翁，其中第一個(gè)參數(shù)Object bean表示當(dāng)前正在初始化的bean對(duì)象柴底。此外兩個(gè)方法都返回Object類型的實(shí)例，返回值既可以是將入?yún)?code>Object bean原封不動(dòng)的返回出去粱胜，也可以對(duì)當(dāng)前bean進(jìn)行包裝再返回柄驻。來看看下面的自定義BeanPostProcessor
/**
* 后置處理器：初始化前后進(jìn)行處理工作
* 需要將后置處理器加入到容器中
*/
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessBeforeInitialization..."+beanName+"..."+bean);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("postProcessAfterInitialization..."+beanName+"..."+bean);
return bean;
}
}
Spring容器中加入MyBeanPostProcessor之后，針對(duì)容器中每個(gè)創(chuàng)建的Bean對(duì)象（Spring自身創(chuàng)建的Bean和應(yīng)用程序創(chuàng)建的Bean）焙压，都會(huì)回調(diào)postProcessBeforeInitialization和postProcessAfterInitialization方法鸿脓。
執(zhí)行原理
BeanPostProcessor的執(zhí)行是定義在容器的刷新過程中，容器刷新對(duì)象具體的方法為：AbstractApplicationContext.refresh()涯曲。
在refresh方法執(zhí)行的調(diào)用棧中會(huì)去調(diào)用AbstractAutowireCapableBeanFactory.doCreateBean()方法答憔，該方法節(jié)選源碼如下
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
invokeInitMethods(beanName, wrappedBean, mbd);
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
看到在調(diào)用初始化方法前后會(huì)分別調(diào)用applyBeanPostProcessorsBeforeInitialization()和applyBeanPostProcessorsAfterInitialization()。applyBeanPostProcessorsBeforeInitialization()方法的源碼如下
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
//獲取所有的BeanPostProcessor進(jìn)行遍歷
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
可以看到其邏輯為遍歷得到容器中所有的BeanPostProcessor掀抹，然后一次執(zhí)行postProcessBeforeInitialization，一但返回null心俗，就跳出for循環(huán)不執(zhí)行后面的BeanPostProcessor.postProcessorsBeforeInitialization()傲武。也就是說如果返回的是null那么我們通過getBean方法將得不到目標(biāo)Bean。
applyBeanPostProcessorsBeforeInitialization()方法的邏輯和上面一致城榛，就是將循環(huán)執(zhí)行的beanProcessor.postProcessBeforeInitialization()替換成beanProcessor.postProcessAfterInitialization()
Spring底層的很多功能特性都是借助BeanPostProcessor的子類來實(shí)現(xiàn)揪利。
常見BeanPostProcessor分析
下圖是debug過程中，ApplicationContext對(duì)象中的包含的BeanPostProcessor狠持。具體包含哪些BeanPostProcessor和具體應(yīng)用程序相關(guān)疟位，除了下標(biāo)3中的MyBeanPostProcessor為自定義的BeanPostProcessor，其余均為Spring自帶的BeanPostProcessor喘垂。
下面來分析一下
ApplicationContextAwareProcessor和AutowiredAnnotationProcessor的執(zhí)行原理甜刻。
ApplicationContextAwareProcessor
ApplicationContextAwareProcessor后置處理器的作用是，當(dāng)應(yīng)用程序定義的Bean實(shí)現(xiàn)ApplicationContextAware接口時(shí)注入ApplicationContext對(duì)象正勒。
@Component
public class Car implements ApplicationContextAware {
private ApplicationContext applicationContext;
public Car(){
System.out.println("car instance...");
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
System.out.println("ApplicationContextAware...setApplicationContext()");
this.applicationContext = applicationContext;
}
}
那Car是如何通過實(shí)現(xiàn)ApplicationContextAware接口就能獲得ApplicationContext對(duì)象呢得院？答案是通過ApplicationContextAwareProcessor后置處理器來實(shí)現(xiàn)，我們來看看ApplicationContextAwareProcessor的源碼
class ApplicationContextAwareProcessor implements BeanPostProcessor {
private final ConfigurableApplicationContext applicationContext;
private final StringValueResolver embeddedValueResolver;
/**
* Create a new ApplicationContextAwareProcessor for the given context.
*/
public ApplicationContextAwareProcessor(ConfigurableApplicationContext applicationContext) {
this.applicationContext = applicationContext;
this.embeddedValueResolver = new EmbeddedValueResolver(applicationContext.getBeanFactory());
}
@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
AccessControlContext acc = null;
// 這里bean是Car,它實(shí)現(xiàn)了ApplicationContextAware接口
if (System.getSecurityManager() != null &&
(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)) {
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(this.embeddedValueResolver);
}
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) {
// 會(huì)執(zhí)行這里回調(diào)car重寫的setApplicationContext方法章贞，然后將this.applicationContext注入給Car
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
InitDestroyAnnotationBeanPostProcessor
InitDestroyAnnotationBeanPostProcessor后置處理器是用來處理自定義的初始化方法和銷毀方法祥绞。Spring中提供了3種自定義初始化和銷毀方法：
- 通過@Bean指定init-method和destroy-method屬性
- Bean實(shí)現(xiàn)InitializingBean（定義初始化邏輯），DisposableBean（定義銷毀邏輯）;
- @PostConstruct：在bean創(chuàng)建完成并且屬性賦值完成鸭限；來執(zhí)行初始化方法@PreDestroy：在容器銷毀bean之前通知我們進(jìn)行清理工作
InitDestroyAnnotationBeanPostProcessor的作用就是讓第3種方式生效蜕径。先看看如何使用@PostConstruct和@PreDestroy注解。
@Component
public class Car {
public Car(){
System.out.println("car instance...");
}
/**
* 自定義的初始化方法
*/
@PostConstruct
public void init(){
System.out.println("car ... init...");
}
/**
* 自定義的銷毀方法
*/
@PreDestroy
public void detory(){
System.out.println("car ... detory...");
}
}
InitDestroyAnnotationBeanPostProcessor會(huì)在Bean創(chuàng)建的時(shí)候通過反射的方式查找包含@PostConstruct和@PreDestroy注解的方法败京，然后再通過反射執(zhí)行方法兜喻。我們來看看InitDestroyAnnotationBeanPostProcessor.postProcessBeforeInitialization()的源碼
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
// 獲取bean的metadata
LifecycleMetadata metadata = findLifecycleMetadata(bean.getClass());
try {
// 執(zhí)行@PostConstruct指定的init方法
metadata.invokeInitMethods(bean, beanName);
}
catch (InvocationTargetException ex) {
throw new BeanCreationException(beanName, "Invocation of init method failed", ex.getTargetException());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Failed to invoke init method", ex);
}
return bean;
}
metadata中已經(jīng)解析出initMethods和destroyMethods，其具體內(nèi)容如下赡麦。
metadata.invokeInitMethods(bean, beanName);就是根據(jù)反射執(zhí)行init方法虹统。
InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口弓坞。
public interface InstantiationAwareBeanPostProcessor extends BeanPostProcessor {
//實(shí)例化Bean之前調(diào)用
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;
//實(shí)例化Bean之后調(diào)用
boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException;
//設(shè)置Bean對(duì)象中的某個(gè)屬性時(shí)調(diào)用
PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException;
}
這兩個(gè)接口的功能基本類似，不過要注意InstantiationAwareBeanPostProcessor和BeanPostProcessor的方法名區(qū)別车荔。InstantiationAwareBeanPostProcessor中是Instantiation渡冻， 而BeanPostProcessor是Initialization。
參考閱讀
https://blog.csdn.net/chjttony/article/details/6301591
Spring開閉原則的表現(xiàn)-BeanPostProcessor擴(kuò)展點(diǎn)-2
