本文转自：链接

前言

SpringFramework其实具有很高的扩展性，只是很少人喜欢挖掘那些扩展点，而且官方的Refrence也很少提到那些Hook类或Hook接口，至于是不是Spring官方有意为之就不得而知。
目前看到的Spring的一些对外开放的扩展点、Hook接口或者Hook类，如果有什么错误，希望多多交流指正，一切以Spring的源码为准，文章编写使用的Spring版本为4.3.8.Release,对应SpringBoot的版本为1.5.3.RELEASE

1、Aware接口族

Spring中提供了各种Aware接口，方便从上下文中获取当前的运行环境，比较常见的几个子接口有：
BeanFactoryAware,BeanNameAware,ApplicationContextAware,EnvironmentAware，BeanClassLoaderAware等，这些Aware的作用都可以从命名得知，并且其使用也是十分简单。
例如我们经常看到SpringContext工具类：

  1. /**
  2.  * @author demon
  3.  * @date 2020/12/14 11:09
  4.  */
  5. @Component
  6. public class ApplicationAware implements ApplicationContextAware {
  7.     private static ApplicationContext applicationContext;
  10.     @Override
  11.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
  12.         ApplicationAware.applicationContext = applicationContext;
  13.     }
  15.     public static Object getBeanDefinition(String name) {
  16.         return applicationContext.getBean(name);
  17.     }
  20.     public static Object getBeanDefinition(String name, Class clazz) {
  21.         return applicationContext.getBean(name, clazz);
  22.     }
  23. }

实现ApplicationContextAware接口可以获取ApplicationContext
又例如想获取到当前的一个Spring Bean的BeanFactory：
一般来说，拿到的应该是 DefaultListableBeanFactory，因为这个BeanFactory是BeanFactory一族的最底层的BeanFactory实现类，拥有所有父BeanFactory的功能。其他的Aware可以自己尝试下功能。

2、InitializingBean接口和DisposableBean接口

InitializingBean接口只有一个方法#afterPropertiesSet，作用是：当一个Bean实现InitializingBean，#afterPropertiesSet方法里面可以添加自定义的初始化方法或者做一些资源初始化操作(Invoked by a BeanFactory after it has set all bean properties supplied ==> “当BeanFactory 设置完所有的Bean属性之后才会调用#afterPropertiesSet方法”)。

DisposableBean接口只有一个方法#destroy，作用是：当一个单例Bean实现DisposableBean，#destroy可以添加自定义的一些销毁方法或者资源释放操作(Invoked by a BeanFactory on destruction of a singleton ==>”单例销毁时由BeanFactory调用#destroy”)

使用例子:

  1. package com.alibaba.demo.service;
  3. import org.springframework.beans.factory.DisposableBean;
  4. import org.springframework.beans.factory.InitializingBean;
  5. import org.springframework.stereotype.Component;
  7. /**
  8.  * @author demon
  9.  * @date 2020/12/14 11:03
  10.  */
  11. @Component
  12. public class InitializeBean implements InitializingBean, DisposableBean {
  15.     /**
  16.      * bean 销毁之前做很多资源的释放
  17.      * @throws Exception
  18.      */
  19.     @Override
  20.     public void destroy() throws Exception {
  21.         System.out.println("=== destroy ===");
  23.     }
  25.     /**
  26.      * bean 初始化之前可以做很多个性化的配置
  27.      * @throws Exception
  28.      */
  29.     @Override
  30.     public void afterPropertiesSet() throws Exception {
  31.         System.out.println("=== init ===");
  32.     }
  33. }


3、ImportBeanDefinitionRegistrar接口

功能：
先看官方的注释

  1. /**
  2.  * Interface to be implemented by types that register additional bean definitions when
  3.  * processing @{@link Configuration} classes. Useful when operating at the bean definition
  4.  * level (as opposed to {@code @Bean} method/instance level) is desired or necessary.
  5.  *
  6.  * <p>Along with {@code @Configuration} and {@link ImportSelector}, classes of this type
  7.  * may be provided to the @{@link Import} annotation (or may also be returned from an
  8.  * {@code ImportSelector}).
  9.  *
  10.  * <p>An {@link ImportBeanDefinitionRegistrar} may implement any of the following
  11.  * {@link org.springframework.beans.factory.Aware Aware} interfaces, and their respective
  12.  * methods will be called prior to {@link #registerBeanDefinitions}:
  13.  * <ul>
  14.  * <li>{@link org.springframework.context.EnvironmentAware EnvironmentAware}</li>
  15.  * <li>{@link org.springframework.beans.factory.BeanFactoryAware BeanFactoryAware}
  16.  * <li>{@link org.springframework.beans.factory.BeanClassLoaderAware BeanClassLoaderAware}
  17.  * <li>{@link org.springframework.context.ResourceLoaderAware ResourceLoaderAware}
  18.  * </ul>
  19. ** /

翻译一下大概如下：
1.当处理Java编程式配置类(使用了@Configuration的类)的时候，ImportBeanDefinitionRegistrar接口的实现类可以注册额外的bean definitions;
2.ImportBeanDefinitionRegistrar接口的实现类必须提供给@Import注解或者是ImportSelector接口返回值
3.ImportBeanDefinitionRegistrar接口的实现类可能还会实现下面org.springframework.beans.factory.Aware接口中的一个或者多个，它们各自的方法优先于ImportBeanDefinitionRegistrar#registerBeanDefinitions被调用
org.springframework.beans.factory.Aware的部分接口如下：

  • org.springframework.context.EnvironmentAware(读取或者修改Environment的变量)
  • org.springframework.beans.factory.BeanFactoryAware (获取Bean自身的Bean工厂)
  • org.springframework.beans.factory.BeanClassLoaderAware(获取Bean自身的类加载器)
  • org.springframework.context.ResourceLoaderAware(获取Bean自身的资源加载器)

个人理解：
1.首先需要自定义一个类去实现ImportBeanDefinitionRegistrar接口， #registerBeanDefinitions方法的参数有(使用了@Import的类型)元注解AnnotationMetadata以及BeanDefinitionRegistry(Bean注册相关方法的提供接口)，通过BeanDefinitionRegistry的方法可以实现BeanDefinition注册、移除等相关操作；
2.为了保证1生效，必须定义一个Java配置类(带有注解@Configuration)通过@Import指定1中定义的实现类
一个例子：
目标是通过自定义注解@EnableThrowable里面的targets属性指定需要注册进去Spring容器的class，当注解使用在@Configuration的类上，实现指定class的注册，然后可以使用@Autowire实现自动注入。
定义ImportBeanDefinitionRegistrar的实现类EnableThrowableRegistrar：

Spring 钩子方法 - 图1
定义一个注解@EnableThrowable：
定义一个Java配置类ConcreteConfiguration：
定义一个非Spring管理的Service类ConcreteService：
测试代码：
Spring 钩子方法 - 图2
结果：
可以看到读取Environment属性成功，同时普通Java类ConcreteService成功注册到Spring容器并且自动注入和调用成功。

4、BeanPostProcessor接口和BeanFactoryPostProcessor接口

一般我们叫这两个接口为Spring的Bean后置处理器接口,作用是为Bean的初始化前后提供可扩展的空间。先看接口的方法：
BeanPostProcessor
BeanFactoryPostProcessor
BeanFactoryPostProcessor可以对bean的定义（配置元数据）进行处理。也就是说，Spring IoC容器允许BeanFactoryPostProcessor在容器实际实例化任何其它的bean之前读取配置元数据，并有可能修改它。
如果你愿意，你可以配置多个BeanFactoryPostProcessor。你还能通过设置’order’属性来控制BeanFactoryPostProcessor的执行次序。(大概可以这样理解:Spring容器加载了bean的定义文件之后，在bean实例化之前执行的)
实现BeanPostProcessor接口可以在Bean(实例化之后)初始化的前后做一些自定义的操作，但是拿到的参数只有BeanDefinition实例和BeanDefinition的名称，也就是无法修改BeanDefinition元数据,这里说的Bean的初始化是：
1）bean实现了InitializingBean接口，对应的方法为afterPropertiesSet
2）在bean定义的时候，通过init-method设置的方法
PS:BeanFactoryPostProcessor回调会先于BeanPostProcessor
使用例子：
实现一个BeanPostProcessor==>ConcreteBeanPostProcessor
Spring 钩子方法 - 图3
实现一个BeanFactoryPostProcessor==>ConcreteBeanFactoryPostProcessor
定义一个Spring的Bean
Spring 钩子方法 - 图4
测试类：
Spring 钩子方法 - 图5
结果：
Spring 钩子方法 - 图6

5、BeanDefinitionRegistryPostProcessor 接口

BeanDefinitionRegistryPostProcessor 接口可以看作是BeanFactoryPostProcessor和ImportBeanDefinitionRegistrar的功能集合，既可以获取和修改BeanDefinition的元数据，也可以实现BeanDefinition的注册、移除等操作。
例子：
定义一个BeanDefinitionRegistryPostProcessor==>ConcreteBeanDefinitionRegistryPostProcessor
Spring 钩子方法 - 图7
定义一个普通的Java类：
测试类：
Spring 钩子方法 - 图8
结果：

6、FactoryBean接口

首先第一眼要注意，是FactoryBean接口而不是BeanFactory接口。一般情况下，Spring通过反射机制利用bean的class属性指定实现类来实例化bean ，实例化bean过程比较复杂。
FactoryBean接口就是为了简化此过程，把bean的实例化定制逻辑下发给使用者。
在该接口中还定义了以下3个方法。
T getObject()：返回由FactoryBean创建的bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单实例缓存池中。
boolean isSingleton()：返回由FactoryBean创建的bean实例的作用域是singleton还是prototype。
Class getObjectType()：返回FactoryBean创建的bean类型。
注意一点：通过Spring容器的getBean()方法返回的不是FactoryBean本身，而是FactoryBean#getObject()方法所返回的对象，相当于FactoryBean#getObject()代理了getBean()方法。
如果希望获取CarFactoryBean的实例，则需要在使用getBean(beanName) 方法时在beanName前显示的加上 “&” 前缀。
一个例子：
实体类：
Spring 钩子方法 - 图9
自定义FactoryBean:
Spring 钩子方法 - 图10
测试类：
Spring 钩子方法 - 图11
结果：
结果和预期一样，通过ApplicationContext#getBean(beanName)获取到的实际上是FactoryBean#getObject的实例，ApplicationContext#getBean(“&” + beanName)获取到的才是FruitFactoryBean本身的实例。

7. ApplicationRunner与CommandLineRunner

如果在spring 应用启动后，想做一些定制化的操作，可以使用上述两个接口

  1. @Component
  2. public class ApplicationArgsService implements ApplicationRunner {
  4.     @Override
  5.     public void run(ApplicationArguments args) throws Exception {
  6.         System.out.println(args);
  7.     }
  8. }

debug 会发现上述代码会 在spring容器启动后执行