强烈建议阅读本文之前，先看 spring boot 2源码系列（一）- 系统初始化器ApplicationContextInitializer。监听器的源码跟初始化器的源码有很多相似之处，例如：加载、初始化监听器，监听器委派，监听器排序。

spring boot监听器的使用

spring boot的监听器有多种配置方式。

第一种：使用spring.factories配置

1、新建Alistener实现ApplicationListener接口

// 监听ApplicationStartedEvent事件
@Order(1)
public class Alistener implements ApplicationListener<ApplicationStartedEvent> {@Overridepublic void onApplicationEvent(ApplicationStartedEvent event) {System.out.println("####Alistener监听到ApplicationStartedEvent");}
}

2、在spring.factories中添加

org.springframework.context.ApplicationListener=com.example.springbootdemo.listener.Alistener

第二种：硬编码方式

1、新建Blistener实现ApplicationListener接口

// 监听ApplicationStartedEvent事件
@Order(2)
public class Blistener implements ApplicationListener<ApplicationStartedEvent> {@Overridepublic void onApplicationEvent(ApplicationStartedEvent event) {System.out.println("####Blistener监听到ApplicationStartedEvent");}
}

2、修改启动类，通过代码添加Blistener

@SpringBootApplication
public class SpringBootDemoApplication {public static void main(String[] args) {SpringApplication springApplication = new SpringApplication(SpringBootDemoApplication.class);// 添加监听器springApplication.addListeners(new Blistener());springApplication.run(args);}
}

第三种：在application.properties配置context.listener.classes

1、新建Clistener实现ApplicationListener接口

// 监听ApplicationStartedEvent事件
@Order(3)
public class Clistener implements ApplicationListener<ApplicationStartedEvent> {@Overridepublic void onApplicationEvent(ApplicationStartedEvent event) {System.out.println("####Clistener监听到ApplicationStartedEvent");}
}

2、在application.properties中配置

context.listener.classes=com.example.springbootdemo.listener.Clistener

第四种：实现GenericApplicationListener接口

1、新建Dlistener实现GenericApplicationListener接口

/*** GenericApplicationListener是标准ApplicationListener接口的扩展变体，* 公开了其他元数据，例如受支持的事件和源类型。* 从Spring Framework 4.2开始，此接口取代了基于类的SmartApplicationListener，并全面处理了通用事件类型。*/
@Order(4)
public class Dlistener implements GenericApplicationListener {// 此监听器支持的事件类型@Overridepublic boolean supportsEventType(ResolvableType eventType) {// 监听ApplicationStartingEvent、ApplicationStartedEvent事件return eventType.isAssignableFrom(ApplicationStartingEvent.class)|| eventType.isAssignableFrom(ApplicationStartedEvent.class);}@Overridepublic void onApplicationEvent(ApplicationEvent event) {System.out.println("####Dlistener监听到"+event.getClass().getSimpleName());}}

2、在spring.factories中添加配置（注意：实现类前后以及,\之间不要有空格）。

org.springframework.context.ApplicationListener=com.example.springbootdemo.listener.Alistener,\
com.example.springbootdemo.listener.Dlistener

启动工程，控制台打印

####Dlistener监听到ApplicationStartingEvent
####Clistener监听到ApplicationStartedEvent
####Alistener监听到ApplicationStartedEvent
####Blistener监听到ApplicationStartedEvent
####Dlistener监听到ApplicationStartedEvent

源码讲解—初始化阶段

spring boot监听器初始化阶段跟系统初始化器很相似，都是在创建SpringApplication实例的时候将在spring.factories配置的监听器设置给this.listeners属性。

主要源码如下：

// 源码位置 org.springframework.boot.SpringApplication#SpringApplication(org.springframework.core.io.ResourceLoader, java.lang.Class<?>...)
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {// 将spring.factories配置的监听器赋值给this.listenerssetListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
}

源码讲解—运行阶段

1、进入SpringApplication#run(java.lang.String...)源码，探究监听器的运行过程

//  仅列出主要代码
org.springframework.boot.SpringApplication#run(java.lang.String...)
// 此处打断点。获取SpringApplicationRunListeners
SpringApplicationRunListeners listeners = getRunListeners(args);
// spring application 开始启动阶段
listeners.starting();
// spring application 启动完成阶段。在这里打个断点，通过启动完成阶段的代码分析spring boot监听器源码
listeners.started(context);
// spring application 运行阶段
listeners.running(context);

// SpringApplicationRunListeners讲解
class SpringApplicationRunListeners {/*** SpringApplicationRunListeners 是对 SpringApplicationRunListener 的封装。* 包含多个SpringApplicationRunListener，以便能批量执行SpringApplicationRunListener的同名方法。* 利用List<SpringApplicationRunListener> listeners 可以方便我们拓展，自定义运行监听器。*/private final List<SpringApplicationRunListener> listeners;// 省略部分代码/*** 循环listeners并调用SpringApplicationRunListener的started同名方法。* this.listeners默认只包含一个SpringApplicationRunListener实现类EventPublishingRunListener*/void started(ConfigurableApplicationContext context) {for (SpringApplicationRunListener listener : this.listeners) {listener.started(context);}}void environmentPrepared(ConfigurableEnvironment environment) {for (SpringApplicationRunListener listener : this.listeners) {listener.environmentPrepared(environment);}}// 省略部分代码}

SpringApplicationRunListener接口定义如下：

/*** SpringApplicationRunListener是SpringApplication运行阶段的侦听器。*/
public interface SpringApplicationRunListener {/*** 在首次启动run方法时立即调用。 可用于非常早的初始化。*/default void starting() {}/*** 在环境准备好、ApplicationContext创建之前调用。*/default void environmentPrepared(ConfigurableEnvironment environment) {}/*** ApplicationContext已创建并准备好，但是在加载源之前。*/default void contextPrepared(ConfigurableApplicationContext context) {}/*** 应用程序上下文已加载，但尚未刷新。*/default void contextLoaded(ConfigurableApplicationContext context) {}/*** 上下文已刷新，应用程序已启动，CommandLineRunners和ApplicationRunner尚未被调用。*/default void started(ConfigurableApplicationContext context) {}/*** 在run方法完成之前，当刷新应用程序上下文并且已调用所有CommandLineRunners和ApplicationRunners*/default void running(ConfigurableApplicationContext context) {}/*** 运行应用程序时发生故障时调用*/default void failed(ConfigurableApplicationContext context, Throwable exception) {}}

2、进入 listeners.started();源码中

2.1 首先进入到SpringApplicationRunListeners#started 方法

// 源码位置 org.springframework.boot.SpringApplicationRunListeners#started
void started(ConfigurableApplicationContext context) {for (SpringApplicationRunListener listener : this.listeners) {// 调用SpringApplicationRunListener实现类的同名方法listener.started(context);}
}

2.2 listener.started(context); 分析

listener是EventPublishingRunListener。

/*** EventPublishingRunListener是SpringApplicationRunListener接口的默认实现，用于发布事件。* 仅展示部分代码*/
public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {// 默认事件广播器，用于广播事件private final SimpleApplicationEventMulticaster initialMulticaster;@Overridepublic int getOrder() {return 0;}// 省略部分代码// 使用SimpleApplicationEventMulticaster#multicastEvent()广播ApplicationStartedEvent事件@Overridepublic void started(ConfigurableApplicationContext context) {context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));}@Overridepublic void environmentPrepared(ConfigurableEnvironment environment) {this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(this.application, this.args, environment));}}

3、context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));   源码

// 源码位置 org.springframework.context.support.AbstractApplicationContext.publishEvent(java.lang.Object, org.springframework.core.ResolvableType)
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {/*** 主要代码：* getApplicationEventMulticaster()返回的依旧是SimpleApplicationEventMulticaster实例* multicastEvent(applicationEvent, eventType);广播事件*/getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
}

4、SimpleApplicationEventMulticaster#multicastEvent()的作用是广播事件。

// 源码位置 org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent, org.springframework.core.ResolvableType)
// 将的应用程序事件广播给对此事件感兴趣的侦听器
@Override
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {// 重点代码1：根据event创建ResolvableTypeResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));Executor executor = getTaskExecutor();/*** 重点代码2：getApplicationListeners(event, type)* 返回监听了当前event事件的监听器，不监听当前事件的监听器被排除，不会返回* event：要广播的事件* eventType：事件类型*/for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {// 若设置了线程池，使用线程调用监听器if (executor != null) {executor.execute(() -> invokeListener(listener, event));}else {// 重点代码3：没设置线程池，使用当前线程调用监听器。默认没设置线程池invokeListener(listener, event);}}
}

4.1 ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));   通过event创建ResolvableType。

4.2 getApplicationListeners(event, type) 返回监听了当前event事件的监听器，不监听当前事件的监听器被排除，不会返回。这是个重点的方法。

进入getApplicationListeners(event, type)中debug，会进入到 AbstractApplicationEventMulticaster#supportsEvent() 中

// 源码位置 org.springframework.context.event.AbstractApplicationEventMulticaster#supportsEvent(org.springframework.context.ApplicationListener<?>, org.springframework.core.ResolvableType, java.lang.Class<?>)
protected boolean supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, @Nullable Class<?> sourceType) {// 如果监听器是GenericApplicationListener的实现类则返回监听器本身，否则创建GenericApplicationListenerAdapterGenericApplicationListener smartListener = (listener instanceof GenericApplicationListener ?(GenericApplicationListener) listener : new GenericApplicationListenerAdapter(listener));/*** 通过supportsEventType和supportsSourceType判断监听器是否监听了当前事件* supportsSourceType默认返回true*/return (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType));
}

我们自己创建的Dlistener实现GenericApplicationListener接口，并重写了supportsEventType()方法，监听ApplicationStartingEvent、ApplicationStartedEvent事件。

Alistener、Blistener没实现GenericApplicationListener。与系统初始化器一样，Clistener由DelegatingApplicationListener调用，DelegatingApplicationListener也没实现GenericApplicationListener。因此会创建GenericApplicationListenerAdapter实例，再执行  (smartListener.supportsEventType(eventType) && smartListener.supportsSourceType(sourceType)); 判断

4.2.1 new GenericApplicationListenerAdapter(listener)); 源码分析

// 源码位置 org.springframework.context.event.GenericApplicationListenerAdapter#GenericApplicationListenerAdapter
public GenericApplicationListenerAdapter(ApplicationListener<?> delegate) {// 将监听器赋值给delegate属性this.delegate = (ApplicationListener<ApplicationEvent>) delegate;/*** 获取监听器监听的事件类型。* 例如：this.delegate = Alistener*      this.declaredEventType就等于ApplicationStartedEvent*/this.declaredEventType = resolveDeclaredEventType(this.delegate);
}

4.2.2 GenericApplicationListenerAdapter#supportsEventType()源码分析

    // 源码位置 org.springframework.context.event.GenericApplicationListenerAdapter.supportsEventType(org.springframework.core.ResolvableType)@Override@SuppressWarnings("unchecked")public boolean supportsEventType(ResolvableType eventType) {if (this.delegate instanceof SmartApplicationListener) {Class<? extends ApplicationEvent> eventClass = (Class<? extends ApplicationEvent>) eventType.resolve();return (eventClass != null && ((SmartApplicationListener) this.delegate).supportsEventType(eventClass));}else {/*** 主要代码是 this.declaredEventType.isAssignableFrom(eventType))* 当监听器是Alistener、Blistener时:*    this.declaredEventType是ApplicationStartedEvent，eventType也是ApplicationStartedEvent，返回true* 当监听器是DelegatingApplicationListener时：*    this.declaredEventType是ApplicationEvent，eventType是ApplicationStartedEvent，*    ApplicationEvent是ApplicationStartedEvent的父类，this.declaredEventType.isAssignableFrom(eventType)也返回true*/return (this.declaredEventType == null || this.declaredEventType.isAssignableFrom(eventType));}}

在本项目中 getApplicationListeners(event, type) 返回的监听器会包含Alistener、Blistener、Dlistener、DelegatingApplicationListener。DelegatingApplicationListener会调用Clistener。

4.3 监听了event事件的监听器通过 getApplicationListeners(event, type) 返回了，接下来就是调用监听器的onApplicationEvent(event)方法。

 invokeListener(listener, event); 源码

// 源码位置 org.springframework.context.event.SimpleApplicationEventMulticaster#invokeListener
protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) {// 主要代码，调用监听器doInvokeListener(listener, event);
}

4.3.1 doInvokeListener(listener, event); 源码

// 源码位置 org.springframework.context.event.SimpleApplicationEventMulticaster#doInvokeListener
private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {// 主要代码，执行监听器的onApplicationEvent(E event);方法listener.onApplicationEvent(event);
}