BeanPostProcessor执行步骤总结
BeanPostProcessor执行步骤总结或者说spring bean生命周期里的扩展点进行总结
public void createBean() {
// 可以返回一个bean以中断后续的实例化操作
1.InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation();
doCreateBean() {
// 进行实例化
createBeanInstance() {
// 如果通过之前的方法都没能解析出构造函数，调用该后置处理方法获取构造器
2.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors();
}
applyMergedBeanDefinitionPostProcessors() {
// 使用构造器实例化完毕后，将merged Beandefinitiong暴露出来
// 比如把被`@Autowired、@Value`等注解标记的成员变量或者方法实例标记
// 方便后续`populateBean()进行依赖注入的时候使用
3.MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition();
}
// 进行属性填充
populateBean() {
// 可用于自定义属性填充，短路后续属性填充逻辑
4.InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation();
// 细粒度的处理，@Autowired就在此处进行依赖注入
5.InstantiationAwareBeanPostProcessor#postProcessProperties();
}
// 进行初始化
initializeBean() {
// 生命周期里的一些awareMethod
invokeAwareMethods() {
BeanNameAware#setBeanName();
BeanClassLoaderAware().setBeanClassLoader();
BeanFactoryAware.setBeanFactory();
}
6. BeanPostProcessor#postProcessBeforeInitialization();
7. BeanPostProcessor#postProcessAfterInitialization();
}
}
}
public void destroyBean() {
8. DestructionAwareBeanPostProcessor#postProcessBeforeDestruction();
}
------------------------下边是简单的源码分析--------------------
重点BeanPostProcessor类图
[图片上传失败...(image-a6ddf6-1618332360968)]
主要介绍四个接口
InstantiationAwareBeanPostProcessorSmartInstantiationAwareBeanPostProcessorMergedBeanDefinitionPostProcessorDestructionAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor里边主要有三个方法
postProcessBeforeInstantiationpostProcessAfterInstantiationpostProcessProperties
主要作用于bean实例化的过程
postProcessBeforeInstantiation
@Nullable
default Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
用来在对象实例化前直接返回一个对象，代替通过内置的实例化流程创建对象，如果该方法出现返回值，说明返回的Object为初始化好的对象，转而执行BeanPostProcessor#postProcessBeforeInitialization方法。
该方法在生命周期里执行时间参考AbstractAutowireCapableBeanFactory#createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])，在createBean()方法体里，doCreateBean()方法之前调用
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {
.......
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
....,.
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
return beanInstance;
......
}
@Nullable
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) {
// 执行postProcessBeforeInstantiation()
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 执行applyBeanPostProcessorsAfterInitialization()
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
postProcessAfterInstantiation
default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
return true;
}
在属性实例化完毕，执行populateBean()进行属性填充之前执行，如果返回值为false则spring跳过属性填充及依赖注入的步骤。可以用于用户自定义属性填充操作。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
...... create bean instance.
Object exposedObject = bean;
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
......
}
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
...... 校验步骤
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
// 在此处调用postProcessAfterInstantiation()方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 如果调用返回为false，中断后续的属性填充逻辑
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}
}
...... 属性填充逻辑
}
postProcessProperties
@Nullable
default PropertyValues postProcessProperties(
PropertyValues pvs, Objects bean, String beanName) throws BeansException {
return null;
}
提供了更细粒度的操作，在spring处理完默认的成员属性，应用到指定的bean之前进行调用，可以用来进行属性检查和修改
@Autowired、@Resource等注解就是在这里实现最终的依赖注入
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
...... create bean instance.
Object exposedObject = bean;
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
......
}
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
......
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// (AutowiredAnnotationBeanPostprocessor实现了该方法对@Autowired标记的属性进行依赖注入)
PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
......
}
SmartInstantiationAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor继承于InstantiationAwareBeanPostProcessor里边扩展了三个方法
predictBeanTypedetermineCandidateConstructorsgetEarlyBeanReference
主要作用于bean实例化的过程
predictBeanType
default Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
调用时机不确定，如果beanDefinition中没有beanType，可以调用这个方法预测beanType
protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
Class<?> targetType = determineTargetType(beanName, mbd, typesToMatch);
// Apply SmartInstantiationAwareBeanPostProcessors to predict the
// eventual type after a before-instantiation shortcut.
if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
Class<?> predicted = ibp.predictBeanType(targetType, beanName);
if (predicted != null && (typesToMatch.length != 1 || FactoryBean.class != typesToMatch[0] ||
FactoryBean.class.isAssignableFrom(predicted))) {
return predicted;
}
}
}
}
return targetType;
}
determineCandidateConstructors
default Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
return null;
}
提供一个扩展点，来获取或者改变用来实例化的构造函数（比如没有通过bean定义构造器及参数的情况下，会根据这个扩展点确定构造器）
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
......
instanceWrapper = createBeanInstance(beanName, mbd, args);
......
}
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
......
// Candidate constructors for autowiring?
// 如果之前都没能够解析出构造器，调用createBeanInstance()尝试解析出构造器
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
......
}
// 调用所有的#determineConstructorsFromBeanPostProcessors解析构造函数
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName) throws BeansException {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
if (ctors != null) {
return ctors;
}
}
}
}
return null;
}
getEarlyBeanReference
default Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
return bean;
}
获取要提前暴露的bean的引用，用来支持单例bean的循环引用，在调用第三级缓存时，会调用getEarlyBeanReference()方法来获取实例。
我们都知道Spring解决单例的时候，使用了三级缓存
- 第一级从已经初始化完成的singletonMap中获取
- 第二级从earluSingletonMap中获取
- 第三级从singletonFactoryMap中获取
从直觉上来说，使用earluSingletonMap已经可以解决循环依赖的问题，为什么还要有第三级ObjectFactory缓存存在呢？这是为了解决aop的问题，也是getEarlyBeanReference的关键。关于循环依赖的问题，不在这里进行分析。
MergedBeanDefinitionPostProcessor
提供唯一方法
- postProcessMergedBeanDefinition
将merged BeanDefinition暴露出来
void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName);
在bean实例化完毕后调用，将merged BeanDefinition暴露出来，让使用者可以对其进行修改。比如其重点实现类AutowiredAnnotationBeanPostProcessor该类在此处把被@Autowired、@Value等注解标记的成员变量或者方法实例标记，方便后续populateBean()进行依赖注入的时候使用
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
......
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
......
}
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
DestructionAwareBeanPostProcessor
里边扩展方法
- postProcessBeforeDestruction
用于在对象销毁时执行销毁前置逻辑，比如清除缓存、监控等功能的实现
