spring-BeanPostProcessor-1
spring 从扩展点说起
spring 两大功能IOC,AOP。spring的扩展如何呢？我们想在bean实例化的时候做些修改该如何做呢？在bean销毁的时候能做什么呢？AOP的代理对象是什么时候注入的？
BeanPostProcessor 接口
public interface BeanPostProcessor {
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}
可以看出这个接口是定义一些在Initialization操作前后的操作，那这个接口是实现的呢？我们来看看Bean创建的流程
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
//创建出BeanFactory,解析出xml的元素成BeanDefinitions
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
//为BeanFactory设置classLoader,BeanExpressionResolver,PropertyEditorRegistrar,注册ApplicationContextAwareProcessor
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);
// 实例化所有的BeanPostProcessors
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();
// 实例化Bean
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
// 省略
}
}
1、从AbstractAutowireCapableBeanFactory的createBean方法看
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
//1.1、解析出其bean class ，若解析出错抛出CannotLoadBeanClassException异常
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 1.2、做注入方法验证 ，若出错则抛出BeanDefinitionValidationException异常
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
//1.3 执行InstantiationAwareBeanPostProcessors的前置，后置方法执行
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
接上面的1，可以看到这里，其根据注册的InstantiationAwareBeanPostProcessors执行，其能自定义类的初始化的预处理，以及后置处理
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.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//1.3.1、执行InstantiationAwareBeanPostProcessors的applyBeanPostProcessorsBeforeInstantiation方法
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//1.3.2、执行InstantiationAwareBeanPostProcessors的applyBeanPostProcessorsAfterInitialization
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
2、AbstractAutowireCapableBeanFactory的createBeanInstance方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
//2.1通过BeanWrapper 实例化bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
// 2.2 执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
mbd.postProcessed = true;
}
}
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
//log省略
addSingletonFactory(beanName, new ObjectFactory<Object>() {
//2.3暴露出及早暴露的bean的引用，使其支持set的循环引用通过SmartInstantiationAwareBeanPostProcessor
//的getEarlyBeanReference方法，获取一个bean的引用
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//2.4 组装bean依赖
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//2.5 实例化bean
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
//省略异常
if (earlySingletonExposure) {
//2.6 触发 2.3的getObject()方法，获取bean引用
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// 2.7注册bean销毁方法
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
2.4 组装依赖装配
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
PropertyValues pvs = mbd.getPropertyValues();
if (bw == null) {
if (!pvs.isEmpty()) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
return;
}
}
boolean continueWithPropertyPopulation = true;
//2.4.1 执行 InstantiationAwareBeanPostProcessor 扩展点，执行自定义装配流程
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
}
}
}
if (!continueWithPropertyPopulation) {
return;
}
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
//2.4.2 执行自动装配 by name/type
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
2.4.3 执行 InstantiationAwareBeanPostProcessor的postProcessPropertyValues方法
if (hasInstAwareBpps || needsDepCheck) {
PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
if (hasInstAwareBpps) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
}
}
//2.4.4 执行依赖检查
if (needsDepCheck) {
checkDependencies(beanName, mbd, filteredPds, pvs);
}
}
//2.4.5执行 依赖注入
applyPropertyValues(beanName, mbd, bw, pvs);
}
2.5 执行bean实例化
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 {
//2.5.1 调用Aware接口注入，BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
//2.5.2 执行BeanPostProccessor的postProcessBeforeInitialization方法
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
//2.5.3执行InitializingBean的afterPropertiesSet方法，和定义的init-method
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//2.5.4 执行执行BeanPostProccessor的postProcessAfterInitialization方法
if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
Bean 实例化流程总结
1、AbstractAutowireCapableBeanFactory的createBean()
1.1 Class<?> resolvedClass = resolveBeanClass(mbd, beanName); 解析出bean的class，若失败则抛出CannotLoadBeanClassException异常
1.2 mbdToUse.prepareMethodOverrides(); 准备和验证方法注入，出错则抛出BeanDefinitionValidationException异常
1.3 Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 此处只执行InstantiationAwareBeanPostProcessor类型的 BeanPostProcessor的bean
执行InstantiationAwareBeanPostProcessor的预处理方法postProcessBeforeInstantiation的方法，若返回值不是Null,则继续执行postProcessAfterInitialization方法，
若此处返回的bean不是null则不进行后续操作 (第一个BeanPostProcessor的扩展点)
2、AbstractAutowireCapableBeanFactory的doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args)方法
2.1 createBeanInstance 实例化bean
2.1.1通过工厂方法实例化instantiateUsingFactoryMethod(beanName, mbd, args)；
2.1.2构造器实例化
2.1.2.1 如果之前已经解析过构造器，有参调用autowireConstructor实例化，无参则调用instantiateBean实例化
2.1.2.2 如果没有解析过构造器，则通过SmartInstantiationAwareBeanPostProcessor的determineCandidateConstructors解析出构造器，(第二个扩展点)
若返回值不为null，则调用autowireConstructor实例化，此处会调用AutowiredAnnotationBeanPostProcessor实现将自动扫描通过@Autowired/@Value
注解的构造器从而可以完成构造器注入
2.2 执行MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法(第三个扩展点)
2.3 暴露出及早暴露的bean的引用，使其支持set的循环引用通过SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法，获取一个bean的引用(第四个扩展点)
2.4 populateBean(beanName, mbd, instanceWrapper); 组装bean依赖
2.4.1 InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation() 方法(第五个扩展点)，自动装配前的检查，如果返回是false则下面的都不会执行
2.4.2 autowireByName,autowireByType 的自动装配
2.4.3 InstantiationAwareBeanPostProcessor的 postProcessPropertyValues() 方法(第六个扩展点)，完成一些定制化的注入，
如AutowiredAnnotationBeanPostProcessor执行@Autowired注解注入，CommonAnnotationBeanPostProcessor执行@Resource等注解的注入，
PersistenceAnnotationBeanPostProcessor执行@ PersistenceContext等JPA注解的注入，RequiredAnnotationBeanPostProcessor执行@ Required注解的检查等等
2.4.4 checkDependencies(beanName, mbd, filteredPds, pvs) 依赖检查
2.4.5 applyPropertyValues(beanName, mbd, bw, pvs); 执行 set 注入
2.5 exposedObject = initializeBean(beanName, exposedObject, mbd);初始化bean 流程
2.5.1 invokeAwareMethods(beanName, bean); 执行Aware接口入参 BeanNameAware，BeanClassLoaderAware，BeanFactoryAware
2.5.2 执行BeanPostProcessor 的postProcessBeforeInitialization 方法 (第七扩展点)
在调用初始化之前完成一些定制的初始化任务，如BeanValidationPostProcessor完成JSR-303 @Valid注解Bean验证，
InitDestroyAnnotationBeanPostProcessor完成@PostConstruct注解的初始化方法调用，
ApplicationContextAwareProcessor完成一些Aware接口的注入（如EnvironmentAware、ResourceLoaderAware、ApplicationContextAware），其返回值将替代原始的Bean对象
2.5.3 invokeInitMethods(beanName, wrappedBean, mbd);
2.5.3.1 执行InitializingBean接口的afterPropertiesSet()初始化方法，已经xml定义的init-method方法
2.5.4 执行BeanPostProcessor的postProcessAfterInitialization 方法(第八个扩展点)
第八个扩展点，AspectJAwareAdvisorAutoProxyCreator（完成xml风格的AOP配置(<aop:config>)
的目标对象包装到AOP代理对象）、AnnotationAwareAspectJAutoProxyCreator（完成@Aspectj注解风格（<aop:aspectj-autoproxy>
@Aspect）的AOP配置的目标对象包装到AOP代理对象），其返回值将替代原始的Bean对象
2.7注册bean销毁方法
registerDisposableBeanIfNecessary(beanName, bean, mbd); 注册单例bean的销毁流程
2.7.1 DestructionAwareBeanPostProcessor的postProcessBeforeDestruction (第九个扩展点)，DisposableBean的destroy：注册/调用DisposableBean的destroy销毁方法
通过xml指定的自定义destroy-method ： 注册/调用通过XML指定的destroy-method销毁方法，Scope的registerDestructionCallback：注册自定义的Scope的销毁回调方法。
