Spring SpringBoot扩展接口
文章目录
- Spring初始化一些类的继承关系
- 调用顺序
- 在spring文档中有一批继承Aware接口，而Aware的作用是：
- 比较常用到的接口
- Spring Boot启动过程
- Bean初始化过程中的拓展接口详解
-
- 1. ApplicationContextInitializer
- 2. BeanDefinitionRegistryPostProcessor
- 3. BeanFactoryPostProcessor
- 4. InstantiationAwareBeanPostProcessor
- 5. SmartInstantiationAwareBeanPostProcessor
- 6. BeanFactoryAware
- 7. ApplicationContextAwareProcessor
- 8. BeanNameAware
- 9. EnvironmentAware
- 10. ApplicationContextAware
- 11. @PostConstruct
- 12. InitializingBean
- 13. FactoryBean
- 14. SmartInitializingSingleton
- 15. CommandLineRunner / ApplicationRunner
- 16. DisposableBean
- 17. ApplicationListener
- 自定义注解扫描
Spring初始化一些类的继承关系
调用顺序
在spring文档中有一批继承Aware接口，而Aware的作用是：
A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method. The actual method signature is determined by individual subinterfaces but should typically consist of just one void-returning method that accepts a single argument.
一个标记超接口，指示bean有资格通过回调样式的方法被特定框架对象的Spring容器通知。实际的方法签名由单个子接口确定，但通常只应包含一个接受单个参数的void返回方法。
- 继承该接口的都有赋予提前暴露的意思，官方api中罗列出了所有继承该接口的接口
All Known Subinterfaces:
ApplicationContextAware, ApplicationEventPublisherAware, BeanClassLoaderAware, BeanFactoryAware, BeanNameAware, BootstrapContextAware, EmbeddedValueResolverAware, EnvironmentAware, ImportAware, LoadTimeWeaverAware, MessageSourceAware, NotificationPublisherAware, ResourceLoaderAware, SchedulerContextAware, ServletConfigAware, ServletContextAware
比较常用到的接口
- BeanFactoryAware接口 暴露BeanFactory ：实现该接口方法可以拿到暴露BeanFactory
- ResourceLoaderAware接口 暴露ResourceLoader： 实现该接口获取资源加载器,可以获得外部资源文件
- BeanNameAware接口 暴露beanName: 实现该接口可以获取bean名字
- MessageSourceAware 暴露MessageSource：实现该接口可以设置国际化信息替换
- EnvironmentAware 暴露Environment：获取所有配置信息继承PropertyResolver可以获取key-value
- ApplicationContextAware 暴露ApplicationContext：实现该接口可以获取到容器上下文（ApplicationContext接口继承BeanFactory，包括Environment、MessageSource、ApplicationEventPublisher、ResourceLoader基本上涵盖以上所有作用）
- ServletContextAware 暴露ServletContext：获取Servlet上下文信息
- ServletConfigAware 暴露ServletConfig：包括可以获取ServletContext
- InstantiationAwareBeanPostProcessor 在Bean实例化前后做一些操作。这个接口实际上我们也是非常的熟悉，该接口在我们剖析注解配置AOP的时候是我们的老朋友，实际上，注解配置的AOP是间接实现 BeanPostProcess 接口的，而 InstantiationAwareBeanPostProcessor 就是继承该接口
- CommandLineRunner 容器初始化完成后执行，可获取设置的环境变量参数
- ApplicationRunner 容器初始化完成后执行一个代码
- 接着下面也是整理些在开发中比较常用的接口：
- BeanPostProcessor接口 ： bean实例化前后处理，实现该接口可以在bean实例化前后进行操作，与之类似接口BeanFactoryPostProcessor该接口在注册bean（BeanDefinitionsMap）后的操作
- InitializingBean接口 :initializeBean时执行，即BeanPostProcessor执行完before后执行该接口方法afterPropertiesSet
- ImportBeanDefinitionRegistrar接口： registerBeanDefinitions bean注册到BeanDefinitionsMap
- ImportSelector接口，返回所有classname数组,在注册bean是调用获取，之后放入BeanDefinitionsMap与ImportBeanDefinitionRegistrar有点类似作用
- DeferredImportSelector接口：继承ImportSelector接口，作用差不多，只不过该接口延迟被注册，ImportSelector接口注册完bean之后才会接着注册DeferredImportSelector的bean
- ApplicationListener接口: 监听接口，当bean被初始化完成并被成功装载后会触发该事件，在最后一步finishRefresh时调用，实现ApplicationListener接口可以收到监听动作
- ApplicationContextInitializer接口： 刷新容器前也就是prepareContext时遍历调用，也就是bean注册前调用
- FactoryBean接口：自定义Bean的创建过程,将对象放入beanFactory
而以上这些接口什么时候被调用及初始化暴露的类呢？
- 下面大概流程：
BeanPostProcessor在实例化bean（一级缓存间）时被循环调用到，在该方法下initializeBean（finishBeanFactoryInitialization），先invokeAwareMethods这个方法进行调用BeanNameAware，BeanFactoryAware和BeanClassLoaderAware的重写方法进行赋值BeanName，BeanFactory和BeanClassLoader；然后接着遍历所有BeanPostProcessor接口的postProcessBeforeInitialization方法，其中ApplicationContextAwareProcessor类的postProcessBeforeInitialization方法是调用ApplicationContextAware，EnvironmentAware，ResourceLoaderAware、MessageSourceAware的重写方法进行赋值ApplicationContext，Environment，ResourceLoader、MessageSource，以及ServletContextAwareProcessor类的postProcessBeforeInitialization方法调用 ServletContextAware和ServletConfigAware的方法进行初始化 ServletContext和ServletConfig；初始化这些值之后，进行InitializingBean接口的afterPropertiesSet调用，然后接着遍历调用BeanPostProcessor接口的postProcessAfterInitialization。还有一个类似的接口InstantiationAwareBeanPostProcessor，该接口是在实例化对象放入beanFactory三级缓存中的前后进行调用操作和BeanPostProcessor类似（当然它继承于BeanPostProcessor），只不过比BeanPostProcessor接口要早被调用到
Spring Boot启动过程
-
Spring的核心思想就是容器，当容器refresh的时候，外部看上去风平浪静，其实内部则是一片惊涛骇浪。Springboot更是封装了Spring，遵循约定大于配置，加上自动装配的机制。很多时候我们只要引用了一个依赖，几乎是零配置就能完成一个功能的装配。
我非常喜欢这种自动装配的机制，所以在自己开发中间件和公共依赖工具的时候也会用到这个特性。让使用者以最小的代价接入。想要把自动装配玩的转，就必须要了解spring对于bean的构造生命周期以及各个扩展接口。当然了解了bean的各个生命周期也能促进我们加深对spring的理解。业务代码也能合理利用这些扩展点写出更加漂亮的代码。 -
可扩展的接口启动调用顺序图
以下是我整理的spring容器中Bean的生命周期内所有可扩展的点的调用顺序
Bean初始化过程中的拓展接口详解
1. ApplicationContextInitializer
- org.springframework.context.ApplicationContextInitializer
这是整个spring容器在刷新之前初始化ConfigurableApplicationContext的回调接口，简单来说，就是在容器刷新之前调用此类的initialize方法。这个点允许被用户自己扩展。用户可以在整个spring容器还没被初始化之前做一些事情。
可以想到的场景可能为，在最开始激活一些配置，或者利用这时候class还没被类加载器加载的时机，进行动态字节码注入等操作。
扩展方式为：
public class TestApplicationContextInitializer implements ApplicationContextInitializer {
@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
System.out.println("[ApplicationContextInitializer]");
}
}
因为这时候spring容器还没被初始化，所以想要自己的扩展的生效，有以下三种方式：
在启动类中用SpringApplication.addInitializers(new TestApplicationContextInitializer())语句加入
配置文件配置context.initializer.classes=com.example.demo.TestApplicationContextInitializer
Spring SPI扩展，在spring.factories中加入org.springframework.context.ApplicationContextInitializer=com.example.demo.TestApplicationContextInitializer
2. BeanDefinitionRegistryPostProcessor
- org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor
这个接口在读取项目中的beanDefinition之后执行，提供一个补充的扩展点
使用场景：你可以在这里动态注册自己的beanDefinition，可以加载classpath之外的bean
扩展方式为:
public class TestBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanDefinitionRegistry");
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("[BeanDefinitionRegistryPostProcessor] postProcessBeanFactory");
}
}
3. BeanFactoryPostProcessor
- org.springframework.beans.factory.config.BeanFactoryPostProcessor
这个接口是beanFactory的扩展接口，调用时机在spring在读取beanDefinition信息之后，实例化bean之前。
在这个时机，用户可以通过实现这个扩展接口来自行处理一些东西，比如修改已经注册的beanDefinition的元信息。
扩展方式为：
public class TestBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
System.out.println("[BeanFactoryPostProcessor]");
}
}
4. InstantiationAwareBeanPostProcessor
- org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor
该接口继承了BeanPostProcess接口，区别如下：
BeanPostProcess接口只在bean的初始化阶段进行扩展（注入spring上下文前后），而InstantiationAwareBeanPostProcessor接口在此基础上增加了3个方法，把可扩展的范围增加了实例化阶段和属性注入阶段。
该类主要的扩展点有以下5个方法，主要在bean生命周期的两大阶段：实例化阶段和初始化阶段，下面一起进行说明，按调用顺序为：
-
postProcessBeforeInstantiation：实例化bean之前，相当于new这个bean之前 -
postProcessAfterInstantiation：实例化bean之后，相当于new这个bean之后 -
postProcessPropertyValues：bean已经实例化完成，在属性注入时阶段触发，@Autowired,@Resource等注解原理基于此方法实现 -
postProcessBeforeInitialization：初始化bean之前，相当于把bean注入spring上下文之前 -
postProcessAfterInitialization：初始化bean之后，相当于把bean注入spring上下文之后
使用场景：这个扩展点非常有用 ，无论是写中间件和业务中，都能利用这个特性。比如对实现了某一类接口的bean在各个生命期间进行收集，或者对某个类型的bean进行统一的设值等等。
扩展方式为：
public class TestInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] before initialization " + beanName);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] after initialization " + beanName);
return bean;
}
@Override
public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] before instantiation " + beanName);
return null;
}
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] after instantiation " + beanName);
return true;
}
@Override
public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
System.out.println("[TestInstantiationAwareBeanPostProcessor] postProcessPropertyValues " + beanName);
return pvs;
}
}
5. SmartInstantiationAwareBeanPostProcessor
- org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor
该扩展接口有3个触发点方法：
-
predictBeanType：该触发点发生在postProcessBeforeInstantiation之前(在图上并没有标明，因为一般不太需要扩展这个点)，这个方法用于预测Bean的类型，返回第一个预测成功的Class类型，如果不能预测返回null；当你调用BeanFactory.getType(name)时当通过bean的名字无法得到bean类型信息时就调用该回调方法来决定类型信息。 -
determineCandidateConstructors：该触发点发生在postProcessBeforeInstantiation之后，用于确定该bean的构造函数之用，返回的是该bean的所有构造函数列表。用户可以扩展这个点，来自定义选择相应的构造器来实例化这个bean。 -
getEarlyBeanReference：该触发点发生在postProcessAfterInstantiation之后，当有循环依赖的场景，当bean实例化好之后，为了防止有循环依赖，会提前暴露回调方法，用于bean实例化的后置处理。这个方法就是在提前暴露的回调方法中触发。
扩展方式为：
public class TestSmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
@Override
public Class predictBeanType(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] predictBeanType " + beanName);
return beanClass;
}
@Override
public Constructor[] determineCandidateConstructors(Class beanClass, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] determineCandidateConstructors " + beanName);
return null;
}
@Override
public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
System.out.println("[TestSmartInstantiationAwareBeanPostProcessor] getEarlyBeanReference " + beanName);
return bean;
}
}
6. BeanFactoryAware
- org.springframework.beans.factory.BeanFactoryAware
这个类只有一个触发点，发生在bean的实例化之后，注入属性之前，也就是Setter之前。这个类的扩展点方法为setBeanFactory，可以拿到BeanFactory这个属性。
使用场景为，你可以在bean实例化之后，但还未初始化之前，拿到 BeanFactory，在这个时候，可以对每个bean作特殊化的定制。也或者可以把BeanFactory拿到进行缓存，日后使用。
扩展方式为：
public class TestBeanFactoryAware implements BeanFactoryAware {
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("[TestBeanFactoryAware] " + beanFactory.getBean(TestBeanFactoryAware.class).getClass().getSimpleName());
}
}
7. ApplicationContextAwareProcessor
- org.springframework.context.support.ApplicationContextAwareProcessor
该类本身并没有扩展点，但是该类内部却有6个扩展点可供实现 ，这些类触发的时机在bean实例化之后，初始化之前可以看到，该类用于执行各种驱动接口，在bean实例化之后，属性填充之后，通过执行以上红框标出的扩展接口，来获取对应容器的变量。所以这里应该来说是有6个扩展点，这里就放一起来说了
-
EnvironmentAware：用于获取EnviromentAware的一个扩展类，这个变量非常有用， 可以获得系统内的所有参数。当然个人认为这个Aware没必要去扩展，因为spring内部都可以通过注入的方式来直接获得。 -
EmbeddedValueResolverAware：用于获取StringValueResolver的一个扩展类， StringValueResolver用于获取基于String类型的properties的变量，一般我们都用@Value的方式去获取，如果实现了这个Aware接口，把StringValueResolver缓存起来，通过这个类去获取String类型的变量，效果是一样的。 -
ResourceLoaderAware：用于获取ResourceLoader的一个扩展类，ResourceLoader可以用于获取classpath内所有的资源对象，可以扩展此类来拿到ResourceLoader对象。 -
ApplicationEventPublisherAware：用于获取ApplicationEventPublisher的一个扩展类，ApplicationEventPublisher可以用来发布事件，结合ApplicationListener来共同使用，下文在介绍ApplicationListener时会详细提到。这个对象也可以通过spring注入的方式来获得。 -
MessageSourceAware：用于获取MessageSource的一个扩展类，MessageSource主要用来做国际化。 -
ApplicationContextAware：用来获取ApplicationContext的一个扩展类，ApplicationContext应该是很多人非常熟悉的一个类了，就是spring上下文管理器，可以手动的获取任何在spring上下文注册的bean，我们经常扩展这个接口来缓存spring上下文，包装成静态方法。同时ApplicationContext也实现了BeanFactory，MessageSource，ApplicationEventPublisher等接口，也可以用来做相关接口的事情。
8. BeanNameAware
- org.springframework.beans.factory.BeanNameAware
可以看到，这个类也是Aware扩展的一种，触发点在bean的初始化之前，也就是postProcessBeforeInitialization之前，这个类的触发点方法只有一个：setBeanName
使用场景为：用户可以扩展这个点，在初始化bean之前拿到spring容器中注册的的beanName，来自行修改这个beanName的值。
扩展方式为：
public class NormalBeanA implements BeanNameAware{
public NormalBeanA() {
System.out.println("NormalBean constructor");
}
@Override
public void setBeanName(String name) {
System.out.println("[BeanNameAware] " + name);
}
}
9. EnvironmentAware
- org.springframework.context.EnvironmentAware
初始化系统环境参数上下文对象
@Configuration
public class EnvironmentContext implements EnvironmentAware, InitializingBean {
/**
* 服务名
*/
public static String serverName;
/**
* 服务端口
*/
public static String serverPort;
/**
* 服务IP地址
*/
public static String serverIpAddress;
/**
* 服务环境DEV FAT UAT PRO等
*/
public static String springActiveProfile;
/**
* 系统环境配置
*/
public static Environment environment;
@Override
public void setEnvironment(Environment environment) {
EnvironmentContext.environment = environment;
}
@Override
public void afterPropertiesSet() throws Exception {
serverPort = environment.getProperty("server.port");
serverName = environment.getProperty("spring.application.name");
serverIpAddress = environment.getProperty("spring.cloud.client.ip-address");
springActiveProfile = environment.getProperty("spring.active.profile");
}
/**
* 获取配置文件中key对应的value
*/
public static String getProperty(String key){
return environment.getProperty(key);
}
}
10. ApplicationContextAware
- org.springframework.context.ApplicationContextAware
@Configuration
public class ApplicationContextWrapper implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
ApplicationContextWrapper.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() {
return applicationContext;
}
public static T getBean(Class clazz) {
return applicationContext.getBean(clazz);
}
public static T getBean(String name) {
@SuppressWarnings("unchecked")
T t = (T) applicationContext.getBean(name);
return t;
}
}
11. @PostConstruct
- javax.annotation.PostConstruct
这个并不算一个扩展点，其实就是一个标注。其作用是在bean的初始化阶段，如果对一个方法标注了@PostConstruct，会先调用这个方法。这里重点是要关注下这个标准的触发点，这个触发点是在postProcessBeforeInitialization之后，InitializingBean.afterPropertiesSet之前。
使用场景：用户可以对某一方法进行标注，来进行初始化某一个属性
扩展方式为：
public class NormalBeanA {
public NormalBeanA() {
System.out.println("NormalBean constructor");
}
@PostConstruct
public void init(){
System.out.println("[PostConstruct] NormalBeanA");
}
}
12. InitializingBean
- org.springframework.beans.factory.InitializingBean
这个类，顾名思义，也是用来初始化bean的。InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是继承该接口的类，在初始化bean的时候都会执行该方法。这个扩展点的触发时机在postProcessAfterInitialization之前。
使用场景：用户实现此接口，来进行系统启动的时候一些业务指标的初始化工作。
扩展方式为：
public class NormalBeanA implements InitializingBean{
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("[InitializingBean] NormalBeanA");
}
}
13. FactoryBean
- org.springframework.beans.factory.FactoryBean
一般情况下，Spring通过反射机制利用bean的class属性指定支线类去实例化bean，在某些情况下，实例化Bean过程比较复杂，如果按照传统的方式，则需要在bean中提供大量的配置信息。配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个简单的方案。Spring为此提供了一个org.springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化Bean的逻辑。FactoryBean接口对于Spring框架来说占用重要的地位，Spring自身就提供了70多个FactoryBean的实现。它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。从Spring3.0开始，FactoryBean开始支持泛型，即接口声明改为FactoryBean的形式
使用场景：用户可以扩展这个类，来为要实例化的bean作一个代理，比如为该对象的所有的方法作一个拦截，在调用前后输出一行log，模仿ProxyFactoryBean的功能。
扩展方式为：
public class TestFactoryBean implements FactoryBean {
@Override
public TestFactoryBean.TestFactoryInnerBean getObject() throws Exception {
System.out.println("[FactoryBean] getObject");
return new TestFactoryBean.TestFactoryInnerBean();
}
@Override
public Class getObjectType() {
return TestFactoryBean.TestFactoryInnerBean.class;
}
@Override
public boolean isSingleton() {
return true;
}
public static class TestFactoryInnerBean{
}
}
14. SmartInitializingSingleton
- org.springframework.beans.factory.SmartInitializingSingleton
这个接口中只有一个方法afterSingletonsInstantiated，其作用是是 在spring容器管理的所有单例对象（非懒加载对象）初始化完成之后调用的回调接口。其触发时机为postProcessAfterInitialization之后。
使用场景：用户可以扩展此接口在对所有单例对象初始化完毕后，做一些后置的业务处理。
扩展方式为：
public class TestSmartInitializingSingleton implements SmartInitializingSingleton {
@Override
public void afterSingletonsInstantiated() {
System.out.println("[TestSmartInitializingSingleton]");
}
}
15. CommandLineRunner / ApplicationRunner
- org.springframework.boot.CommandLineRunner / org.springframework.boot.ApplicationRunner
这个接口也只有一个方法：run(String… args)，触发时机为整个项目启动完毕后，自动执行。如果有多个CommandLineRunner，可以利用@Order来进行排序。
使用场景：用户扩展此接口，进行启动项目之后一些业务的预处理。
扩展方式为：
//CommandLineRunner
public class TestCommandLineRunner implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
System.out.println("[TestCommandLineRunner]");
}
}
//ApplicationRunner
public class AnnotationConsumerProcessor implements ApplicationRunner {
@Override
public void run(ApplicationArguments args) throws Exception {
log.info("start scan annotation @KtKafkaListener class.");
}
}
16. DisposableBean
- org.springframework.beans.factory.DisposableBean
这个扩展点也只有一个方法：destroy()，其触发时机为当此对象销毁时，会自动执行这个方法。比如说运行applicationContext.registerShutdownHook时，就会触发这个方法。
扩展方式为：
public class NormalBeanA implements DisposableBean {
@Override
public void destroy() throws Exception {
System.out.println("[DisposableBean] NormalBeanA");
}
}
17. ApplicationListener
- org.springframework.context.ApplicationListener
准确的说，这个应该不算spring&springboot当中的一个扩展点，ApplicationListener可以监听某个事件的event，触发时机可以穿插在业务方法执行过程中，用户可以自定义某个业务事件。但是spring内部也有一些内置事件，这种事件，可以穿插在启动调用中。我们也可以利用这个特性，来自己做一些内置事件的监听器来达到和前面一些触发点大致相同的事情。
接下来罗列下spring主要的内置事件：
-
ContextRefreshedEvent
ApplicationContext 被初始化或刷新时，该事件被发布。这也可以在ConfigurableApplicationContext接口中使用 refresh()方法来发生。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用 -
ContextStartedEvent
当使用 ConfigurableApplicationContext （ApplicationContext子接口）接口中的 start() 方法启动 ApplicationContext时，该事件被发布。你可以调查你的数据库，或者你可以在接受到这个事件后重启任何停止的应用程序 -
ContextStoppedEvent
当使用 ConfigurableApplicationContext接口中的 stop()停止ApplicationContext 时，发布这个事件。你可以在接受到这个事件后做必要的清理的工作 -
ContextClosedEvent
当使用 ConfigurableApplicationContext接口中的 close()方法关闭 ApplicationContext 时，该事件被发布。一个已关闭的上下文到达生命周期末端；它不能被刷新或重启 -
RequestHandledEvent
这是一个 web-specific 事件，告诉所有 bean HTTP 请求已经被服务。只能应用于使用DispatcherServlet的Web应用。在使用Spring作为前端的MVC控制器时，当Spring处理用户请求结束后，系统会自动触发该事件
自定义注解扫描
示例：kt-kafka-spring-boot-starter
自定义KtKafkaListener注解
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface KtKafkaListener {
/**
* 消费者名称
*/
String consumerName() default "";
/**
* 消费者分组ID
*/
String groupId() default "";
/**
* 订阅主题
*/
String[] topics();
}
扫描注解获取注解类对象和注解对象，同时拿到注解对象参数
@Slf4j
@Configuration
public class AnnotationConsumerProcessor implements ApplicationRunner, ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public void run(ApplicationArguments args) throws Exception {
log.info("start scan annotation @KtKafkaListener class.");
Class annotationClass = KtKafkaListener.class;
Map beanWhithAnnotation = applicationContext.getBeansWithAnnotation(annotationClass);
Set> entitySet = beanWhithAnnotation.entrySet();
for (Map.Entry entry :entitySet){
Class clazz = (Class)entry.getValue().getClass();
KtKafkaConsumer ktKafkaConsumer = applicationContext.getBean(clazz);
KtKafkaListener ktKafkaListener = AnnotationUtils.findAnnotation(clazz, KtKafkaListener.class);
//启动消费者
KafkaConsumerConfig kafkaConsumerConfig = new KafkaConsumerConfig();
kafkaConsumerConfig.setTopics(Arrays.asList(ktKafkaListener.topics()));
kafkaConsumerConfig.setGroupId(ktKafkaListener.groupId());
kafkaConsumerConfig.setConsumerName(StringUtils.hasText(ktKafkaListener.consumerName()) ? ktKafkaListener.consumerName(): String.join(",", ktKafkaListener.topics()));
kafkaConsumerConfig.setKtKafkaAutoProperties(applicationContext.getBean(KtKafkaAutoProperties.class));
ktKafkaConsumer.start(kafkaConsumerConfig);
}
}
}