spring 扩展点之后置处理器（PostProcessor）及Aware接口

PostProcessor

后置处理器（PostProcessor）是一种扩展机制，它可以让我们在Bean实例化、初始化和销毁的过程中加入自己的逻辑处理

BeanFactoryPostProcessor

BeanFactory后置处理器，用于在Bean工厂实例化Bean之前对Bean定义进行修改或自定义处理。它允许我们在Spring容器加载Bean定义后，在实例化Bean之前对这些定义进行干预和修改。

要想使用BeanFactory后置处理器，只需要实现BeanFactoryPostProcessor接口实现其postProcessBeanFactory方法。在postProcessBeanFactory接口可以获取到beanFacotry可以对bean定义进行操作。

用例：

@Component
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        BeanDefinition def = beanFactory.getBeanDefinition("xxx");
        def.setLazyInit(true);
    }
}

容器自动加载的BeanFactory后置处理器：

以AnnotationConfigApplicationContext容器实例化过程看，在AnnotationConfigApplicationContext构造函数会创建一个AnnotatedBeanDefinitionReader实例，然后会通过工具类判断注册一些processorAnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry)

public static Set registerAnnotationConfigProcessors(
      BeanDefinitionRegistry registry, @Nullable Object source) {

   DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
   if (beanFactory != null) {
      if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
         beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
      }
      if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
         beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
      }
   }

   Set beanDefs = new LinkedHashSet<>(8);

   if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
   if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   // Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
   if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition();
      try {
         def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
               AnnotationConfigUtils.class.getClassLoader()));
      }
      catch (ClassNotFoundException ex) {
         throw new IllegalStateException(
               "Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
      }
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
   }

   if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
      RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
      def.setSource(source);
      beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
   }

   return beanDefs;
}

BeanDefinitionRegistryPostProcessor：

Bean定义注册后置处理器，这个也是在bean被初始化之前对bean定义进行修改，比BeanFactory后置处理其稍早一些，暴露的是BeanDefinitionRegistry注册对象。同时Bean定义注册后置处理器是继承了BeanFacotry后置处理器，也可以获取BeanFacotry。

用例：实现BeanDefinitionRegistryPostProcessor接口即可

@Component
public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
       //新加载一个bean
        BeanDefinition selfDef = BeanDefinitionBuilder.genericBeanDefinition(SelfDefBean.class).getBeanDefinition();
        registry.registerBeanDefinition("selfDef",selfDef);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		//TODO 
    }
}

上面BeanFactoryPostProcessor和BeanDefinitionRegistryPostProcessor两种类型的后置处理器都是容器在bean加载之前暴露BeanDefinitionRegistry或beanFactory允许开发人员对beandef进行修改的机会。因为再往后就要开始对bean进行实例化了。那么这两种后置处理器在什么时候执行的呢？

在context的refresh方法里有几步是关于BeanFactoryPostProcessor的操作

public void refresh() throws BeansException, IllegalStateException {
      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);
      try {
         //这里是个空方法
         postProcessBeanFactory(beanFactory);
         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);
        //...
      }
}

prepareBeanFactory方法，这里会初始化一些系统默认的post

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

然后在invokeBeanFactoryPostProcessors方法调用post。最后在PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()方法获取不同类型的post并执行。

public static void invokeBeanFactoryPostProcessors(
      ConfigurableListableBeanFactory beanFactory, List beanFactoryPostProcessors) {

   //省略很多，优先级较高的容器级post...
   //获取BeanFactoryPostProcessor类型的post
   String[] postProcessorNames =
         beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);

   // ...

   // First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
   sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
   //执行post
   invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

   // Next, invoke the BeanFactoryPostProcessors that implement Ordered.
   //...
}

获取post方法beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false)。从beanDef里获取BeanFactoryPostProcessor类型的。所以我们要自定义一个postProcessor只要定义一个实现BeanFactoryPostProcessor接口的bean就好了。

调用就很简单了，调用post实现的接口方法postProcessBeanFactory就可以了。

private static void invokeBeanFactoryPostProcessors(
      Collection postProcessors, ConfigurableListableBeanFactory beanFactory) {

   for (BeanFactoryPostProcessor postProcessor : postProcessors) {
      postProcessor.postProcessBeanFactory(beanFactory);
      postProcessBeanFactory.end();
   }
}

BeanPostProcessor

bean初始化前后通知，这个是在每个bean初始化时候都会执行

同样post的解析获取在refresh方法有一步registerBeanPostProcessors(beanFactory);同factory的post查找方法也是通过beanFactory.getBeanNamesForType(BeanPostProcessor.class)获取BeanPostProcessor。所以要自定义一个beanpost只要实现BeanPostProcessor接口，重写 postProcessBeforeInitialization，postProcessAfterInitialization两个方法。在bean的实例化前后执行

执行时机

从bean的创建开始，

在AbstractAutowireCapableBeanFactory.doCreateBean方法会有

//注入依赖属性
populateBean(beanName, mbd, instanceWrapper);
//初始化bean，调用post方法
exposedObject = initializeBean(beanName, exposedObject, mbd);

在initializeBean方法的最后会调用post方法

protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
   if (System.getSecurityManager() != null) {
      AccessController.doPrivileged((PrivilegedAction