监听器与事件机制

监听器机制是 Spring Boot 启动流程的核心组件，用于在各个阶段广播事件并执行扩展逻辑。

监听器加载机制

SpringApplicationRunListener 加载

// SpringApplication 构造时加载监听器
public SpringApplication(ResourceLoader resourceLoader, Class<?>... primarySources) {
    // 加载所有 SpringApplicationRunListener
    this.runListeners = getRunListeners(arguments);
}

private SpringApplicationRunListeners getRunListeners(String[] args) {
    // 通过 spring.factories 加载
    return new SpringApplicationRunListeners(
        SpringFactoriesLoader.load(SpringApplicationRunListener.class, getClassLoader()));
}

spring.factories 配置

org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

EventPublishingRunListener

核心实现

public class EventPublishingRunListener implements SpringApplicationRunListener {
    private final SimpleApplicationEventMulticaster initialMulticaster;

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

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

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

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

启动事件类型

事件序列（按启动顺序）

1. ApplicationStartingEvent          - 启动开始
2. ApplicationEnvironmentPreparedEvent - 环境准备完成
3. ApplicationContextInitializedEvent - 上下文初始化
4. ApplicationPreparedEvent          - 上下文准备完成
5. ApplicationStartingEvent          - 上下文刷新前
6. ApplicationStartedEvent           - 上下文刷新完成
7. ApplicationReadyEvent             - 应用就绪
8. ApplicationFailedEvent            - 启动失败

事件继承体系

// 基类
public abstract class SpringApplicationEvent extends ApplicationEvent {
    private final SpringApplication application;
    private final String[] args;
}

// 具体事件
public class ApplicationEnvironmentPreparedEvent extends SpringApplicationEvent {
    private final ConfigurableEnvironment environment;
}

ApplicationListener 注册

通过 spring.factories 注册

org.springframework.boot.ApplicationListener=\
org.springframework.boot.context.config.ConfigFileApplicationListener,\
org.springframework.boot.context.logging.LoggingApplicationListener

代码注册方式

public class CustomApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        ConfigurableEnvironment environment = event.getEnvironment();
        // 自定义逻辑
    }
}

// 注册
SpringApplication app = new SpringApplication(App.class);
app.addListeners(new CustomApplicationListener());

内置监听器

LoggingApplicationListener

// 初始化日志系统
public class LoggingApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // 根据 environment 配置初始化日志
        LoggingSystem loggingSystem = LoggingSystem.get(getClass().getClassLoader());
        loggingSystem.beforeInitialize();
    }
}

ConfigFileApplicationListener

// 加载配置文件
public class ConfigFileApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {
    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // 加载 application.yml/properties
        load(event.getEnvironment());
    }
}

自定义监听器实战

监听启动完成

@Component
public class StartupCompleteListener implements ApplicationListener<ApplicationReadyEvent> {
    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("应用启动完成！");
        // 记录启动耗时等
    }
}

监听启动失败

@Component
public class StartupFailureListener implements ApplicationListener<ApplicationFailedEvent> {
    @Override
    public void onApplicationEvent(ApplicationFailedEvent event) {
        Throwable exception = event.getException();
        log.error("启动失败", exception);
    }
}

条件监听

@Component
@ConditionalOnProperty(name = "app.monitor.enabled", havingValue = "true")
public class ConditionalListener implements ApplicationListener<ApplicationStartedEvent> {
    @Override
    public void onApplicationEvent(ApplicationStartedEvent startedEvent) {
        // 条件满足才执行
    }
}

事件广播机制

SimpleApplicationEventMulticaster

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
    @Override
    public void multicastEvent(ApplicationEvent event) {
        multicastEvent(event, resolveDefaultEventType(event));
    }

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

注意：监听器执行顺序由 @Order 注解或 Ordered 接口控制，数值越小优先级越高。

要点总结

• EventPublishingRunListener 是默认的事件广播实现
• 启动过程依次广播 7 个核心事件
• 监听器通过 spring.factories 或代码注册
• 可在任意阶段插入自定义逻辑
• 异步广播需要配置 Executor