环境：Spring5.3.23

1. 简介

Spring事件机制是一种用于处理系统内部或者外部事件的机制，它是Spring框架的一部分。事件机制基于监听者设计模式实现，包括事件、发布器和监听器三个主要部分。

在Spring中，事件是主体，发布器负责发布事件，监听器负责处理事件。事件对象封装了事件源对象和事件相关信息，用于在事件源和监听器之间传递信息。发布器通过注入事件发布者实现，使用事件发布者发布事件。监听器通过实现ApplicationListener接口来定义，用于对事件进行处理。

Spring容器提供了事件管理机制，内部很多节点都会发布事件，也支持自定义事件。在Spring Boot中，你可以使用ApplicationEventPublisher接口来发布事件，通过继承ApplicationEvent抽象类来定义事件对象，通过实现ApplicationListener接口来定义事件监听器。

总之，Spring事件机制是一个非常有用的工具，可以帮助你更好地管理和处理系统中的事件。

2. 事件发布及监听

创建并发布自己的自定义事件。通过ApplicationEvent

static class OrderEvent extends ApplicationEvent {
  private Order order ;
  public OrderEvent(Object source, Order order) {
    super(source) ;
    this.order = order ;
  }
  public Order getOrder() {
    return this.order;
  }
}

要接收自定义 ApplicationEvent，可以创建一个实现 ApplicationListener 的类，并将其注册为 Spring Bean。

static class OrderListener implements ApplicationListener {
  @Override
  public void onApplicationEvent(OrderEvent event) {
    System.out.printf("监听到定义事件：%s", event.getOrder().toString()) ;
  }
}

要发布自定义 ApplicationEvent，调用 ApplicationEventPublisher 上的 publishEvent() 方法。通常，可以通过创建一个实现 ApplicationEventPublisherAware 的类并将其注册为 Spring Bean 来实现：

static class OrderService implements ApplicationEventPublisherAware {
  private ApplicationEventPublisher eventPublisher ;
  @Override
  public void setApplicationEventPublisher(ApplicationEventPublisher eventPublisher) {
    this.eventPublisher = eventPublisher ;
  }
  public void save(Order order) {
    this.eventPublisher.publishEvent(new OrderEvent("create oder event", new Order()));
  }
}

基于注解方式实现事件监听

你可以使用 @EventListener 注解在任意Bean 的任何方法上注册事件监听器。示例如下：

static class MyEventListener {
    
  @EventListener
  public void receiveOrderEvent(OrderEvent event) {
    System.out.printf("监听到定义事件：%s", event.getOrder().toString()) ;
  }
  
}

通过一个注解，实现了事件的监听，在该方法中指定了要监听的事件类型。

如果你的方法需要监听多个事件，或者你想定义一个不带任何参数的方法，也可以在注解中指定事件类型。示例如下：

@EventListener({OrderEvent.class, UserEvent.class})
public void receiveOrderEvent() {
  System.out.printf("监听到定义事") ;
}

这里指明了只监听OrderEvent, UserEvent两个事件。

也可以直接通过ApplicationEvent携带参数，这样可以通过判断处理不同的事件类型，示例如下：

@EventListener({OrderEvent.class, UserEvent.class})
public void receiveOrderEvent(ApplicationEvent event) {
  System.out.printf("监听到定义事件：%s", event.getSource()) ;
}

我们还可以通过SpEL表达式过滤事件，示例如下：

// User对象
static class User {
  private Integer type ;
  public User(Integer type) {
    this.type = type ;
  }
}
// UserEvent事件对象
static class UserEvent extends ApplicationEvent {
  private User user ;
  public UserEvent(Object source, User user) {
    super(source) ;
    this.user = user ;
  }
  public User getUser() {
    return user;
  }
} 
// 事件监听; 过滤只有User对象的type属性为1时才会触发事件
@EventListener(condition = "#event.user.type == 1")
public void receiveOrderEvent(UserEvent event) {
  System.out.printf("监听到定义事件：%s", event.getUser()) ;
}

3. 异步事件监听

异步方式1：

如果想让某个监听器异步处理事件，可以通过 @Async 注解支持，示例如下：

@EventListener
@Async
public void receiveOrderEvent(UserEvent event) {
  System.out.printf("%s - 监听到定义事件：%s", Thread.currentThread().getName(), event.getUser()) ;
}

执行结果：

SimpleAsyncTaskExecutor-1 - 监听到定义事件：com.pack.main.events.EventMain$User@abb3dc

异步方式2：

自定义一个事件发布器

@Bean
public SimpleApplicationEventMulticaster applicationEventMulticaster() {
  SimpleApplicationEventMulticaster applicationEventMulticaster = new SimpleApplicationEventMulticaster();
  applicationEventMulticaster.setTaskExecutor(Executors.newSingleThreadExecutor()) ;
  return applicationEventMulticaster ;
}

有个该事件发布器，容器在初始化时会先从容器中查找注册的自定义发布器，源码如下：

protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // 判断容器中是否有beanName = applicationEventMulticaster 的Bean
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
      this.applicationEventMulticaster =
          beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    } else {
      // 如果不存在则注册一个默认的，该默认的将使用默认的当前执行线程执行
      this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
      beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
  }

执行结果：

pool-1-thread-1 - 监听到定义事件：com.pack.main.events.EventMain$User@50f8a6

异步事件注意事项：

1. 如果异步事件监听器抛出异常，它不会传播给调用者。对于使用@Async的可以参考 AsyncUncaughtExceptionHandler。
2. 异步事件监听器方法不能通过返回值来发布后续事件。如果需要将另一个事件作为处理结果发布，请注入 ApplicationEventPublisher 以手动发布事件。

4. 事件监听顺序

如果需要在调用一个监听器之前调用另一个监听器，可以在方法声明中添加 @Order 注解，示例如下：

@EventListener
@Order(1)
public void receiveOrderEvent1(UserEvent event) {
  System.out.printf("%s - 监听到定义事件 - 1：%s%n", Thread.currentThread().getName(), event.getUser()) ;
}
@EventListener
@Order(0)
public void receiveOrderEvent2(UserEvent event) {
  System.out.printf("%s - 监听到定义事件 - 2：%s%n", Thread.currentThread().getName(), event.getUser()) ;
}

@Order中指定的值越小优先级越高，执行结果如下：

main - 监听到定义事件 - 2：com.pack.main.events.EventMain$User@96bacf
main - 监听到定义事件 - 1：com.pack.main.events.EventMain$User@96bacf

完毕！！！