Spring中的BeanPostProcessors

BeanPostProcessor

Bean后置处理器基类

• Object postProcessBeforeInitialization：Bean初始化方法执行前调用，返回Bean
• Object postProcessAfterInitialization：Bean初始化方法执行后调用，返回Bean

DestructionAwareBeanPostProcessor

用于Bean销毁时的增强处理器

• boolean requiresDestruction：默认返回true，表示bean需要销毁
• void postProcessBeforeDestruction：Bean销毁方法执行前调用

MergedBeanDefinitionPostProcessor

用于处理MergedBeanDefinition，如父子类，子类创建时需要注入父类属性

• void postProcessMergedBeanDefinition：属性注入后，初始化方法之前执行，处理MergedBeanDefinition

InstantiationAwareBeanPostProcessor

用于Bean实例化的增强处理器

• Object postProcessBeforeInstantiation：bean实例化之前调用，若返回值不为null，则bean创建流程快进到postProcessAfterInitialization处理阶段
• boolean postProcessAfterInstantiation：bean实例化之后，populate之前调用，若返回值为false，跳过populate阶段
• PropertyValues postProcessPropertyValues：populate时调用，处理PropertyValues

SmartInstantiationAwareBeanPostProcessor

用于推断、预测等情况下的增强处理器

• Class<?> predictBeanType：推断bean的Class类型，isTypeMatch、getType方法使用
• Constructor<?>[] determineCandidateConstructors：bean实例化前调用，用来处理构造器依赖注入的情况，返回构造器
• Object getEarlyBeanReference：依赖注入阶段，处理循环依赖，与三级缓存配合使用

注册流程

源码分析

public static void registerBeanPostProcessors(
      ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {

   String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

   // Register BeanPostProcessorChecker that logs an info message when
   // a bean is created during BeanPostProcessor instantiation, i.e. when
   // a bean is not eligible for getting processed by all BeanPostProcessors.

   // 不是所有的BeanPostProcessor都是Bean
   // beanFactory.getBeanPostProcessorCount()：注册到beanFactory中的Processor
   // postProcessorNames.length：BeanDefinition中的Processor
   int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
   beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));

   // Separate between BeanPostProcessors that implement PriorityOrdered,
   // Ordered, and the rest.

   // 实现PriorityOrdered接口的Processor
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   // Spring内部的Processor，不对外暴露
   // 这里存储MergedBeanDefinitionPostProcessor
   List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
   // 实现Ordered接口的Processor
   List<String> orderedPostProcessorNames = new ArrayList<String>();
   // 普通的Processor
   List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
   for (String ppName : postProcessorNames) {
      if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
         BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
         priorityOrderedPostProcessors.add(pp);
         if (pp instanceof MergedBeanDefinitionPostProcessor) {
            internalPostProcessors.add(pp);
         }
      }
      else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
         orderedPostProcessorNames.add(ppName);
      }
      else {
         nonOrderedPostProcessorNames.add(ppName);
      }
   }

   // First, register the BeanPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // beanFactory中以list存储注册的BeanPostProcessors，以注册先后顺序存储
   registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

   // Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : orderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      orderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   sortPostProcessors(orderedPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, orderedPostProcessors);

   // Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
   for (String ppName : nonOrderedPostProcessorNames) {
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      nonOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
         internalPostProcessors.add(pp);
      }
   }
   registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

   // Finally, re-register all internal BeanPostProcessors.
   // 重新注册MergedBeanDefinitionPostProcessor，保证顺序在最后
   sortPostProcessors(internalPostProcessors, beanFactory);
   registerBeanPostProcessors(beanFactory, internalPostProcessors);

   // Re-register post-processor for detecting inner beans as ApplicationListeners,
   // moving it to the end of the processor chain (for picking up proxies etc).
   // 重新注册ApplicationListenerDetector保证顺序在最后
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}