您现在的位置是：首页 >学无止境 >SpringBoot - 事件机制使用详解（ApplicationEvent、ApplicationListener）网站首页学无止境

SpringBoot - 事件机制使用详解（ApplicationEvent、ApplicationListener）

珂-瑞 2023-06-12 20:00:03
简介SpringBoot - 事件机制使用详解（ApplicationEvent、ApplicationListener）

Spring 事件机制使用观察者模式来传递事件和消息。我们可以使用 ApplicationEvent 类来发布事件，然后使用 ApplicationListener 接口来监听事件。当事件发生时，所有注册的 ApplicationListener 都会得到通知。事件用于在松散耦合的组件之间交换信息。由于发布者和订阅者之间没有直接耦合，因此可以在不影响发布者的情况下修改订阅者，反之亦然。下面通过样例样式事件机制的使用。

1，基本用法

（1）首先我们创建一个自定义事件类 MyEvent，该类继承自 ApplicationEvent 类。

// 自定义事件类
public class MyEvent extends ApplicationEvent {
 
  private String message;
 
  public MyEvent(Object source, String message) {
    super(source);
    this.message = message;
  }
 
  public String getMessage() {
    return message;
  }
}

（2）接着定义一个事件监听器类 MyEventListener，该类实现 ApplicationListener 接口，并注册为 Spring 的组件。只要监听器对象在 Spring 应用程序上下文中注册，它就会接收事件。当 Spring 路由一个事件时，它使用监听器的签名来确定它是否与事件匹配。

// 事件监听器
@Component
public class MyEventListener implements ApplicationListener<MyEvent> {
  // 事件发生时执行
  @Override
  public void onApplicationEvent(MyEvent event) {
    System.out.println("接收到事件: " + event.getMessage());
    // 模拟事件处理
    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
}

（3）最后我们可以使用 ApplicationContext 的 publishEvent 方法来发布事件。

@RestController
public class HelloController {
  @Autowired
  private ApplicationContext context;
 
  @GetMapping("/hello")
  public void hello() {
    System.out.println("准备发送事件");
    context.publishEvent(new MyEvent(this, "welcome to hangge.com"));
    System.out.println("事件发送完毕");
  }
}

（4）启动项目测试一下，我们访问 /hello 接口时，控制台输出如下，说明事件机制运行成功。

  • 注意：spring 事件是同步的，这意味着发布者线程将阻塞，直到所有监听都完成对事件的处理为止。

在这里插入图片描述

2，使用 @EventListener 监听事件

（1）上面样例我们通过实现 ApplicationListener 接口来定义监听器。从 Spring 4.1 开始，可以使用 @EventListener 注解的方法，以自动注册与该方法签名匹配的 ApplicationListener（监听器类同样需要注册为 Spring 的组件）。下面代码的效果同上面是一样的：

// 事件监听器
@Component
public class MyEventListener{
  // 使用注解实现事件监听
  @EventListener
  public void onApplicationEvent(MyEvent event) {
    System.out.println("接收到事件: " + event.getMessage());
    // 模拟事件处理
    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
}

（2）我们可以使用 @EventListener 注解的 value 属性来指定我们要监听的事件类型。比如下面代码来监听 MyEvent 类型的事件：
如果需要同时指定多个事件类型可以这么写：@EventListener（{MyEvent.class，AnotherEvent.class}）。

// 事件监听器
@Component
public class MyEventListener{
  // 使用注解实现事件监听
  @EventListener(MyEvent.class)
  public void onApplicationEvent(MyEvent event) {
    System.out.println("接收到事件: " + event.getMessage());
  }
}

（3）我们可以使用 @EventListener 注解的 condition 属性来指定事件监听器的执行条件。在下面的代码中，#event.message == ‘hello’ 是一个 SpEL 表达式，表示当事件的 message 属性值为 hello 时，事件监听器才会被执行。
（1）SpEL (Spring Expression Language) 是一种强大的表达式语言，用于在运行时执行各种表达式。我们可以使用 SpEL 表达式来访问对象的属性、调用对象的方法、执行运算等。
（2）SpEL 表达式语法如下：
属性访问：使用 . 操作符访问对象的属性，例如，object.property 表示访问对象 object 的属性 property。
方法调用：使用 () 操作符调用对象的方法，例如，object.method() 表示调用对象 object 的方法 method。
运算符：SpEL 支持常用的运算符，包括算术运算符、关系运算符、逻辑运算符等。
（3）SpEL 表达式还支持一些特殊的操作符和函数，如下所示：
? 操作符：三目运算符，形如 (condition ? then : else)，表示当 condition 为真时返回 then，否则返回 else。
instanceof 操作符：用于判断对象是否为某个类型，形如 object instanceof T，表示对象 object 是否为类型 T。
t() 函数：将对象转换为给定的类型，形如 t(T)，表示将对象转换为类型 T。
elvis 操作符：用于判断对象是否为空，形如 object ?: defaultValue，表示如果对象不为空则返回对象，否则返回默认值。

// 事件监听器
@Component
public class MyEventListener{
  // 使用注解实现事件监听
  @EventListener(condition = "#event.message == 'hello'")
  public void onApplicationEvent(MyEvent event) {
    System.out.println("接收到事件: " + event.getMessage());
  }
}

（4）对于使用 @EventListener 注解并定义为具有返回类型的方法，Spring 会将结果作为新事件发布。在下面的示例中，第一个方法返回的 AnotherEvent 将被发布，然后由第二个方法处理。

// 事件监听器
@Component
public class MyEventListener{
  @EventListener
  public AnotherEvent listener1(MyEvent event) {
    // 处理事件
    System.out.println("事件监听器 1 接收到事件: " + event.getMessage());
    return new AnotherEvent(this, "转发" + event.getMessage());
  }
 
  @EventListener
  public void listener2(AnotherEvent event) {
    // 处理事件
    System.out.println("事件监听器 2 接收到事件: " + event.getMessage());
  }
}

3，使用 @Order 指定优先级

（1）当 Spring 发布一个事件时，会调用所有能处理这个事件的事件监听器方法。如果你有多个事件监听器方法，那么 Spring 会依次调用这些方法。比如下面样例，当发布一个 MyEvent 事件时，Spring 会依次调用这两个方法。

// 事件监听器
@Component
public class MyEventListener{
  @EventListener
  public void listener1(MyEvent event) {
    // 处理事件
    System.out.println("事件监听器 1 接收到事件: " + event.getMessage());
  }
 
  @EventListener
  public void listener2(MyEvent event) {
    // 处理事件
    System.out.println("事件监听器 2 接收到事件: " + event.getMessage());
  }
}

在这里插入图片描述

（2）我们可以使用 @Order 注解来指定事件监听器方法的优先级。@Order 注解可以标注在类上或方法上，表示这个类或方法的优先级。数值越小，优先级越高。

// 事件监听器
@Component
public class MyEventListener{
  @Order(2)
  @EventListener
  public void listener1(MyEvent event) {
    // 处理事件
    System.out.println("事件监听器 1 接收到事件: " + event.getMessage());
  }
 
  @Order(1)
  @EventListener
  public void listener2(MyEvent event) {
    // 处理事件
    System.out.println("事件监听器 2 接收到事件: " + event.getMessage());
  }
}

在这里插入图片描述

4，使用 @Async 实现异步事件监听

（1）从第一个样例运行结果可以看出默认 spring 事件是同步的，这意味着发布者线程将阻塞，直到所有侦听器都完成对事件的处理为止。我们可以使用 @Async 注解来标注一个事件监听器方法，表示这个方法是一个异步方法，应该在独立的线程中执行。

// 事件监听器
@Component
public class MyEventListener{
  // 使用注解实现事件监听
  @Async
  @EventListener
  public void onApplicationEvent(MyEvent event) {
    System.out.println("接收到事件: " + event.getMessage());
    // 模拟事件处理
    try {
      Thread.sleep(3000);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
  }
}

（2）同时我们还需要在配置类（@Configuration 类之一或 @SpringBootApplication 类）中启用异步处理，才能使用 @Async 注解。

@Configuration
@EnableAsync
public class MyConfig {
    // 配置类
}

（3）最后测试一下，可看到实现了异步事件监听：
在这里插入图片描述

附：Spring Boot 内置的 Application Event

（1）Spring Boot 中包含了一些与 SpringApplication 生命周期相关的内置 Application Event，包括：

  • ApplicationStartingEvent：在 Spring Boot 应用程序启动之前发布。
  • ApplicationEnvironmentPreparedEvent：在 Spring Boot 应用程序的环境已经准备好，但正在创建 Application Context 上下文之前发布。
  • ApplicationContextInitializedEvent：当 Spring Boot 应用程序 Application Context 上下文准备就绪并且调用
  • ApplicationContextInitializers，但尚未加载 bean 定义时发布。
  • ApplicationPreparedEvent：在 Spring Boot 应用程序的 Application Context 上下文已经创建，但尚未刷新之前发布。
  • ApplicationStartedEvent：在 Spring Boot 应用程序的 Application Context 上下文已经刷新，但尚未启动之前发布。
  • ApplicationReadyEvent：在 Spring Boot 应用程序已经启动并准备接受请求之后发布。
  • ApplicationFailedEvent：在 Spring Boot 应用程序启动失败时发布。

（2）假设我们需要监听 ApplicationStartingEvent，则首先定义一个监听器类：

// 事件监听器
public class MyEventListener implements ApplicationListener<ApplicationStartingEvent> {
  // 事件发生时执行
  @Override
  public void onApplicationEvent(ApplicationStartingEvent event) {
    // 处理事件
    System.out.println("应用程序将要启动");
  }
}

（3）由于该事件实际上是在 Application Context 创建前触发的，这时的 Bean 是不能被加载的。所以我们不能在这个监听器类上中使用 @Component 注册监听器，只能通过 SpringApplication 注册监听器。我们对项目启动类做如下修改：
注意：对于ApplicationStartedEvent、ApplicationReadyEvent、ApplicationFailedEvent 这些在 Application Context上下文已经创建完毕之后，所以可以直接使用 @Component 注册，不需要下面这个步骤。

@SpringBootApplication
public class RmiserverApplication {
 
  public static void main(String[] args) {
    SpringApplication app = new SpringApplication(RmiserverApplication.class);
    app.addListeners(new MyEventListener()); //注册监听器
    app.run(args);
  }
}

或者也可以使用使用 SpringApplicationBuilder 注册监听器：

@SpringBootApplication
public class RmiserverApplication {
 
  public static void main(String[] args) {
    new SpringApplicationBuilder().sources(RmiserverApplication.class)
            .listeners(new MyEventListener()) //注册监听器
            .run(args);
  }
}

（4）启动项目，可以看到控制台输出如下：
在这里插入图片描述

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐