SpringBoot源码解析(八)：SpringApplicationRunListener生命周期事件广播

一、SpringApplicationRunListener概述

1.1 核心概念与作用

SpringApplicationRunListener是SpringBoot应用启动过程中的核心事件监听器接口，它定义了应用启动过程中各个关键生命周期阶段的回调方法。其主要功能包括：

1. 生命周期事件通知：在应用启动的关键节点发布事件
2. 启动过程监控：监控应用启动的完整流程
3. 扩展点集成：与其他扩展机制协同工作
4. 异常处理：在启动失败时提供回调

1.2 接口定义与核心方法

public interface SpringApplicationRunListener {

    /**
     * 应用启动时立即调用
     */
    default void starting(ConfigurableBootstrapContext bootstrapContext) {
        starting();
    }

    /**
     * 环境准备完成后调用
     */
    default void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
            ConfigurableEnvironment environment) {
        environmentPrepared(environment);
    }

    /**
     * 应用上下文创建后，资源加载前调用
     */
    default void contextPrepared(ConfigurableApplicationContext context) {
    }

    /**
     * 应用上下文加载完成，刷新前调用
     */
    default void contextLoaded(ConfigurableApplicationContext context) {
    }

    /**
     * 应用上下文刷新完成，命令执行前调用
     */
    default void started(ConfigurableApplicationContext context) {
    }

    /**
     * 应用完全就绪后调用
     */
    default void running(ConfigurableApplicationContext context) {
    }

    /**
     * 启动失败时调用
     */
    default void failed(ConfigurableApplicationContext context, Throwable exception) {
    }
}

二、运行监听器的加载机制

2.1 加载入口

监听器的加载始于SpringApplication的构造方法：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) {
    // ...
    setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class));
    // ...
}

2.2 工厂加载机制

SpringFactoriesLoader负责从META-INF/spring.factories加载实现类：

private  Collection getSpringFactoriesInstances(Class type) {
    return getSpringFactoriesInstances(type, new Class[] {});
}

private  Collection getSpringFactoriesInstances(Class type,
        Class[] parameterTypes, Object... args) {
    ClassLoader classLoader = getClassLoader();
    Set names = new LinkedHashSet<>(
            SpringFactoriesLoader.loadFactoryNames(type, classLoader));
    List instances = createSpringFactoriesInstances(type, parameterTypes,
            classLoader, args, names);
    AnnotationAwareOrderComparator.sort(instances);
    return instances;
}

2.3 实例创建过程

private  List createSpringFactoriesInstances(Class type,
        Class[] parameterTypes, ClassLoader classLoader,
        Object[] args, Set names) {
    List instances = new ArrayList<>(names.size());
    for (String name : names) {
        try {
            Class instanceClass = ClassUtils.forName(name, classLoader);
            Assert.isAssignable(type, instanceClass);
            Constructor constructor = instanceClass.getConstructor(parameterTypes);
            T instance = (T) BeanUtils.instantiateClass(constructor, args);
            instances.add(instance);
        } catch (Throwable ex) {
            throw new IllegalArgumentException("Cannot instantiate " + type + " : " + name, ex);
        }
    }
    return instances;
}

三、事件广播的核心流程

3.1 运行监听器的包装

SpringApplicationRunListeners类封装了多个监听器的批量操作：

class SpringApplicationRunListeners {

    private final Log log;
    private final List listeners;
    private final ApplicationStartup applicationStartup;

    SpringApplicationRunListeners(Log log, Collection listeners,
            ApplicationStartup applicationStartup) {
        this.log = log;
        this.listeners = new ArrayList<>(listeners);
        this.applicationStartup = applicationStartup;
    }

    // 各生命周期方法的批量调用...
}

3.2 事件广播时序图

Mermaid

四、各生命周期阶段详解

4.1 starting阶段

4.1.1 触发时机

应用启动时的第一个回调，在SpringApplication.run()方法中：

public ConfigurableApplicationContext run(String... args) {
    // ...
    SpringApplicationRunListeners listeners = getRunListeners(args);
    listeners.starting(bootstrapContext, this.mainApplicationClass);
    // ...
}

4.1.2 典型实现

EventPublishingRunListener的实现：

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

4.2 environmentPrepared阶段

4.2.1 触发时机

环境准备完成后，上下文创建前：

private ConfigurableEnvironment prepareEnvironment(
        SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments) {
    // ...
    listeners.environmentPrepared(bootstrapContext, environment);
    // ...
}

4.2.2 典型实现

@Override
public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
        ConfigurableEnvironment environment) {
    this.initialMulticaster.multicastEvent(new ApplicationEnvironmentPreparedEvent(
            this.application, this.args, environment));
}

4.3 contextPrepared阶段

4.3.1 触发时机

上下文创建后，资源加载前：

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // ...
    listeners.contextPrepared(context);
    // ...
}

4.3.2 典型实现

@Override
public void contextPrepared(ConfigurableApplicationContext context) {
    this.initialMulticaster.multicastEvent(new ApplicationContextInitializedEvent(
            this.application, this.args, context));
}

4.

4 contextLoaded阶段

4.4.1 触发时机

上下文加载完成，刷新前：

private void prepareContext(ConfigurableApplicationContext context,
        ConfigurableEnvironment environment, SpringApplicationRunListeners listeners,
        ApplicationArguments applicationArguments, Banner printedBanner) {
    // ...
    listeners.contextLoaded(context);
}

4.4.2 典型实现

@Override
public void contextLoaded(ConfigurableApplicationContext context) {
    // 无默认事件发布
}

4.5 started阶段

4.5.1 触发时机

上下文刷新完成，命令执行前：

private void callRunners(ApplicationContext context, ApplicationArguments args) {
    // ...
    listeners.started(context);
    // ...
}

4.5.2 典型实现

@Override
public void started(ConfigurableApplicationContext context) {
    context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
}

4.6 running阶段

4.6.1 触发时机

应用完全就绪后：

private void callRunners(ApplicationContext context, ApplicationArguments args) {
    // ...
    listeners.running(context);
    // ...
}

4.6.2 典型实现

@Override
public void running(ConfigurableApplicationContext context) {
    context.publishEvent(new ApplicationReadyEvent(this.application, this.args, context));
}

4.7 failed阶段

4.7.1 触发时机

启动过程中任何阶段发生异常时：

private void handleRunFailure(ConfigurableApplicationContext context, Throwable exception,
        SpringApplicationRunListeners listeners) {
    // ...
    listeners.failed(context, exception);
    // ...
}

4.7.2 典型实现

@Override
public void failed(ConfigurableApplicationContext context, Throwable exception) {
    ApplicationFailedEvent event = new ApplicationFailedEvent(this.application,
            this.args, context, exception);
    if (context != null && context.isActive()) {
        context.publishEvent(event);
    }
    else {
        this.initialMulticaster.multicastEvent(event);
    }
}

五、内置监听器分析

5.1 EventPublishingRunListener

5.1.1 核心作用

将SpringApplicationRunListener生命周期方法转换为标准Spring事件：

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

    private final SpringApplication application;
    private final String[] args;
    private final SimpleApplicationEventMulticaster initialMulticaster;

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

    // 其他方法实现...
}

5.1.2 事件转换表

生命周期方法	对应事件类型
starting	ApplicationStartingEvent
environmentPrepared	ApplicationEnvironmentPreparedEvent
contextPrepared	ApplicationContextInitializedEvent
started	ApplicationStartedEvent
running	ApplicationReadyEvent
failed	ApplicationFailedEvent

5.2 BackgroundPreinitializer

5.2.1 核心作用

在后台线程中预初始化常用组件：

public class BackgroundPreinitializer implements ApplicationListener {

    @Override
    public void onApplicationEvent(SpringApplicationEvent event) {
        if (event instanceof ApplicationStartingEvent) {
            performPreinitialization();
        }
    }

    private void performPreinitialization() {
        try {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    runSafely(new ConversionServiceInitializer());
                    runSafely(new ValidationInitializer());
                    runSafely(new MessageConverterInitializer());
                    runSafely(new MBeanFactoryInitializer());
                }
            }, "background-preinit");
            thread.start();
        } catch (Exception ex) {
            // 处理异常...
        }
    }
}

六、事件传播机制

6.1 事件传播层次

SpringBoot事件传播分为两个层次：

1. 早期事件：通过SimpleApplicationEventMulticaster直接广播
2. 后期事件：通过ApplicationContext的事件机制广播

6.2 早期事件传播

public class EventPublishingRunListener implements SpringApplicationRunListener, Ordered {

    private final SimpleApplicationEventMulticaster initialMulticaster;

    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);
        }
    }

    // 事件广播方法...
}

6.3 后期事件传播

@Override
public void started(ConfigurableApplicationContext context) {
    // 通过ApplicationContext发布事件
    context.publishEvent(new ApplicationStartedEvent(this.application, this.args, context));
}

七、自定义监听器实践

7.1 实现自定义运行监听器

public class CustomRunListener implements SpringApplicationRunListener {

    private final Log logger = LogFactory.getLog(getClass());

    public CustomRunListener(SpringApplication application, String[] args) {
        // 构造器必须包含这两个参数
    }

    @Override
    public void starting(ConfigurableBootstrapContext bootstrapContext) {
        logger.info("应用启动开始");
    }

    @Override
    public void environmentPrepared(ConfigurableBootstrapContext bootstrapContext,
            ConfigurableEnvironment environment) {
        logger.info("环境准备完成: " + environment);
    }

    @Override
    public void running(ConfigurableApplicationContext context) {
        logger.info("应用启动完成，服务已就绪");
    }
}

7.2 注册自定义监听器

在META-INF/spring.factories中配置：

Propertiesorg.springframework.boot.SpringApplicationRunListener=\
  com.example.CustomRunListener

八、监听器的调试与诊断

8.1 调试技巧

1. 日志级别调整：
2. 关键断点设置：
   • SpringApplicationRunListeners各方法
   • EventPublishingRunListener事件转换处
   • 自定义监听器的回调方法

8.2 诊断工具

1. Actuator端点：
2. 事件跟踪：

•  GET /actuator/events

1. 启动指标：

九、性能优化与最佳实践

9.1 性能优化建议

1. 避免阻塞操作：在监听器中避免长时间阻塞
2. 异步处理：耗时操作使用异步线程
3. 缓存数据：重复使用的数据进行缓存
4. 精简逻辑：只包含必要的启动逻辑

9.2 最佳实践

1. 单一职责：每个监听器只关注一个特定任务
2. 明确阶段：清楚每个回调方法的执行时机
3. 异常处理：妥善处理可能出现的异常
4. 文档记录：为自定义监听器添加详细文档

十、版本演进与兼容性

10.1 Spring Boot 1.x到2.x的变化

1. 接口方法变更：增加了bootstrapContext参数
2. 事件体系扩展：新增更多生命周期事件
3. 执行顺序优化：更精确的监听器排序

10.2 Spring Boot 2.7的重要改进

1. 启动指标增强：更详细的启动过程监控
2. 事件类型丰富：新增上下文准备事件
3. 性能优化：减少事件传播开销

十一、总结与核心价值

11.1 核心机制回顾

1. 加载机制：通过SpringFactoriesLoader加载实现类
2. 包装模式：SpringApplicationRunListeners统一管理
3. 事件转换：EventPublishingRunListener将生命周期转换为标准事件
4. 阶段划分：清晰的7个生命周期阶段

11.2 设计价值分析

1. 扩展性：为应用启动过程提供丰富扩展点
2. 可观测性：完整监控应用启动流程
3. 解耦设计：将启动过程与业务逻辑解耦
4. 一致性：统一的事件处理机制

11.3 典型应用场景

1. 启动监控：记录应用启动时间和各阶段耗时
2. 环境检测：验证运行环境是否符合要求
3. 动态配置：根据环境调整应用配置
4. 服务预热：在就绪前完成缓存加载等操作

通过本文的深度解析，我们全面掌握了SpringApplicationRunListener在SpringBoot启动过程中的核心机制与实现原理。从加载机制、事件广播到各生命周期阶段的详细分析，这一扩展点为开发者提供了对应用启动过程的精细控制能力。合理运用这一机制，可以构建更加健壮、可观测的SpringBoot应用系统。