Spring5源码5-Bean生命周期后置处理器_spring生命周期以及后置处理器-优快云博客

本文主要讲解 Bean的生命周期后置处理器，关于bean创建对象流程我们后面在讲。主要说明三种生命周期增强器：

BeanFactoryPostProcessor:BeanFactory 后置处理器
- BeanDefinitionRegistryPostProcessor：bean定义注册后置处理器
- BeanFactoryPostProcessor
BeanPostProcessor:Bean后置处理器
- BeanPostProcessor
- MergedBeanDefinitionPostProcessor
- SmartInstantiationAwareBeanPostProcessor
- InstantiationAwareBeanPostProcessor
InitializingBean
DisposableBean (销毁的方案我们暂时不做说明)

1. 简介

1.1 什么是 BeanPostProcessor

BeanPostProcessor 是 Spring提供给我们的一个非常重要的扩展接口，并且Spring内部的很多功能也是通过 BeanPostProcessor 来完成的(目前看到最典型的就是 AnnotationAwareAspectJAutoProxyCreator 的注入)。

1.2 BeanPostProcessor 的种类

BeanPostProcessor 在Spring 中的子类非常多(idea 显是有46个)，比如

InstantiationAwareBeanPostProcessorAdapter ：在Spring 的bean加载过程中起了非常重要的作用
AnnotationAwareAspectJAutoProxyCreator ： bean 创建过程中的属性注入时起作用
AspectJAwareAdvisorAutoProxyCreator ： Aspect 的 AOP 功能实现也全仰仗BeanPostProcessor 的特性。

1.3 创建时机

BeanFactoryPostProcessor：在 Spring 启动时对BeanDefinition 的创建进行干预处理。

BeanPostProcessor:一是Bean对应的BeanDefinition 的创建。二是Bean 实例的创建。因为在 Spring容器中，Bean的创建并非仅仅通过反射创建就结束了，在创建过程中，需要考虑到Bean针对Spring容器中的一些属性，所以BeanDefinition 中不仅仅包含了 Bean Class 文件信息，还包含了当前Bean在Spring容器中的一些属性，比如在容器中的作用域、是否懒加载、别名等信息。当Bean 进行实例化创建时需要依赖于对应的BeanDefinition 提供对应的信息。。

而由于 BeanPostProcessor 是参与了 Bean 创建过程。所以其创建一定在普通 Bean 之前。实际上 BeanPostProcessor 的创建时在 Spring 启动时容器刷新的时候。

BeanPostProcessor 的 BeanDefinition 创建时机和普通 Bean没有区别，都是在Spring 启动时的BeanFactoryPostProcessor 中完成(确切的说是 ConfigurationClassPostProcessor 中完成)。

而BeanPostProcessor 的实例创建要优先于普通bean创建，Spring启动过程中会调用AbstractApplicationContext#registerBeanPostProcessors 方法。在这个方法中，Spring 会从容器中获取到所有BeanPostProcessor 类型的beanName，通过 beanFactory.getBean 方法获取到对应实例，进行排序后注册到 BeanFactory.beanPostProcessors 属性中.当容器需要执行 BeanPostProcessor 方法时可以直接从 beanPostProcessors 中获取即可。

2. 案例

分别定义几个测试类，实现bean的后置处理器：

BeanDefinitionRegistryPostProcessor:

/**
 * BeanFactory的后置处理器  , PriorityOrdered, Ordered
 */
@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
   public MyBeanDefinitionRegistryPostProcessor(){
      System.out.println("MyBeanDefinitionRegistryPostProcessor");
   }

   @Override  //紧接着执行
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanFactory...");
   }

   @Override  //先执行的
   public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
      System.out.println("MyBeanDefinitionRegistryPostProcessor...postProcessBeanDefinitionRegistry...");
      //增强bean定义信息的注册中心，比如自己注册组件

   }
}

BeanFactoryPostProcessor:

/**
 * BeanFactory的后置处理器
 */
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {

   public MyBeanFactoryPostProcessor(){
      System.out.println("MyBeanFactoryPostProcessor...");
   }

   @Override
   public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
      System.out.println("BeanFactoryPostProcessor....postProcessBeanFactory==>"+beanFactory);
   }
}

BeanPostProcessor:

/**
 * Bean组件的 PostProcessor；
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

   public MyBeanPostProcessor(){
      System.out.println("MyBeanPostProcessor...");
   }

   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("MyBeanPostProcessor...postProcessAfterInitialization..."+bean+"==>"+beanName);
      return bean;
   }

   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("MyBeanPostProcessor...postProcessBeforeInitialization..."+bean+"==>"+beanName);
      return bean; // new Object();
   }
}

InstantiationAwareBeanPostProcessor:

@Component
public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {

   public MyInstantiationAwareBeanPostProcessor(){
      System.out.println("MyInstantiationAwareBeanPostProcessor...");
   }

   //初始化之前进行后置处理，Spring留给我们给这个组件创建对象的回调。
   public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
      System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>"+beanClass+"--"+beanName);
      //if(class.isAssFrom(Cat.class)){return new Dog()}
      //如果我们自己创建了对象返回。Spring则不会帮我们创建对象，用我们自己创建的对象？ 我们创建的这个对象，Spring会保存单实例？还是每次getBean都调到我们这里创建一个新的？
      return null;
   }

   // 是否让剩下的后置处理器对bean继续进行处理
   public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
      //提前改变一些Spring不管的bean里面的属性
      System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessAfterInstantiation=>"+bean+"--"+beanName);
      return true; //返回false则bean的赋值全部结束
   }
   //解析自定义注解进行属性值注入；pvs 封装了所有的属性信息。
   public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
         throws BeansException { //@GuiguValue();redis
      System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties=>"+bean+"--"+beanName);
      return null;
   }

// public PropertyValues postProcessPropertyValues(
//       PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
//    System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties");
//    return pvs;
// }
}

MergedBeanDefinitionPostProcessor:

@Component
public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {

   public MyMergedBeanDefinitionPostProcessor(){
      System.out.println("MyMergedBeanDefinitionPostProcessor...");
   }

   @Override
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessBeforeInitialization...=>"+bean+"--"+beanName);
      return bean; //null
   }

   @Override
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessAfterInitialization..=>"+bean+"--"+beanName);
      return null;
   }

   @Override
   public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
      System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessMergedBeanDefinition..=>"+beanName+"--"+beanType+"---"+beanDefinition);
   }

   @Override
   public void resetBeanDefinition(String beanName) {
      System.out.println("MyMergedBeanDefinitionPostProcessor...resetBeanDefinition.."+beanName);

   }
}

SmartInstantiationAwareBeanPostProcessor:

@Component   //bean进行代理增强期间进行使用
public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {

   public MySmartInstantiationAwareBeanPostProcessor(){
      System.out.println("MySmartInstantiationAwareBeanPostProcessor...");
   }

   //预测bean的类型，最后一次改变组件类型。
   public Class<?> predictBeanType(Class<?> beanClass, String beanName) throws BeansException {
      System.out.println("MySmartInstantiationAwareBeanPostProcessor...predictBeanType=>"+beanClass+"--"+beanName);
      return null;
   }

    //返回我们要使用的构造器候选列表
   public Constructor<?>[] determineCandidateConstructors(Class<?> beanClass, String beanName) throws BeansException {
      System.out.println("MySmartInstantiationAwareBeanPostProcessor...determineCandidateConstructors=>"+beanClass+"--"+beanName);
      //返回一个我们指定的构造器
      return null;
   }

     //返回早期的bean引用，定义三级缓存中的bean信息
   public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
      System.out.println("MySmartInstantiationAwareBeanPostProcessor...getEarlyBeanReference=>"+bean+"--"+beanName);

      return bean; //
   }

}

InitializingBean:

@Component
public class CatInitializingBean implements InitializingBean {

   public CatInitializingBean(){
      System.out.println("cat被创建了...");
   }

   private String name;


   @Value("${JAVA_HOME}") //自动赋值功能
   public void setName(String name) {
      System.out.println("cat....setName正在赋值调用....");
      this.name = name;
   }
   //注解怎么定义这个是初始化方法？
   public String getName() {
      return name;
   }

   @Override
   public void afterPropertiesSet() throws Exception {
      System.out.println("CatInitializingBean..afterPropertiesSet...");
   }

   @Autowired
   private void init() {
      System.out.println("CatInitializingBean init....");
   }

}

debug打点：在每个构造器和方法上都打上断点，主要看看每个方法的执行时机是什么时候？

3. 源码分析

入口还是： org.springframework.context.support.AbstractApplicationContext#refresh：

// 容器刷新的十二大步骤
@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // 容器启动的状态
      StartupStep contextRefresh = this.applicationStartup.star