Spring-BeanPostProcessor

最新推荐文章于 2024-08-11 20:00:32 发布

_半桶水

最新推荐文章于 2024-08-11 20:00:32 发布

阅读量138

点赞数

分类专栏： spring 文章标签： spring java

本文链接：https://blog.csdn.net/weixin_45794310/article/details/127830871

版权

spring 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

BeanPostProcessor

BeanPostProcessor是spring的bean增强器，也就是说我们交给spring管理的那些类，在创建之后还可以对他进行增强，那是怎么用的呢，我们这篇文章就来看看

BeanPostProcessor源码

public interface BeanPostProcessor {
    // 前置处理（bean初始化方法前）
   @Nullable
   default Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      return bean;
   }
    // 后置处理（bean初始化方法后）
   @Nullable
   default Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      return bean;
   }
}

这两个方法说明了在bean的什么时候增强，一个是bean之前(Before)，一个是bean之后(After)，那到底是在什么时候在哪里调用的呢，这里就不得不提到我们去spring的工厂获取bean时的操作流程，当spring容器中有的话，就直接返回，也就是说已经被创建过了，并且放在spring容器中了。那么BeanPostProcessor是在创建的时候执行的，我们就看看创建的那个方法,主要看看创建bean的那几个步骤吧

AbstractAutowireCapableBeanFactory.doCreateBean

反射创建对象（创建出来的对象里面的属性都是默认的）
填充属性
初始化bean

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
          throws BeanCreationException {
       // Instantiate the bean.
       BeanWrapper instanceWrapper = null;
       if (mbd.isSingleton()) {
          instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
       }
       if (instanceWrapper == null) {
          /** 反射创建bean: BeanUtils.instantiateClass(constructorToUse); */
          instanceWrapper = createBeanInstance(beanName, mbd, args);
       }
	   Object bean = instanceWrapper.getWrappedInstance();
       // Initialize the bean instance.
       Object exposedObject = bean;
       try {
          /** 填充属性，依赖注入等 */
          populateBean(beanName, mbd, instanceWrapper);
          /** 初始化bean,设置调用Aware和调用beanPostProcessor处理bean */
          exposedObject = initializeBean(beanName, exposedObject, mbd);
       }
       catch (Throwable ex) {
       }
       return exposedObject;
    }
}

在这里并没有看到我们BeanPostProcessor所要执行的那几个方法，那么是在哪个步骤里面呢，1.反射创建对象是不可能的，他只是反射创建对象，2.填充属性也不是，所以就是在第3步的时候了：初始化bean

为什么是初始化bean，这里我们可以知道哈，当一个完整的bean创建出来之后，我们才可以对他进行增强吧，所以我们看看initializeBean（）

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
            // 如果bean实现了某些Aware，这里就会调用对应的setXXX方法
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
            // 执行BeanPostProcessors的前置处理
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
            // 执行bean的初始化方法
			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()) {
            // 执行BeanPostProcessors的后置处理
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
}

这个方法有很多步骤要执行

先是把一些Aware写到bean去（如果实现了某些Aware接口的话): invokeAwareMethods(beanName, bean);
接下来就是到applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName); 眼不眼熟，就是我们要讲的BeanPostProcessors的BeforeInitialization吧
然后就是invokeInitMethods(beanName, wrappedBean, mbd); 执行初始化方法
最后就是applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 也是很眼熟吧，BeanPostProcessors的AfterInitialization

我们本篇主要讲的是BeanPostProcessors，所以我们就看看applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);和applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    @Override
	public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
        // 遍历BeanPostProcessor们执行他的前置处理方法
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
            // 如果前置处理返回的是null，就返回原先的bean，否则返回前置处理返回的
			Object current = processor.postProcessBeforeInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}

	@Override
	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {

		Object result = existingBean;
        // 遍历BeanPostProcessor们执行他的后置处理方法
		for (BeanPostProcessor processor : getBeanPostProcessors()) {
            // 如果前置处理返回的是null，就返回原先的bean，否则返回前置处理返回的
			Object current = processor.postProcessAfterInitialization(result, beanName);
			if (current == null) {
				return result;
			}
			result = current;
		}
		return result;
	}
}