转载

SpringBoot内置生命周期事件详解 SpringBoot源码(十)

SpringBoot中文注释项目Github地址：

https://github.com/yuanmabiji/spring-boot-2.1.0.RELEASE

本篇接 SpringBoot事件监听机制源码分析(上) SpringBoot源码(九)

1 温故而知新

温故而知新，我们来简单回顾一下上篇的内容，上一篇我们分析了SpringBoot启动时广播生命周期事件的原理 ，现将关键步骤再浓缩总结下：

为广播SpringBoot内置生命周期事件做前期准备：1）首先加载ApplicationListener 监听器实现类；2）其次加载SPI扩展类EventPublishingRunListener 。
SpringBoot启动时利用EventPublishingRunListener 广播生命周期事件，然后ApplicationListener 监听器实现类监听相应的生命周期事件执行一些初始化逻辑的工作。

2 引言

上篇文章的侧重点是分析了SpringBoot启动时广播生命周期事件的原理，此篇文章我们再来详细分析SpringBoot内置的7种生命周期事件的源码。

3 SpringBoot生命周期事件源码分析

分析SpringBoot的生命周期事件，我们先来看一张类结构图： SpringBoot内置生命周期事件详解 SpringBoot源码(十) 由上图可以看到事件类之间的关系：

最顶级的父类是JDK的事件基类EventObject ；
然后Spring的事件基类ApplicationEvent 继承了JDK的事件基类EventObject ；
其次SpringBoot的生命周期事件基类SpringApplicationEvent 继承了Spring的事件基类ApplicationEvent ；
最后SpringBoot具体的7个生命周期事件类再继承了SpringBoot的生命周期事件基类SpringApplicationEvent 。

3.1 JDK的事件基类EventObject

EventObject 类是JDK的事件基类，可以说是所有Java事件类的基本，即所有的Java事件类都直接或间接继承于该类，源码如下：

// EventObject.java

public class EventObject implements java.io.Serializable {

 private static final long serialVersionUID = 5516075349620653480L;

 /**
 * The object on which the Event initially occurred.
 */
 protected transient Object source;
 /**
 * Constructs a prototypical Event.
 *
 * @param source The object on which the Event initially occurred.
 * @exception IllegalArgumentException if source is null.
 */
 public EventObject(Object source) {
 if (source == null)
 throw new IllegalArgumentException("null source");
 this.source = source;
 }
 /**
 * The object on which the Event initially occurred.
 *
 * @return The object on which the Event initially occurred.
 */
 public Object getSource() {
 return source;
 }
 /**
 * Returns a String representation of this EventObject.
 *
 * @return A a String representation of this EventObject.
 */
 public String toString() {
 return getClass().getName() + "[source=" + source + "]";
 }
}

可以看到EventObject 类只有一个属性source ，这个属性是用来记录最初事件是发生在哪个类，举个栗子，比如在SpringBoot启动过程中会发射ApplicationStartingEvent 事件，而这个事件最初是在SpringApplication 类中发射的，因此source 就是SpringApplication 对象。

3.2 Spring的事件基类ApplicationEvent

ApplicationEvent 继承了DK的事件基类EventObject 类，是Spring的事件基类，被所有Spring的具体事件类继承，源码如下：

// ApplicationEvent.java

/**
 * Class to be extended by all application events. Abstract as it
 * doesn't make sense for generic events to be published directly.
 *
 * @author Rod Johnson
 * @author Juergen Hoeller
 */
public abstract class ApplicationEvent extends EventObject {
 /** use serialVersionUID from Spring 1.2 for interoperability. */
 private static final long serialVersionUID = 7099057708183571937L;
 /** System time when the event happened. */
 private final long timestamp;
 /**
 * Create a new ApplicationEvent.
 * @param source the object on which the event initially occurred (never {@code null})
 */
 public ApplicationEvent(Object source) {
 super(source);
 this.timestamp = System.currentTimeMillis();
 }
 /**
 * Return the system time in milliseconds when the event happened.
 */
 public final long getTimestamp() {
 return this.timestamp;
 }
}

可以看到ApplicationEvent 有且仅有一个属性timestamp ，该属性是用来记录事件发生的时间。

3.3 SpringBoot的事件基类SpringApplicationEvent

SpringApplicationEvent 类继承了Spring的事件基类ApplicationEvent ，是所有SpringBoot内置生命周期事件的父类，源码如下：


/**
 * Base class for {@link ApplicationEvent} related to a {@link SpringApplication}.
 *
 * @author Phillip Webb
 */
@SuppressWarnings("serial")
public abstract class SpringApplicationEvent extends ApplicationEvent {
 private final String[] args;
 public SpringApplicationEvent(SpringApplication application, String[] args) {
 super(application);
 this.args = args;
 }
 public SpringApplication getSpringApplication() {
 return (SpringApplication) getSource();
 }
 public final String[] getArgs() {
 return this.args;
 }
}

可以看到SpringApplicationEvent 有且仅有一个属性args ，该属性就是SpringBoot启动时的命令行参数即标注@SpringBootApplication 启动类中main 函数的参数。

3.4 SpringBoot具体的生命周期事件类

接下来我们再来看一下SpringBoot 内置生命周期事件即SpringApplicationEvent 的具体子类们。

3.4.1 ApplicationStartingEvent

// ApplicationStartingEvent.java

public class ApplicationStartingEvent extends SpringApplicationEvent {
 public ApplicationStartingEvent(SpringApplication application, String[] args) {
 super(application, args);
 }
}

SpringBoot开始启动时便会发布ApplicationStartingEvent 事件，其发布时机在环境变量Environment或容器ApplicationContext创建前但在注册ApplicationListener 具体监听器之后，标志标志SpringApplication 开始启动。

3.4.2 ApplicationEnvironmentPreparedEvent

// ApplicationEnvironmentPreparedEvent.java

public class ApplicationEnvironmentPreparedEvent extends SpringApplicationEvent {
 private final ConfigurableEnvironment environment;
 /**
 * Create a new {@link ApplicationEnvironmentPreparedEvent} instance.
 * @param application the current application
 * @param args the arguments the application is running with
 * @param environment the environment that was just created
 */
 public ApplicationEnvironmentPreparedEvent(SpringApplication application,
 String[] args, ConfigurableEnvironment environment) {
 super(application, args);
 this.environment = environment;
 }
 /**
 * Return the environment.
 * @return the environment
 */
 public ConfigurableEnvironment getEnvironment() {
 return this.environment;
 }
}

可以看到ApplicationEnvironmentPreparedEvent 事件多了一个environment 属性，我们不妨想一下，多了environment 属性的作用是啥？答案就是ApplicationEnvironmentPreparedEvent 事件的environment 属性作用是利用事件发布订阅机制，相应监听器们可以从ApplicationEnvironmentPreparedEvent 事件中取出environment 变量，然后我们可以为environment 属性增加属性值或读出environment 变量中的值。

举个栗子：ConfigFileApplicationListener 监听器就是监听了ApplicationEnvironmentPreparedEvent 事件，然后取出ApplicationEnvironmentPreparedEvent 事件的environment 属性，然后再为environment 属性增加application.properties 配置文件中的环境变量值。

当SpringApplication已经开始启动且环境变量Environment 已经创建后，并且为环境变量Environment 配置了命令行和Servlet 等类型的环境变量后，此时会发布ApplicationEnvironmentPreparedEvent 事件。

监听ApplicationEnvironmentPreparedEvent 事件的第一个监听器是ConfigFileApplicationListener ，因为是ConfigFileApplicationListener 监听器还要为环境变量Environment 增加application.properties 配置文件中的环境变量；此后还有一些也是监听ApplicationEnvironmentPreparedEvent 事件的其他监听器监听到此事件时，此时可以说环境变量Environment 几乎已经完全准备好了。

思考：监听同一事件的监听器们执行监听逻辑时是有顺序的，我们可以想一下这个排序逻辑是什么时候排序的？还有为什么要这样排序呢？

3.4.3 ApplicationContextInitializedEvent

// ApplicationContextInitializedEvent.java

public class ApplicationContextInitializedEvent extends SpringApplicationEvent {
 private final ConfigurableApplicationContext context;
 /**
 * Create a new {@link ApplicationContextInitializedEvent} instance.
 * @param application the current application
 * @param args the arguments the application is running with
 * @param context the context that has been initialized
 */
 public ApplicationContextInitializedEvent(SpringApplication application,
 String[] args, ConfigurableApplicationContext context) {
 super(application, args);
 this.context = context;
 }
 /**
 * Return the application context.
 * @return the context
 */
 public ConfigurableApplicationContext getApplicationContext() {
 return this.context;
 }
}

可以看到ApplicationContextInitializedEvent 事件多了个ConfigurableApplicationContext 类型的context 属性，context 属性的作用同样是为了相应监听器可以拿到这个context 属性执行一些逻辑，具体作用将在3.4.4 详述。

ApplicationContextInitializedEvent 事件在ApplicationContext 容器创建后，且为ApplicationContext 容器设置了environment 变量和执行了ApplicationContextInitializers 的初始化方法后但在bean定义加载前触发，标志ApplicationContext已经初始化完毕。

扩展：可以看到 ApplicationContextInitializedEvent 是在为 context 容器配置 environment 变量后触发，此时 ApplicationContextInitializedEvent 等事件只要有 context 容器的话，那么其他需要 environment 环境变量的监听器只需要从 context 中 取出 environment 变量即可，从而 ApplicationContextInitializedEvent 等事件没必要再配置 environment 属性。

3.4.4 ApplicationPreparedEvent

// ApplicationPreparedEvent.java

public class ApplicationPreparedEvent extends SpringApplicationEvent {
 private final ConfigurableApplicationContext context;
 /**
 * Create a new {@link ApplicationPreparedEvent} instance.
 * @param application the current application
 * @param args the arguments the application is running with
 * @param context the ApplicationContext about to be refreshed
 */
 public ApplicationPreparedEvent(SpringApplication application, String[] args,
 ConfigurableApplicationContext context) {
 super(application, args);
 this.context = context;
 }
 /**
 * Return the application context.
 * @return the context
 */
 public ConfigurableApplicationContext getApplicationContext() {
 return this.context;
 }
}

同样可以看到ApplicationPreparedEvent 事件多了个ConfigurableApplicationContext 类型的context 属性，多了context 属性的作用是能让监听该事件的监听器们能拿到context 属性，监听器拿到context 属性一般有如下作用：

context ConfigFileApplicationListener ApplicationPreparedEvent context context PropertySourceOrderingPostProcessor

context beanFactory bean LoggingApplicationListener ApplicationPreparedEvent context beanFactory springBootLoggingSystem bean

context Environment PropertiesMigrationListener

ApplicationPreparedEvent 事件在ApplicationContext 容器已经完全准备好时但在容器刷新前触发，在这个阶段bean 定义已经加载完毕还有environment 已经准备好可以用了。

3.4.5 ApplicationStartedEvent

// ApplicationStartedEvent.java

public class ApplicationStartedEvent extends SpringApplicationEvent {
 private final ConfigurableApplicationContext context;
 /**
 * Create a new {@link ApplicationStartedEvent} instance.
 * @param application the current application
 * @param args the arguments the application is running with
 * @param context the context that was being created
 */
 public ApplicationStartedEvent(SpringApplication application, String[] args,
 ConfigurableApplicationContext context) {
 super(application, args);
 this.context = context;
 }
 /**
 * Return the application context.
 * @return the context
 */
 public ConfigurableApplicationContext getApplicationContext() {
 return this.context;
 }
}

ApplicationStartedEvent 事件将在容器刷新后但ApplicationRunner 和CommandLineRunner 的run 方法执行前触发，标志Spring 容器已经刷新，此时容器已经准备完毕了。

扩展：这里提到了ApplicationRunner 和CommandLineRunner 接口有啥作用呢？我们一般会在Spring 容器刷新完毕后，此时可能有一些系统参数等静态数据需要加载，此时我们就可以实现了ApplicationRunner 或CommandLineRunner 接口来实现静态数据的加载。

3.4.6 ApplicationReadyEvent

// ApplicationReadyEvent.java

public class ApplicationReadyEvent extends SpringApplicationEvent {
 private final ConfigurableApplicationContext context;
 /**
 * Create a new {@link ApplicationReadyEvent} instance.
 * @param application the current application
 * @param args the arguments the application is running with
 * @param context the context that was being created
 */
 public ApplicationReadyEvent(SpringApplication application, String[] args,
 ConfigurableApplicationContext context) {
 super(application, args);
 this.context = context;
 }
 /**
 * Return the application context.
 * @return the context
 */
 public ConfigurableApplicationContext getApplicationContext() {
 return this.context;
 }
}

ApplicationReadyEvent 事件在调用完ApplicationRunner 和CommandLineRunner 的run 方法后触发，此时标志SpringApplication 已经正在运行。

3.4.7 ApplicationFailedEvent

// ApplicationFailedEvent.java

public class ApplicationFailedEvent extends SpringApplicationEvent {
 private final ConfigurableApplicationContext context;
 private final Throwable exception;
 /**
 * Create a new {@link ApplicationFailedEvent} instance.
 * @param application the current application
 * @param args the arguments the application was running with
 * @param context the context that was being created (maybe null)
 * @param exception the exception that caused the error
 */
 public ApplicationFailedEvent(SpringApplication application, String[] args,
 ConfigurableApplicationContext context, Throwable exception) {
 super(application, args);
 this.context = context;
 this.exception = exception;
 }
 /**
 * Return the application context.
 * @return the context
 */
 public ConfigurableApplicationContext getApplicationContext() {
 return this.context;
 }
 /**
 * Return the exception that caused the failure.
 * @return the exception
 */
 public Throwable getException() {
 return this.exception;
 }
}