在前一节中，我们已经隐隐约约瞥到过SpringApplicationRunListener的身影，这一节就来详细读一下它的相关源码并尝试使用。

1 SpringApplicationRunListener是什么

1.1 读注释

/**
 * Listener for the {@link SpringApplication} {@code run} method.
 * {@link SpringApplicationRunListener}s are loaded through the
 * {@link SpringFactoriesLoader} and should declare a public constructor that accepts a
 * {@link SpringApplication} instance and a {@code String[]} of arguments. A new
 * {@link SpringApplicationRunListener} instance will be created for each run.
 */
public interface SpringApplicationRunListener {

翻译过来就是：

• 监听的是SpringApplication的run方法——于是我们可以很容易记住它的名字“SpringApplicationRunListener”，而且知道了SpringApplicationRunListener只会在run方法的执行过程中被调用
• 监听类是通过SpringFactoriesLoader加载的——这点稍后可以找到代码印证一下，应该可以找到注册Listener的方式
• 监听类应当声明一个入参为(SpringApplication, String[])的构造方法
• 每次运行都会新生成一个Listener实例——在使用SpringApplicationRunListener的时候要注意这点

1.2 读接口方法

大概翻看一下SpringApplicationRunListener类，就可以知道，主要是定义了一堆会在不同时机被调用的方法。

1.3 SpringApplicationRunListener的加载方式

SpringApplicationRunListener的获取方式也很简单，从getRunListeners -> getSpringFactoriesInstances容易看出是通过spring.factories配置SpringApplicationRunListener

private SpringApplicationRunListeners getRunListeners(String[] args) {
   Class<?>[] types = new Class<?>[] { SpringApplication.class, String[].class };
   return new SpringApplicationRunListeners(logger,
         getSpringFactoriesInstances(SpringApplicationRunListener.class, types, this, args),
         this.applicationStartup);
}
private <T> Collection<T> getSpringFactoriesInstances(Class<T> type, Class<?>[] parameterTypes, Object... args) {
	 ClassLoader classLoader = getClassLoader();
	 // Use names and ensure unique to protect against duplicates
	 Set<String> names = new LinkedHashSet<>(SpringFactoriesLoader.loadFactoryNames(type, classLoader));
	 List<T> instances = createSpringFactoriesInstances(type, parameterTypes, classLoader, args, names);
	 AnnotationAwareOrderComparator.sort(instances);
	 return instances;
}

单纯看SpringApplicationRunListener的确很简单，也就是以上这些内容。为了能继续深入学习，举一反三，我们debug一下getRunListeners的代码，可以看到SpringBoot在启动时有一个EventPublishingRunListener，接下来以它为入口，看看还能多学到点什么。

2 EventPublishingRunListener

我们围绕EventPublishingRunListener来分析一下

2.1 EventPublishingRunListener跟读

看注释及类继承关系可知，EventPublishingRunListener既是一个监听者（它实现了SpringApplicationRunListener），又是一个事件发布者（它在监听方法中，发布了相应的事件）。

/**
 * {@link SpringApplicationRunListener} to publish {@link SpringApplicationEvent}s.
 * <p>
 * Uses an internal {@link ApplicationEventMulticaster} for the events that are fired
 * before the context is actually refreshed.
 *
 * @author Phillip Webb
 * @author Stephane Nicoll
 * @author Andy Wilkinson
 * @author Artsiom Yudovin
 * @author Brian Clozel
 * @author Chris Bono
 * @since 1.0.0
 */
public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

再看一下EventPublishingRunListener实现的监听方法，以starting为例，发现它是通过持有的SimpleApplicationEventMulticaster发布事件出去的

@Override
public void starting(ConfigurableBootstrapContext bootstrapContext) {
   this.initialMulticaster
      .multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
}

那事件的监听者又是从哪里来的呢，继续跟进代码multicastEvent，方法内调用了getApplicationListeners获取事件监听者，并逐个调用

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
   ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
   Executor executor = getTaskExecutor();
   for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
      if (executor != null) {
         executor.execute(() -> invokeListener(listener, event));
      }
      else {
         invokeListener(listener, event);
      }
   }
}

跟进getApplicationListeners -> retrieveApplicationListeners，发现了事件监听者的来源：this.defaultRetriever

private Collection<ApplicationListener<?>> retrieveApplicationListeners(
      ResolvableType eventType, @Nullable Class<?> sourceType, @Nullable CachedListenerRetriever retriever) {

   List<ApplicationListener<?>> allListeners = new ArrayList<>();
   Set<ApplicationListener<?>> filteredListeners = (retriever != null ? new LinkedHashSet<>() : null);
   Set<String> filteredListenerBeans = (retriever != null ? new LinkedHashSet<>() : null);

   Set<ApplicationListener<?>> listeners;
   Set<String> listenerBeans;
   synchronized (this.defaultRetriever) {
      listeners = new LinkedHashSet<>(this.defaultRetriever.applicationListeners);
      listenerBeans = new LinkedHashSet<>(this.defaultRetriever.applicationListenerBeans);
   }

   //省略余下代码...
   //... ...
}

找到this.defaultRetriever这个属性赋值的地方，果然有个addApplicationListener

@Override
public void addApplicationListener(ApplicationListener<?> listener) {
   synchronized (this.defaultRetriever) {
      // Explicitly remove target for a proxy, if registered already,
      // in order to avoid double invocations of the same listener.
      Object singletonTarget = AopProxyUtils.getSingletonTarget(listener);
      if (singletonTarget instanceof ApplicationListener) {
         this.defaultRetriever.applicationListeners.remove(singletonTarget);
      }
      this.defaultRetriever.applicationListeners.add(listener);
      this.retrieverCache.clear();
   }
}

查找这个方法的调用方，或者直接回到EventPublishingRunListener中，很容易找到EventPublishingRunListener的构造方法中初始化添加了监听者，而监听者的源头又来自于application.getListeners()

public EventPublishingRunListener(SpringApplication application, String[] args) {
   this.application = application;
   this.args = args;
   this.initialMulticaster = new SimpleApplicationEventMulticaster();
   for (ApplicationListener<?> listener : application.getListeners()) {
      this.initialMulticaster.addApplicationListener(listener);
   }
}

再到SpringApplication类中找到listeners来源于构造方法，从spring.factories中获取

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();
   this.bootstrapRegistryInitializers = new ArrayList<>(
         getSpringFactoriesInstances(BootstrapRegistryInitializer.class));
   setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class));
   setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
   this.mainApplicationClass = deduceMainApplicationClass();
}

看到这里，应该已经晕了，我们阶段性总结一下：EventPublishingRunListener本身是一个监听者，监听了SpringApplication#run启动过程的生命周期方法。EventPublishingRunListener同时还是一个事件发布者，通过ApplicationEventMulticaster事件广播器发布了各种SpringApplicationEvent事件，这些事件有自己的监听者，事件监听者最初取自于SpringApplication（构造时从spring.factories中加载）。

到此本以为一切都结束了，可是细心的我又发现一个可疑的点，请看EventPublishingRunListener部分方法的对比，以starting和started为例，为啥使用了不同的事件发布方式？context.publishEvent和AvailabilityChangeEvent.publish是什么？

public void starting(ConfigurableBootstrapContext bootstrapContext) {
	this.initialMulticaster
		.multicastEvent(new ApplicationStartingEvent(bootstrapContext, this.application, this.args));
}
public void started(ConfigurableApplicationContext context, Duration timeTaken) {
   context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context, timeTaken));
   AvailabilityChangeEvent.publish(context, LivenessState.CORRECT);
}

深入代码，不难发现原来ApplicationContext继承了ApplicationEventPublisher，也是一个事件发布者。而且发布事件的机制和EventPublishingRunListener类似，也是持有一个ApplicationEventMulticaster，通过事件广播器广播事件及管理监听者，而这些监听者就是开发时通常用到的，利用ApplicationContext的addApplicationListener方法注册进去的。

2.2 EventPublishingRunListener总结

对以上内容，我总结了一份关系图供参考，从中可以整体上感受到：

• SpringApplicationRunListener是SpringApplication#run方法执行过程的监听者，SpringApplication#run通过SpringApplicationRunListeners代理调用SpringApplicationRunListener
• EventPublishingRunListener实现了SpringApplicationRunListener，监听SpringApplication#run方法的执行过程，并依此发布不同的事件SpringApplicationEvent
• EventPublishingRunListener发布事件及调用监听者的机制是利用ApplicationEventMulticaster事件广播器实现的
• ApplicationContext也有事件发布者的身份，事件发布机制与EventPublishingRunListener的类似