ps:真正适合阅读源码的新手来看的SpringBoot源码讲解,如果你真的想读懂SpringBoot源码,可以按照以下推荐的方式来阅读文章

  1. 打开ide,打开SpringBoot源码,跟着文章一起写注释,写自己的注释
  2. 不要过于纠结没讲到的地方,毕竟SpringBoot源码那么多,想全讲完是不可能的,只要跟着文章认真阅读,SpringBoot是如何运行的一定可以有一个较为深刻的理解
  3. 文章适合通篇阅读,不适合跳读,跳跃性的阅读很容易错过重要的东西
  4. 同样的如果之前的文章没有读过,还是最好先去看之前的文章
  5. 阅读源码必然少不了大段大段的源码,一定要耐心,不要翻翻了事,往往是那些最长的方法中才是真正需要学习的
  6. 如果断更了请用点赞、收藏、评论的方式激励我

系列文章链接:
《SpringBoot源码初学者(一):SpringBoot功能扩展接口的使用与源码分析》

文章目录

    • 一、监听器模式
      • 1、监听器模式小demo!天气监听器
      • 2、黑默丁格大讲堂,监听器模式机制讲解
    • 二、SpringBoot事件监听器的实现
      • 1、ApplicationListener接口
      • 2、ApplicationEventMulticaster接口
      • 3、SpringBoot的7大事件
        • (1)事件发生顺序
      • 4、事件监听器的源码分析
        • (1)监听器注册流程
        • (2)监听器触发流程
      • 5、自定义SpringBoot监听器
        • (1)通过spring.factories注入
        • (2)SpringApplication手动注入
        • (3)SpringBoot的配置文件中注册
        • (4)多事件监听,实现SmartApplicationListener接口

一、监听器模式

  在学习的路上遵循一些原则,可以更高效的学习,其中就有这么一条“循循渐进”,在深入SpringBoot之前先要了解清楚什么是监听器,监听器是如何实现的,这些都是对付大魔王的神兵利器,和RPG游戏一样打boss之前先要打小怪提升等级,爆出“屠龙宝刀”。
  伊泽瑞尔作为瓦罗拉大陆上组名的探险家在探险的路上,却总是受到天气的影响无法冒险,所以他拜托我帮他写一个软件,辅助他关注天气。
SpringBoot源码初学者(二):SpringBoot事件监听器-编程之家

1、监听器模式小demo!天气监听器

步骤1:创建抽象类WeatherEvent(天气状态)

public abstract class weatherEvent{//获取天气状态public abstract String getWeather();
}

步骤2:实现下雪和下雨事件
下雪事件

public class SnowEvent extends WeatherEvent{@Overidepublic String getWeather(){return "下雪了";}
}

下雨事件

public class RainEvent extends WeatherEvent{@Overidepublic String getWeather(){return "下雨了";}
}

步骤3:创建天气监听器接口

public interface WeatherListener{void onWeatherEvent(WeatherEvent event);
}

步骤4:实现监听器,分别处理下雪和下雨的天气
下雪的时候需要穿上大棉袄,带上手套御寒

public class SnowListener implements WeatherListener{@Overridepublic void onWeatherEvent(WeatherEvent event){if(event instanceof SnowEvent){event.getWeather();System.out.println("今天下雪!请增加衣物,做好御寒保护!");}}
}

下雨的时候需要带雨伞,穿雨鞋

public class RainListener implements WeatherListener{@Overridepublic void onWeatherEvent(WeatherEvent event){if(event instanceof RainEvent){event.getWeather();System.out.println("今天下雨!出门请带好雨伞");}}
}

步骤5:创建广播器接口

public interface EventMulticaster{//广播事件void multicastEvent(WeatherEvent event);//添加监听器 void addListener(WeatherListener weaterListener);//删除监听器 void removeListener(WeatherListener weaterListener);
}

步骤6:抽象类实现广播接口

public abstract class AbstractEventMulticaster implements EventMulticaster{//存放监听器的集合,所有需要监听的事件都存在这里private List<WeaterListener> listenerList = new ArrayList<>();@Overridepublic void multicastEvent(WeatherEvent event){//采用模板方法,子类可以实现的doStart和doEnd,在调用监听器之前和之后分别作出扩展//SpringBoot中有着大量相似的操作//SpringBoot中的前置处理器和后置处理器,就是这样实现的doStart();//循环所有调用所有监听器的onWeatherEvent方法listenerList.forEach(i -> i.onWeatherEvent(event));doEnd();}@Overridepublic void addListener(WeatherListener weaterListener){listenerList.add(weaterListener);}@Overridepublic void removeListener(WeatherListener weaterListener){listenerList.remove(weaterListener);}abstract void doStart();abstract void doEnd();
}

步骤7:实现天气事件的广播

public class WeatherEventMulticaster extends AbstractEventMulticaster{@Overridevoid doStart(){System.out.println("开始广播天气预报!")}@Overridevoid doEnd(){System.out.println("广播结束!Over!")}
}

步骤8:测试并触发广播

public class Test{public static void main(String[] args){//创建广播器WeatherEventMulticaster eventMulticaster = new WeatherEventMulticaster();//创建监听器RainListener rainListener = new RainListener();SnowListener snowListener = new SnowListener();//添加监听器eventMulticaster.addListener(rainListener);eventMulticaster.addListener(snowListener);//触发下雨事件eventMulticaster.multicastEvent(new RainEvent());//触发下雪事件eventMulticaster.multicastEvent(new SnowEvent());}
}

2、黑默丁格大讲堂,监听器模式机制讲解

  伊泽瑞尔的探险活动终于不再受到天气的骚扰了,可是他并不明白小小的玩意为什么如此神奇,多次询问过我,可是无赖我语言贫乏,无法将如此复杂的思想表达清楚,只要求助老友黑默丁格,帮忙说明。

ps:工作中不仅要能实现功能,还要注重表达能力,在面试的时候能把思想表达的清楚可以拿到更高的薪资,在和测试交流的时候可以帮助测试理解实现原理,测试出隐藏在深处的bug,当然作为天才程序员的大伙是没有bug的,肯定是环境问题或者操作不当导致的。

黑默丁格拿到代码,简单看了两眼就分析出了各个模块的作用:

  • 事件:步骤1和步骤2,通过对天气进行抽象,并实现下雨和下雪的天气状态
  • 监听器:步骤3和步骤4,规范对天气监听的模式,并且规范对应天气下,需要如何处理
  • 广播器:步骤5、步骤6和步骤7,当有事件发生的时候,广播器发出信号,告知所有的监听器,监听器根据事件作出相应的处理。触发下雨事件的时候,下雨监听器收到消息,它抬头一看乌云密布电闪雷鸣,微微一愣,大喊一句:“打雷下雨收衣服啊!!”,广播器继续通知下一个监听器下雪监听器,下雪监听器看看天空,摆摆手,说:“这事与我无关去找别人”
  • 触发机制:步骤8,demo中采用的硬编码的形式触发的,在实际运用中,可能是湿度仪检测到湿度暴涨开始下雨了,触发广播。

  在23种设计模式中是没有监听器模式的,监听器模式是观察者模式的一种实现,这两个名字都容易让人产生一些误导,在“监听”、“观察”很容易让人觉得是监听器发现了事件,然后行动。实际上是广播器把事件推送给所有的监听器,每个监听器都对事件做出判断和处理。

二、SpringBoot事件监听器的实现

1、ApplicationListener接口

  ApplicationListener是Spring事件机制的一部分,与抽象类ApplicationEvent类配合来完成ApplicationContext的事件机制,实现ApplicationListener接口的类,会在SpringBoot加入到广播器中,当ApplicationContext触发了一个事件,就用广播器通知所有实现ApplicationListener接口的类。

//这个注解表示,当前类只有一个方法
@FunctionalInterface
//传入的泛型,说明这个监听器,需要监听的事件类型
//继承的EventListener类,是个空类,主要是声明继承它的类是个事件监听器,面向对象编程的思想体现
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {/*** Handle an application event.* @param event the event to respond to*/void onApplicationEvent(E event);}

  不难发现ApplicationListener的接口与我们实现的天气监听器的步骤3几乎一样,如果理解了小demo这个类的作用肯定已经了解的明明白白。

2、ApplicationEventMulticaster接口

  ApplicationEventMulticaster是Spring事件机制的广播器接口,所有的广播器都需要实现此接口,主要作用是管理所有的监听器,以及推送事件给监听器。

public interface ApplicationEventMulticaster {//添加一个监听器void addApplicationListener(ApplicationListener<?> listener);//根据beanName添加一个监听器void addApplicationListenerBean(String listenerBeanName);//移除一个监听器void removeApplicationListener(ApplicationListener<?> listener);//根据beanName移除一个监听器void removeApplicationListenerBean(String listenerBeanName);//移除所有监听器void removeAllListeners();//广播事件的方法void multicastEvent(ApplicationEvent event);void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}

3、SpringBoot的7大事件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cu6pwkNo-1585491460589)(en-resource://database/2523:1)]

  • EventObject:事件顶级对象,所有事件对象的根对象
  • ApplicationEvent:应用事件
  • SpringApplicationEvent:Spring自己的事件,Spring框架自身的事件都会实现这个接口
  • ApplicationStartingEvent:启动事件,框架刚刚启动就会发出这个事件
  • ApplicationEnvironmentPreparedEvent:环境在变完成,系统属性和用户指定已经加载完成
  • ApplicationContextInitializedEvent:已经创建好了上下文,并且还没有加载任何bean之前发出这个事件
  • ApplicationPreparedEvent:在Bean定义开始加载之后,尚未完全加载之前,刷新上下文之前触发
  • ApplicationStartedEvent:bean已经创建完成,上下文已经刷新完成,但是ApplicationRunner和CommandLineRunne两个扩展接口并未执行
  • ApplicationReadyEvent:ApplicationRunner和CommandLineRunne两个扩展接口执行完成之后触发
  • ApplicationFailedEvent:在启动发生异常时触发

(1)事件发生顺序

启动 —》ApplicationStartingEvent —》ApplicationEnvironmentPreparedEvent —》ApplicationContextInitializedEvent —》 ApplicationPreparedEvent —》ApplicationStartedEvent —》 ApplicationReadyEvent —》启动完毕

中间发生异常 —》ApplicationFailedEvent —》启动失败

4、事件监听器的源码分析

(1)监听器注册流程

如果看过之前的文章
《 SpringBoot源码初学者(一):SpringBoot功能扩展接口的使用与源码分析》:https://blog.csdn.net/qq_34886352/article/details/104949485
这里就很容易理解,不想完整的阅读可以只看一下工厂加载机制源码解析的部分
与ApplicationContextInitializer接口完全一样的流程进行注册的,只是把ApplicationContextInitializer接口换成了ApplicationListener接口

我们还是从最开始的main方法一步步看。
步骤1:查看SpringBoot启动类

@SpringBootApplication
public class Application {public static void main(String[] args) {//进入run方法的源码SpringApplication.run(Application.class, args);}
}

步骤2:这里可以看到一层简单的调用

public static ConfigurableApplicationContext run(Class<?> primarySource,String... args) {//进入这个同名方法,继续戳run方法return run(new Class<?>[] { primarySource }, args);
}

步骤3:这里就比较有意思了,注意一下注释

public static ConfigurableApplicationContext run(Class<?>[] primarySources,String[] args) {//点这个SpringApplication构造方法return new SpringApplication(primarySources).run(args);
}

步骤4:没有什么用的封装,对构成函数复用

public SpringApplication(Class<?>... primarySources) {//点this,查看构造函数this(null, primarySources);
}

步骤5:这里我们可以看到两个熟悉的名字getSpringFactoriesInstances方法和ApplicationContextInitializer接口

public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {this.resourceLoader = resourceLoader;Assert.notNull(primarySources, "PrimarySources must not be null");this.primarySources = new LinkedHashSet<>(Arrays.asList(primarySources));this.webApplicationType = WebApplicationType.deduceFromClasspath();//这里就是上一篇文章说的ApplicationContextInitializer接口注册setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));//这里就是ApplicationListener注册的位置,可以看出主要区别就是查询的接口类不同//setListeners是找到的对象存到容器中,存到一个list属性中,方便以后使用//这个存放对象的list,对应的是小demo的AbstractEventMulticaster类中list,作用是一样一样的//getSpringFactoriesInstances方法详解参考文章《SpringBoot功能扩展接口的使用与源码分析》setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));this.mainApplicationClass = deduceMainApplicationClass();
}

(2)监听器触发流程

步骤1:查看SpringBoot启动类

@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}
}

步骤2:ConfigurableApplicationContext类

public static ConfigurableApplicationContext run(Class<?> primarySource,String... args) {return run(new Class<?>[] { primarySource }, args);
}

步骤3:这次进入run方法

public static ConfigurableApplicationContext run(Class<?>[] primarySources,String[] args) {//点击run方法return new SpringApplication(primarySources).run(args);
}

步骤4:每次看到这个方法,都感觉它罪孽深重,多少人从它开始看起,踏上阅读源码的不归路
代码较长,这次就不写所有的注释了,具体注释看这里https://blog.csdn.net/qq_34886352/article/details/104949485

	public ConfigurableApplicationContext run(String... args) {StopWatch stopWatch = new StopWatch();stopWatch.start();ConfigurableApplicationContext context = null;Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();configureHeadlessProperty();//获取事件运行器//SpringApplicationRunListeners内部包含一个SpringApplicationRunListener(这里s没有了)的集合//SpringApplicationRunListener有7大事件的执行方法,在对应的地点会被调用,SpringBoot通过这个实现事件的触发//SpringBoot自带一个实现,这个实现分别会执行定义好的7大事件//使用者可以通过实现SpringApplicationRunListener的接口,定义在对应事件所需执行的命令//总体流程还是很简单的,留给大家自己阅读SpringApplicationRunListeners listeners = getRunListeners(args);//监听器的故事从这里开始,我们这次的故事也从这里起航//进入starting方法listeners.starting();try {ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);configureIgnoreBeanInfo(environment);Banner printedBanner = printBanner(environment);context = createApplicationContext();exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,new Class[] { ConfigurableApplicationContext.class }, context);prepareContext(context, environment, listeners, applicationArguments, printedBanner);refreshContext(context);afterRefresh(context, applicationArguments);stopWatch.stop();if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);}listeners.started(context);callRunners(context, applicationArguments);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, listeners);throw new IllegalStateException(ex);}try {listeners.running(context);}catch (Throwable ex) {handleRunFailure(context, ex, exceptionReporters, null);throw new IllegalStateException(ex);}return context;}

步骤5:没有千层套路

public void starting() {//listeners里面存放了所有的SpringApplicationRunListener(事件触发器)for (SpringApplicationRunListener listener : this.listeners) {//循环执行事件触发器的starting方法//点击进入看看SpringBoot自带的事件触发器是如何运行的listener.starting();}
}

步骤6:广播器发送事件

@Overridepublic void starting() {//initialMulticaster是广播器this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));}

步骤7:广播器发送事件

@Overridepublic void starting() {//initialMulticaster是广播器//进入multicastEvent方法this.initialMulticaster.multicastEvent(new ApplicationStartingEvent(this.application, this.args));}

步骤8:广播事件的时候要判断这个事件的类型,判断需不需要在这个时间点执行

@Override
public void multicastEvent(ApplicationEvent event) {//resolveDefaultEventType方法,解析事件的默认类型//进入resolveDefaultEventType方法,步骤9//进入multicastEvent方法,步骤11multicastEvent(event, resolveDefaultEventType(event));
}

步骤9:获取事件类型

private ResolvableType resolveDefaultEventType(ApplicationEvent event) {//获取事件类型//进入forInstance方法,步骤10return ResolvableType.forInstance(event);
}

步骤10:通过接口判断时间类型

public static ResolvableType forInstance(Object instance) {//断路判断,如果instance是个空,就停止SpringBoot的启动,并报错Assert.notNull(instance, "Instance must not be null");//判断有没有实现ResolvableTypeProvider这个接口//ResolvableTypeProvider接口,表明这个类的事件类型可以被解析if (instance instanceof ResolvableTypeProvider) {//强转成ResolvableTypeProvider类型,然后获取事件类型ResolvableType type = ((ResolvableTypeProvider) instance).getResolvableType();if (type != null) {//事件类型不为空,就直接返回return type;}}//返回一个默认类型,传进来的instance是什么类型,就把这个类型包装成ResolvableType,然后返回//返回步骤8return ResolvableType.forClass(instance.getClass());
}

步骤11:开始广播
两个参数:event:需要执行的事件    eventType:事件的类型

@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {//如果事件类型为空,执行resolveDefaultEventType方法(步骤9和步骤10)ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));//获取任务的执行的线程池//如果没有特别指定,返回为null,SpringBoot这里就是空的Executor executor = getTaskExecutor();//getApplicationListeners方法,获取对这个事件感兴趣的监听器//点击进入getApplicationListeners方法,进入步骤12for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {if (executor != null) {//在指定线程上执行触发executor.execute(() -> invokeListener(listener, event));}else {//默认方式执行触发invokeListener(listener, event);}}
}

步骤12:获取对这个事件感兴趣的监听器(缓存获取逻辑)
参数说明:
event:当前发生的事件,这个方法就是找到对这个事件感兴趣的监听器
eventType:事件类型

protected Collection<ApplicationListener<?>> getApplicationListeners(ApplicationEvent event, ResolvableType eventType) {//获取事件发生的源头类,这里就是SpringApplicationObject source = event.getSource();//获取原头类的类型Class<?> sourceType = (source != null ? source.getClass() : null);//获取缓存的keyListenerCacheKey cacheKey = new ListenerCacheKey(eventType, sourceType);//快速执行,从缓存中获取监听器,如果这个方法已经执行了过了,就不要在获取一次了,直接拿到缓存ListenerRetriever retriever = this.retrieverCache.get(cacheKey);if (retriever != null) {//返回对当前事件感兴趣的监听器return retriever.getApplicationListeners();}if (this.beanClassLoader == null ||(ClassUtils.isCacheSafe(event.getClass(), this.beanClassLoader) &&(sourceType == null || ClassUtils.isCacheSafe(sourceType, this.beanClassLoader)))) {//通过key上锁,这是上锁的一个很有效的方式,定义一个属性作为锁的keysynchronized (this.retrievalMutex) {//上锁之后再次检查,有没有其他地方触发了当前事件,把监听器的列表放入了缓存中//写过双层验证的单例模式对这里不会陌生,主要原理是一样的retriever = this.retrieverCache.get(cacheKey);if (retriever != null) {//返回对当前事件感兴趣的监听器return retriever.getApplicationListeners();}retriever = new ListenerRetriever(true);//真正的查找逻辑被封装在这里//SpringBoot这种千层套路,是有规律可循的,这一次是缓存的封装,下一次是实际的调用//我们编程的时候可以学习一下,比如封装缓存的查询,再去数据库,降低耦合度//点retrieveApplicationListeners方法进入 步骤13Collection<ApplicationListener<?>> listeners =retrieveApplicationListeners(eventType, sourceType, retriever);//存入缓存中this.retrieverCache.put(cacheKey, retriever);return listeners;}}else {//不需要加锁的,并且不需要缓存的查询方式//这个方法中有两处调用了retrieveApplicationListeners方法,在方法的内部对有无缓存,做了不同的处理//个人观点:应该把内部的缓存逻辑移到这层中,否则耦合度依旧很高return retrieveApplicationListeners(eventType, sourceType, null);}
}

步骤13:真正获取监听器的逻辑

private Collection<ApplicationListener<?>> retrieveApplicationListeners(ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable ListenerRetriever retriever) {List<ApplicationListener<?>> allListeners = new ArrayList<>();Set<ApplicationListener<?>> listeners;Set<String> listenerBeans;synchronized (this.retrievalMutex) {//获取所有的监听器实例listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);//获取所有监听器的beanNamelistenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);}//对所有的监听器进行逐一的循环for (ApplicationListener<?> listener : listeners) {//判断监听器是否对这个事件感兴趣//点击supportsEvent方法进入  步骤14if (supportsEvent(listener, eventType, sourceType)) {if (retriever != null) {//如果监听器功能开启了缓存,就存到缓存中retriever.applicationListeners.add(listener);}//不管有没有缓存都会存到这里allListeners.add(listener);}}//通过工厂方式,获取监听器,一般情况不会走这里if (!listenerBeans.isEmpty()) {//获取bean工厂BeanFactory beanFactory = getBeanFactory();//循环监听器beanNamefor (String listenerBeanName : listenerBeans) {try {//更具beanName,获取监听器的类型Class<?> listenerType = beanFactory.getType(listenerBeanName);// 判断监听器是否对这个事件感兴趣if (listenerType == null || supportsEvent(listenerType, eventType)) {//获取bean实例,这个方法写作getBean,读作createBean//这是ioc中非常重要的一块逻辑,当获取不到bean的时候,就会创建一个bean对象//具体的我们在后续ioc源码分析的时候讲解ApplicationListener<?> listener =beanFactory.getBean(listenerBeanName, ApplicationListener.class);if (!allListeners.contains(listener) && supportsEvent(listener, eventType, sourceType)) {//也是判断是否有缓存的逻辑if (retriever != null) {//多一个判断是否单例的逻辑if (beanFactory.isSingleton(listenerBeanName)) {retriever.applicationListeners.add(listener);}else {//原形bean这里,想起来以前有个组员说这个叫“多例”,最好还是叫“原型”retriever.applicationListenerBeans.add(listenerBeanName);}}allListeners.add(listener);}}}catch (NoSuchBeanDefinitionException ex) {}}}//进行排序,SpringBoot的常规操作了,根据Order接口或者注解进行排序AnnotationAwareOrderComparator.sort(allListeners);//对缓存进行一次刷新,把以前的结果清空,将这次运行的结果缓存if (retriever != null && retriever.applicationListenerBeans.isEmpty()) {retriever.applicationListeners.clear();retriever.applicationListeners.addAll(allListeners);}//返回获取到的监听器//返回  步骤12return allListeners;
}

步骤14:判断监听器是否对当前事件感兴趣

protected boolean supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {//判断监听器,是否是GenericApplicationListener的子类//starting的事件并不是其子类//GenericApplicationListener使用了装饰器模式//著名的装饰器模式是java中io流(inputStream这些)//GenericApplicationListener中可以解析ApplicationListener接口中的泛型参数,接口如下://“ApplicationListener<E extends ApplicationEvent>”要是还想不起来,回头看一下上面小Demo中的使用,和对这个接口的介绍GenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));//下面就变得简单了,虽然内部的判断很繁杂,总体只做了两件事情//supportsEventType:判断监听器是否支持当前事件//supportsSourceType:监听器是否对这个事件的发起来类感兴趣//返回一个总的bool值,返回  步骤13return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
}

5、自定义SpringBoot监听器

(1)通过spring.factories注入

步骤1:创建监听器,并实现ApplicationListener接口

//我们让这个监听器对ApplicationStartedEvent事件感兴趣
@Order(1)
public class TestListener implements ApplicationListener<ApplicationStartedEvent>{@Ovrridepublic void onApplicationEvent(ApplicationStartedEvent event){System.out.println("hello,  Application start is over");}
}

步骤2:在spring.factories中添加实现类的指引
这里涉及上一讲的内容,还不会的小伙伴们猛戳这里,赶紧补习一下:
https://blog.csdn.net/qq_34886352/article/details/104949485

#com.gyx.test.Listener是刚刚写的监听器的全路径名
org.springframework.context.ApplicationListener=com.gyx.test.TestListener

然后运行程序,就可以发现打印的语句出现了

(2)SpringApplication手动注入

步骤1:创建监听器,并实现ApplicationListener接口,和上面的完全一样
步骤2:修改SpringBoot启动类

@SpringBootApplication
public class Application {public static void main(String[] args) {SpringApplication springApplication = new SpringApplication(Application.class);//添加到初始化配置项中springApplication.addListeners(new TestListener());springApplication.run(args);}
}

(3)SpringBoot的配置文件中注册

步骤1:创建监听器,并实现ApplicationListener接口,和上面的完全一样
步骤2:修改配置文件

context.listener.classes=com.gyx.test.TestListener

看过上一课的小伙伴们,是不是发现了,和之前ApplicationContextInitializer的注册方式完全一样!!!是不是有点感觉了,趁热打铁赶紧吧上一讲再去回顾一下吧

(4)多事件监听,实现SmartApplicationListener接口

这种方法只是实现的接口不一样,注入的方式是一样的,上面的三种注入方式都可以使用
步骤1:创建监听器,并实现SmartApplicationListener接口

@Order(1)
public class TestSmartListener implements SmartApplicationListener{@Ovrridepublic boolean supportsEventType(Class<? extends ApplicationEvent> eventType){//这里是类型判断,判断监听器感兴趣的事件//可以对多个事件感兴趣,这里就配置了两个事件return ApplicationStartedEvent.class.isAssignableFrom(eventType) || ApplicationPreparedEvent.class.isAssignableFrom(eventType);}@Ovrridepublic void onApplicationEvent(ApplicationStartedEvent event){System.out.println("hello,  This is smartApplicationListener");}
}