有意与无意之间

1 监听器Listener

在Spring Boot中，监听器(Listener)用于监听应用程序中发生的事件，以便在事件发生时执行特定的逻辑。监听器模式用于解耦组件之间的耦合性，使得应用程序可以灵活地响应事件和状态变化。可以实现特定的接口或使用注解来实现监听器。

1.1 监听器的作用

• 事件驱动 监听器可以实现事件模式编程，让不同组件之间能更松散地写作，降低耦合度；
• 应用初始化 可以在应用初始化或销毁的时候执行特定的操作，如加载数据、启动任务等；
• 状态监控 用于监控应用程序的状态变化，例如兼容数据库连接池的状态、应用程序的性能指标等。

1.2 通过实现ApplicationListener接口定义监听器

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 在应用上下文刷新完成后触发
        System.out.println("Application context refreshed.");
    }
}

1.3 通过注解定义监听器

import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;

@Component
public class MyAnnotationListener {

    @EventListener
    public void handleContextRefresh(ContextRefreshedEvent event) {
        System.out.println("Application context refreshed (via annotation).");
    }

    //监听单个事件
    @EventListener
    public void listenerApplicationStarted(ApplicationStartedEvent event) {
        log.info("应用启动完成");
    }

    @EventListener({ApplicationEnvironmentPreparedEvent.class})
    public void listenerApplicationEnv() {
        //实际测试，没有监听到，后面说明原理
        log.info("监听到了环境准备完成事件");
    }

    //监听多个事件
    @EventListener({ApplicationReadyEvent.class, ApplicationStartedEvent.class})
    public void listenerApplication() {
        log.info("监听到了多个事件");
    }

    //自己发布了一个Person事件，Person并没有继承ApplicationEvent
    @EventListener
    public void myCustomListener(Person person) {
        log.info("监听到自己发布的事件,{}", person);
    }

    //只有Person事件中name属性值为csdn时才接收到
    @EventListener(condition = "#person.name == 'csdn'")
    public void myCustomListener2(Person person) {
        log.info("SpEL表达式监听到自己发布的事件,{}", person);
    }
}

1.4 添加监听器

1.4.1 使用spring.factories

在resources文件夹下创建META-INF目录，在此目录下创建spring.factories文件夹，添加

org.springframework.context.ApplicationListener=com.springboot.demo.listeners.MyApplicationListener

1.4.2 对事件使用addListener

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(MyApplication.class);
        app.addListeners(new MyApplicationListener());
        app.run(args);
    }
}

这种方法就是观察者模式，将监听器注册到事件的观察者列表中，当事件发生时，循环调用或通知观察者。

1.4.3 通过配置添加事件监听

在application.yml中添加

context:
  listener:
    classes: com.springboot.demo.listeners.MyApplicationListener

1.4.4 编写监听器的技巧

• 谨慎处理耗时操作 监听器中的逻辑应该尽量保持轻量级，避免耗时操作，以免影响应用程序的性能;
• 避免循环依赖 监听器与其他组件之间避免产生循环依赖，否则可能引起意外问题;
• 使用事件层级 根据需要，可以定义自己的事件类，以及相应的监听器，使事件传递更加灵活;
• 合理使用事件的异步处理 Spring Boot 支持异步监听器，可以在监听器中使用 @Async 注解来实现异步处理，提高性能。

1.4.5 内置的监听器

• ClearCachesApplicationListener
  应用上下文加载完成后对缓存做清除工作
• ParentContextCloserApplicationListener
  父应用程序上下文关闭时，会将关闭事件向下传播以关闭该应用程序上下文
• FileEncodingApplicationListener
  用于监听应用程序环境准备完毕时，如果系统文件编码（spring.mandatory-file-encoding）与环境中配置的值(file.encoding)不匹配时(忽略大小写)，会抛出异常，并停止应用程序
• AnsiOutputApplicationListener
  根据spring.output.ansi.enabled参数配置AnsiOutput
• DelegatingApplicationListener
  用于委托管理context.listener.classes中配置的监听器
• LoggingApplicationListener
  配置和初始化Spring Boot 的日志系统
• EnvironmentPostProcessorApplicationListener
  管理spring.factories文件中注册的EnvironmentPostProcessors

2 事件Event

在 Spring Boot 中，事件（Event）是一种在应用程序中用于通知和响应状态或动作变化的机制。通过事件机制，不同的组件可以松散耦合地协作，实现模块化和可扩展的应用程序架构。事件的作用在于提供了一种解耦的方式，使得应用程序的不同部分能够相互通信和交互，而不需要直接引用彼此的实现细节。

以下是 Spring Boot 中事件的一些作用：

• 解耦和模块化： 通过事件机制，可以将应用程序拆分成不同的模块，每个模块负责处理特定的事件，从而实现更好的模块化和解耦。

• 松耦合的组件通信： 组件之间不需要直接引用彼此，而是通过发布和监听事件来进行通信。这种松耦合的方式使得组件可以独立开发、测试和部署。

• 提高可维护性： 事件机制使得应用程序的各个部分更容易维护和扩展，因为你可以在不影响其他部分的情况下，更改和增加事件处理逻辑。

• 插件和扩展支持： 通过事件，可以实现插件和扩展的支持，允许第三方模块在应用程序中注册事件监听器，从而增加新的功能和行为。

• 状态通知和响应： 事件机制可用于通知应用程序中的状态变化，以便其他组件能够及时响应和处理。

• 异步处理： Spring Boot 支持异步事件处理，可以通过异步方式处理事件，提高应用程序的性能和响应能力。

• 动态性： 通过事件，可以实现动态注册和注销事件监听器，从而在运行时动态调整应用程序的行为。

2.1 定义事件类

定义一个事件类继承自ApplicationEvent

import org.springframework.context.ApplicationEvent;

public class MyEvent extends ApplicationEvent {

    private final String message;

    public MyEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

2.2 定义监听类

定义一个监听类，实现ApplicationListener接口

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyEventListener implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent event) {
        String message = event.getMessage();
        System.out.println("Received event message: " + message);
    }
}

2.3 触发事件

在适当的地方使用ApplicationEventPublisher触发事件

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private final ApplicationEventPublisher eventPublisher;

    @Autowired
    public MyService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }

    public void doSomethingAndPublishEvent(String message) {
        // 执行一些业务逻辑
        // ...

        // 触发事件
        eventPublisher.publishEvent(new MyEvent(this, message));
    }
}

2.4 编写事件的技巧

• 命名规范： 事件类的命名通常以Event结尾，监听器类的命名通常以EventLisner结尾，以便于识别；
  自定义事件数据：你可以在事件类中添加与事件相关的数据字段，以便监听器能够获取事件的详细信息。

• 多个监听器： 可以定义多个监听器监听同一个事件，它们会按照注册顺序依次被调用。

• 异步监听器： 可以使用 @Async 注解将监听器方法标记为异步，以提高性能。

• 事件层级： 你可以定义事件的继承关系，以实现更复杂的事件传递和处理逻辑。

• 条件触发： 可以通过条件判断，选择性地触发事件，例如只有在满足某些条件时才触发事件。

2.6 内置的事件

Spring中的事件

• ContextRefreshedEvent： ApplicationContext容器初始化或刷新时触发该事件。此处的初始化是指：所有的Bean被成功装载，后处理Bean被检测并激活，所有Singleton Bean 被预实例化，ApplicationContext容器已就绪可用；
• ContextStartedEvent： 当使用ConfigurableApplicationContext接口的start()方法启动ApplicationContext容器时触发该事件；
• ContextStoppedEvent： 当使用ConfigurableApplicationContext接口的stop()方法停止ApplicationContext容器时触发该事件。
• ContextClosedEvent： Spring容器关闭事件，在容器被真正销毁后才会触发，当使用ConfigurableApplicationContext接口的close()方法关闭ApplicationContext容器时触发该事件；
• ServletRequestHandledEvent：

Spring Boot中定义的事件

BootstrapContextClosedEvent

• pring Boot应用程序上下文关闭时触发。

• 通知内部启动上下文已关闭: 在Sring Boot应用程序启动过程中，会设计两个上下文，一个是外部的Web应用上下文，另一个是内部的Bootstrap上下文。此事件的作用是通知内部的上下文被关闭，这是整个应用程序关闭的最后阶段。

• 执行清理和资源释放： 在应用程序关闭时，可能需要进行一些清理工作，例如关闭数据库连接、释放资源、停止定时任务等，监听BootstrapContextCloesedEvent事件可以提供一个机会，在应用程序关闭前执行这些清理操作。

• 整理资源管理： 在应用程序的不同模块中可能存在共享的资源，通过监听BootstrapContextClosedEvent事件，你可以在资源不在需要时进行适当的释放，以避免资源泄露和不必要的消耗。

ExitCodeEvent
从ExitCodeGenerator定应用程序退出代码时触发该事件。

AlabilityChangeEvent
表示应用程序的可用性状态发生了变化，目的是为了帮助应用程序在运行时动态改变自身的可用性状态，以及提供给其他组件一个通知机制，以便应用程序的状态变化做出相应的处理。

• 动态改变应用程序的可用性状态： 在某些情况下，应用程序的可用性状态可能会在运行时发生变化，例如应用程序依赖的外部服务不可用、数据库连接中断等。通过发布AvailabilityChangeEvent事件，你可以通知应用程序的其他组件，以及Spring BootActuator断电，应用程序的可用性状态发生了变化。

• 实时监控和响应： 工作监听AvailabilityChangeEvent事件，你可以试试第监控应用程序的可用性状态，并根据状态的变化采取相应的戳烧，例如发送通知、记录日志、调整策略等。

• 与Spring Boot Actuator集成： Spring Boot Actuator是用于监控和管理Spring Boot应用程序的模块。与Actuator继承，可以使Actuator端点事实反应应用程序的可用性状态。

ParentContentAvaliableEvent
当父上下文可用时触发ApplicationEvent。

ApplicationContextInitializedEvent
这个时间在Spring应用上下文ApplicationContext初始化完成之后但在舒心之前被触发。但在Spring Boot中，这个时间可以用于执行一些在营应用程序上下文初始化时需要完成的操作。

1. 初始化前操作： 通过监听此事件，你可以在Spring应用上下文初始化完成后，但在实际刷新之前执行一些操作，例如加兹安外部配置、初始化日志记录、设置环境变量等。
2. 自定义初始化逻辑： 有时候，你可能需要再Sping上下文初始化时进行一些自定义的初始化逻辑，例如创还能自定义Bean、注册自定义属性等。这个时间提供了一个扩展带你，使你能够执行这些操作。

需要注意的是，ApplicationContextInitializedEvent 事件通常在 Spring Boot 应用程序的启动过程中发生，但具体的触发时机和监听器的执行顺序可能会受到其他因素的影响。

ApplicationEnviromentPreparedEvent

这个时间在应用程序上下文环境准备就绪、但在上下文创建爱你之前被触发。这个事件在Spring Boot启动过程的早起阶段发生，他允许你对应用程序的环境进行预处理。例如修改属性、添加属性源的。

1. 属性源的添加和修改： 通过监听此事件，你可以向应用程序的环境中添加或修改属性源，从而影响应用程序的属性配置。
2. 属性的预处理： 你可以在这个事件中对属性进行预处理，例如根据环境变量、配置文件等动态第设置属性的值。
3. 环境相关的初始化： 在应用程序上下文创还能之前，你可以进行一些与环境相关的初始化操作，例如初始化日志记录、配置数据库连接等。

示例

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationContextInitializedListener
        implements ApplicationListener<ApplicationContextInitializedEvent> {

    @Override
    public void onApplicationEvent(ApplicationContextInitializedEvent event) {
        System.out.println("ApplicationContext initialized.");
        // 执行初始化操作
    }
}

需要注意的是ApplicationEnviromentPrepareEvent事件在Spring Boot启动过程的早起阶段发生，它允许你再应用上下文创还能之前对环境进行操作。

ApplicationFailedEvent
这个时间在应用程序启动过程中出现严重错误导致应用程序无法正常启动时被触发，这个事件允许你再用用程序启动失败时执行也定的操作，例如记录错误日志、发送通知等。

1. 错误处理和日志记录： 通过监听此事件，你可以捕获应用程序启动过程中的异常，执行错误处理逻辑，例如记录详细的错误日志信息，以便后续的问题排查和分析。
2. 通知和报警： 你可以在这个时间中实现发送通知或报警的逻辑，以便及时第通知运维人员或开发团队应用程序启动失败的情况；
3. 释放资源和清理： 如果应用程序启动失败时需要进行资源释放或清理操作，可以在这儿事件中进行这些操作，以便面资源泄露或其他问题。

示例

import org.springframework.boot.context.event.ApplicationFailedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationFailedListener
        implements ApplicationListener<ApplicationFailedEvent> {

    @Override
    public void onApplicationEvent(ApplicationFailedEvent event) {
        // 获取失败的异常信息
        Throwable throwable = event.getException();

        // 记录错误日志或发送通知
        System.err.println("Application failed to start:");
        throwable.printStackTrace();

        // 执行清理操作（如果需要）
        // ...
    }
}

需要注意的是，ApplicationFailedEvent 事件在 Spring Boot 应用程序启动失败时触发，它提供了一个处理应用程序启动异常的机会，以便进行适当的错误处理和资源管理。

ApplicationPreparedEvent
这个时间在Spring应用程序上下文环境准备就绪，但在上下文刷新之前被触发，这个时间在Spring Boot启动过程的早起阶段发生，它允许你再应用程序上下文初始化后，在实际帅鑫之前执行一些操作。

1. 属性源的添加和修改： 通过监听此事件，你可以向应用程序的华景中添加或修改属性源，从而影响应用程序的属性配置。

2. 自定义初始化的逻辑： 你可以在这个时间中对属性进行预处理，例如根据环境变量、配置文件等动态第设置属性的值。

3. 环境相关的初始化： 在应用程序上下文创建之前，你可以进行一些与环境相关的初始化操作，例如初始化日志记录、配置数据库连接等。

示例

mport org.springframework.boot.context.event.ApplicationPreparedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationPreparedListener
        implements ApplicationListener<ApplicationPreparedEvent> {

    @Override
    public void onApplicationEvent(ApplicationPreparedEvent event) {
        // 获取应用程序上下文对象
        ConfigurableApplicationContext applicationContext = event.getApplicationContext();

        // 添加自定义属性源
        Map<String, Object> source = new HashMap<>();
        source.put("custom.property", "custom-value");
        applicationContext.getEnvironment().getPropertySources().addFirst(new MapPropertySource("custom-source", source));

        // 预处理属性
        String existingValue = applicationContext.getEnvironment().getProperty("existing.property");
        if (existingValue != null) {
            String modifiedValue = existingValue + "-modified";
            applicationContext.getEnvironment().getPropertySources().addLast(new MapPropertySource("modified-source",
                    Collections.singletonMap("existing.property", modifiedValue)));
        }
    }
}
在上面的示例中，MyApplicationPreparedListener 监听 ApplicationPreparedEvent 事件，在应用程序上下文准备就绪后，通过添加属性源和预处理属性来影响应用程序的属性配置。

需要注意的是，ApplicationPreparedEvent 事件在 Spring Boot 启动过程的早期阶段发生，它允许你在应用程序上下文初始化后，但在实际刷新之前对环境进行操作。如果有其他关于 Spring Boot 中的事件的问题，也请随时提问。

需要注意的是，ApplicationPreparedEvent 事件在 Spring Boot 启动过程的早期阶段发生，它允许你在应用程序上下文初始化后，但在实际刷新之前对环境进行操作。

ApplicationReadyEvent
这个时间在Spring应用程序已经完全启动且应用程序上下文刷新之后被触发。这个事件表示应用程序已经准备好接受请求并处理业务逻辑。此事件的作用是在应用程序启动完成后执行一些操作，例如执行初始化任务、通知用户应用程序已经可用等。

1. 应用程序启动完成通知： 通过监听此事件，你可以在应用程序完全启动并准备好接受请求是，向用户或运维人员发送通知，告知应用程序已经可用。
2. 执行初始化任务： 在应用程序完全启动后，你可能需要执行一些初始化任务，例如加载出示数据、预热缓存、启动定时任务等，以帮助用户了解应用程序的状态。
3. 打印启动信息： 你可以使用ApplicationReadyEvent事件来打印启动信息，例如显示应用程序的版本号、环境配置等，以帮助用户了解应用程序的状态。

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationReadyListener
        implements ApplicationListener<ApplicationReadyEvent> {

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        // 执行初始化任务，例如加载初始数据、启动定时任务等
        System.out.println("Application is ready and fully started.");
    }
}

需要注意的是，ApplicationReadyEvent 事件表示应用程序已经准备好接受请求和处理业务逻辑，它是在整个启动过程的最后阶段触发的。

ApplicationStartedEvent
在Spring程序应用上下文刷新之后被触发，表示应用程序已经开始运行. 这个事件发生在ApplicationReady事件之前，标示着业务逻辑已经准备好处理业务逻辑，但可能还没有完全接手请求。

• 应用程序启动通知： 通过监听该事件，你可以在应用程序开始运行后，向用户或运维人员发送通知，告知应用程序已经开始运行。
• 执行启动后通知： 在运行程序开始运行后，你可能需要执行一些任务，如打印日志、加载配置、初始化资源等。这个事件提供了一些合适的时间来执行这些操作。
• 与外部系统交互： 你可以在ApplicationStartedEvent事件中与外部系统进行交互，例如注册应用程序到服务注册中心、初始化数据库连接等。

import org.springframework.boot.context.event.ApplicationStartedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationStartedListener
        implements ApplicationListener<ApplicationStartedEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartedEvent event) {
        // 执行启动后任务，例如打印日志、加载配置、初始化资源等
        System.out.println("Application has started.");
    }
}

在上面的示例中，MyApplicationStartedListener 监听 ApplicationStartedEvent 事件，在应用程序开始运行后执行启动后任务。

需要注意的是，ApplicationStartedEvent 事件表示应用程序已经开始运行，但可能还没有完全准备好接受请求。它是在应用程序上下文刷新之后触发的，但在整个启动过程的早期阶段。

ApplicationStartingEvent
在Spring Boot应用程序启动但尚未创建应用程序上下文之前触发，发生在整个启动过程早起阶段。允许你在应用程序开始启动之前执行一些操作。例如修改应用程序属性、修改属性源等。

1. 修改属性 通过监听该事件，可以在应用程序启动之前修改应用程序属性，从而影响应用程序的配置。

2. 添加属性源 你可以在这个事件中向应用程序的环境中添加属性源，以增加属性的来源，例如从外部配置文件中加载属性；

3. 初始化日志记录 在应用程序开始启动之前，你可以进行一些初始化日志记录的操作，例如设置日志级别，配置日志输出目标等。

import org.springframework.boot.context.event.ApplicationStartingEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationStartingListener
        implements ApplicationListener<ApplicationStartingEvent> {

    @Override
    public void onApplicationEvent(ApplicationStartingEvent event) {
        // 修改属性或添加属性源
        event.getSpringApplication().setDefaultProperties(Collections.singletonMap("custom.property", "custom-value"));

        // 初始化日志记录
        // ...
    }
}

在上面的示例中，MyApplicationStartingListener 监听 ApplicationStartingEvent 事件，在应用程序启动之前修改属性和初始化日志记录。

需要注意的是，ApplicationStartingEvent 事件发生在 Spring Boot 应用程序开始启动但尚未创建应用程序上下文之前，它是整个启动过程的最早阶段。

WebServerInitializedEvent
在WEB服务器初始化完成后被触发，当 Spring Boot 应用程序启动并成功初始化了 Web 服务器（如内嵌的 Tomcat、Jetty 等），WebServerInitializedEvent 事件就会被发布。

1. 获取WEB服务器信息 通过监听该事件，你可以获取已经初始化的web服务器信息，如端口号、主机名等；
2. 执行WEB服务器相关操作 你可以在这个事件中执行与 Web 服务器相关的操作，例如注册自定义的 Servlet、Filter、Listener，设置连接超时，配置 SSL 等。
3. 与Spring Boot Actuator集成 WebServerInitializedEvent事件与 Spring Boot Actuator 集成，可以使 Actuator 端点能够提供关于 Web 服务器的信息，例如端口号、上下文路径等。

import org.springframework.boot.web.context.WebServerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyWebServerInitializedListener
        implements ApplicationListener<WebServerInitializedEvent> {

    @Override
    public void onApplicationEvent(WebServerInitializedEvent event) {
        // 获取 Web 服务器的信息
        int port = event.getWebServer().getPort();
        String host = event.getWebServer().getHost();

        // 执行 Web 服务器相关操作，例如注册自定义的 Servlet、配置 SSL 等
        // ...
    }
}

在上面的示例中，MyWebServerInitializedListener 监听 WebServerInitializedEvent 事件，在 Web 服务器初始化完成后获取服务器信息并执行相关操作。

需要注意的是，WebServerInitializedEvent 事件在 Spring Boot 应用程序启动后，成功初始化了 Web 服务器时触发。它允许你在 Web 服务器就绪后执行一些与 Web 服务器相关的操作。

ReactiveWebServerInitializedEvent
在响应式 Web 服务器初始化完成后被触发。当 Spring Boot 应用程序启动并成功初始化了响应式 Web 服务器（如内嵌的 Netty、Undertow 等），ReactiveWebServerInitializedEvent 事件就会被发布。

1. 获取响应式 Web 服务器信息：通过监听 ReactiveWebServerInitializedEvent 事件，你可以获取已初始化的响应式 Web 服务器的信息，例如端口号、主机名等。

2. 执行响应式 Web 服务器相关操作：你可以在这个事件中执行与响应式 Web 服务器相关的操作，例如注册自定义的 Handler、Filter，配置连接池，配置 SSL 等。

3. 与 Spring Boot Actuator 集成：ReactiveWebServerInitializedEvent 事件与 Spring Boot Actuator 集成，可以使 Actuator 端点能够提供关于响应式 Web 服务器的信息，例如端口号、上下文路径等。

示例

import org.springframework.boot.web.reactive.context.ReactiveWebServerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyReactiveWebServerInitializedListener
        implements ApplicationListener<ReactiveWebServerInitializedEvent> {

    @Override
    public void onApplicationEvent(ReactiveWebServerInitializedEvent event) {
        // 获取响应式 Web 服务器的信息
        int port = event.getWebServer().getPort();
        String host = event.getWebServer().getHost();

        // 执行响应式 Web 服务器相关操作，例如注册自定义的 Handler、配置 SSL 等
        // ...
    }
}

在上面的示例中，MyReactiveWebServerInitializedListener 监听 ReactiveWebServerInitializedEvent 事件，在响应式 Web 服务器初始化完成后获取服务器信息并执行相关操作。

需要注意的是，ReactiveWebServerInitializedEvent 事件在 Spring Boot 应用程序启动后，成功初始化了响应式 Web 服务器时触发。它允许你在响应式 Web 服务器就绪后执行一些与服务器相关的操作。

ServletWebServerInitializedEvent
在 Servlet Web 服务器（如内嵌的 Tomcat、Jetty 等）初始化完成后被触发。当 Spring Boot 应用程序启动并成功初始化了 Servlet Web 服务器时，ServletWebServerInitializedEvent 事件就会被发布。

1. 获取 Servlet Web 服务器信息：通过监听 ServletWebServerInitializedEvent 事件，你可以获取已初始化的 Servlet Web 服务器的信息，例如端口号、主机名等。

2. 执行 Servlet Web 服务器相关操作：你可以在这个事件中执行与 Servlet Web 服务器相关的操作，例如注册自定义的 Servlet、Filter、Listener，配置连接池，配置 SSL 等。

3. 与 Spring Boot Actuator 集成：ServletWebServerInitializedEvent 事件与 Spring Boot Actuator 集成，可以使 Actuator 端点能够提供关于 Servlet Web 服务器的信息，例如端口号、上下文路径等。

示例

import org.springframework.boot.web.servlet.context.ServletWebServerInitializedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyServletWebServerInitializedListener
        implements ApplicationListener<ServletWebServerInitializedEvent> {

    @Override
    public void onApplicationEvent(ServletWebServerInitializedEvent event) {
        // 获取 Servlet Web 服务器的信息
        int port = event.getWebServer().getPort();
        String host = event.getWebServer().getHost();

        // 执行 Servlet Web 服务器相关操作，例如注册自定义的 Servlet、配置 SSL 等
        // ...
    }
}

在上面的示例中，MyServletWebServerInitializedListener 监听 ServletWebServerInitializedEvent 事件，在 Servlet Web 服务器初始化完成后获取服务器信息并执行相关操作。

需要注意的是，ServletWebServerInitializedEvent 事件在 Spring Boot 应用程序启动后，成功初始化了 Servlet Web 服务器时触发。