Event-Driven Spring：让你的应用更智能

介绍

事件是 Spring 框架中一个常被忽视的功能，但它非常有用。与 Spring 中的其他功能一样，事件发布是由 ApplicationContext 默认提供的功能，允许我们在应用中使用发布-订阅模式来响应不同的事件。

自定义事件

Spring 允许我们创建和发布自定义事件，默认情况下，这些事件的发布是 同步 的。

一个简单的应用程序事件

首先，我们可以通过继承 ApplicationEvent 类来定义一个简单的自定义事件：

public class CustomSpringEvent extends ApplicationEvent {
    private String message;

    public CustomSpringEvent(Object source, String message) {
        super(source);
        this.message = message;
    }
    
    public String getMessage() {
        return message;
    }
}

这个自定义事件类 CustomSpringEvent 继承了 ApplicationEvent，并包含一个消息字段，用于在事件发布时传递数据。

事件发布者

接下来，我们需要创建一个事件发布者，它负责构造自定义事件对象，并将事件发布出去。发布者可以通过注入 ApplicationEventPublisher 来发布事件：

@Component
public class CustomSpringEventPublisher {
    @Autowired
    private ApplicationEventPublisher applicationEventPublisher;

    public void publishCustomEvent(final String message) {
        System.out.println("Publishing custom event.");
        CustomSpringEvent customSpringEvent = new CustomSpringEvent(this, message);
        applicationEventPublisher.publishEvent(customSpringEvent);
    }
}

在这个发布者类中，publishCustomEvent 方法构造了一个新的 CustomSpringEvent 实例，并通过 ApplicationEventPublisher 将事件发布出去。

从 Spring 4.2 开始，ApplicationEventPublisher 接口支持直接发布任何对象作为事件。因此，我们不再强制要求事件必须继承 ApplicationEvent 类。

事件监听器

事件监听器的角色是处理接收到的事件。我们可以通过实现 ApplicationListener 接口来定义事件监听器，并处理特定类型的事件：

@Component
public class CustomSpringEventListener implements ApplicationListener<CustomSpringEvent> {
    @Override
    public void onApplicationEvent(CustomSpringEvent event) {
        System.out.println("Received spring custom event - " + event.getMessage());
    }
}

当事件发布后，所有监听该事件的组件都会接收到通知并执行相应的处理逻辑。

创建异步事件

有时，同步处理事件可能不是最佳选择，尤其当事件处理逻辑较为复杂或耗时时。此时，我们可以让事件处理异步进行，以避免阻塞主线程。

使用 ApplicationEventMulticaster

为了实现异步事件处理，我们可以在配置类中创建一个 ApplicationEventMulticaster bean，并配置一个执行器（如 SimpleAsyncTaskExecutor）来处理事件：

@Configuration
public class AsynchronousSpringEventsConfig {
    @Bean(name = "applicationEventMulticaster")
    public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
        SimpleApplicationEventMulticaster eventMulticaster =
          new SimpleApplicationEventMulticaster();
        
        eventMulticaster.setTaskExecutor(new SimpleAsyncTaskExecutor());
        return eventMulticaster;
    }
}

通过这样的配置，事件监听器将会在单独的线程中异步处理事件，而不会阻塞主线程。

使用 @Async

除了使用 ApplicationEventMulticaster 来配置异步事件处理，我们还可以直接在事件监听方法上添加 @Async 注解来实现异步处理：

@EventListener
@Async
public void handleAsyncEvent(CustomSpringEvent event) {
    System.out.println("Handling event asynchronously: " + event.getMessage());
}

这种方式使得我们可以在处理特定事件时选择是否异步处理，而其他事件仍然可以保持同步。

现有框架事件

Spring 提供了一些内置的事件，它们与应用程序的生命周期密切相关。你可以监听这些事件，并在特定的时机执行自定义逻辑。

以下是一个示例，展示如何监听 Spring 上下文刷新的事件：

public class ContextRefreshedListener 
  implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent cse) {
        System.out.println("Handling context refreshed event.");
    }
}

Spring 默认提供的事件

注解驱动的事件监听器

从 Spring 4.2 开始，我们可以通过 @EventListener 注解来定义事件监听器，而不再需要实现 ApplicationListener 接口：

@Component
public class AnnotationDrivenEventListener {
    @EventListener
    public void handleContextStart(ContextStartedEvent cse) {
        System.out.println("Handling context started event.");
    }
}

如上所示，使用 @EventListener 注解可以方便地指定监听的事件类型，无需显式实现接口。

默认情况下，事件监听器是同步的。如果需要异步处理事件，可以在监听方法上加上 @Async 注解，并确保应用启用了 @EnableAsync 支持。

泛型支持

Spring 也支持使用泛型类型来分发事件，这样可以使事件的类型更具灵活性。

一个泛型应用事件

我们首先创建一个泛型事件类。在这个例子中，事件类包含任何内容以及一个表示成功与否的状态指示符：

public class GenericSpringEvent<T> {
    private T what;
    protected boolean success;

    public GenericSpringEvent(T what, boolean success) {
        this.what = what;
        this.success = success;
    }
    // ... 标准的 getter 方法
}

注意 GenericSpringEvent 和 CustomSpringEvent 的区别。现在，我们有了更大的灵活性，可以发布任何类型的事件，而且不再要求必须继承 ApplicationEvent 类。

事件监听器

接下来，我们创建这个事件的监听器。

我们可以像以前一样，通过实现 ApplicationListener 接口来定义监听器：

@Component
public class GenericSpringEventListener implements ApplicationListener<GenericSpringEvent<String>> {
    @Override
    public void onApplicationEvent(@NonNull GenericSpringEvent<String> event) {
        System.out.println("Received spring generic event - " + event.getWhat());
    }
}

但这个定义有个问题：它要求我们必须继承 GenericSpringEvent 类为 ApplicationEvent。为了更灵活起见，接下来我们使用之前提到的@EventListener注解驱动事件监听器。

我们还可以通过在 @EventListener 注解中定义一个条件表达式来使事件监听器具有条件触发的功能。在这个例子中，只有 GenericSpringEvent 类型且 success 为 true 的事件才会触发事件处理：

@Component
public class AnnotationDrivenEventListener {
    @EventListener(condition = "#event.success")
    public void handleSuccessful(GenericSpringEvent<String> event) {
        System.out.println("Handling generic event (conditional).");
    }
}

SpEL（Spring 表达式语言）是一种强大的表达式语言，能够在注解中执行复杂的条件判断，关于它的详细介绍可以参考其他教程。

事件发布者

事件发布者与泛型事件

在使用 Spring 事件发布机制时，由于 Java 泛型的 类型擦除（即编译时泛型类型会被去除），我们不能直接发布像 GenericSpringEvent<String> 这样的泛型事件，因为泛型类型会在运行时丢失。所以，我们可以使用 一个通用的事件类型（例如 GenericStringSpringEvent），来解决这个问题。这种事件类型可以携带一个类型参数，但不依赖于 Java 泛型系统的类型信息。

使用 @EventListener 方法的返回值发布事件

另外，Spring 提供了一种替代的事件发布方式：如果你在 @EventListener 注解的方法中返回了一个非 null 的值，Spring 会自动将这个值作为新的事件发布出去。这意味着，在处理一个事件时，你不仅仅是消费事件，还可以通过返回一个新的事件来触发更多的处理。

@EventListener
public Collection<SomeEvent> handleEvent(SomeEvent event) {
    // 处理事件并返回多个新的事件
    return Arrays.asList(new AnotherEvent(), new MoreEvents());
}

事务绑定的事件

从 Spring 4.2 开始，框架提供了一个新的 @TransactionalEventListener 注解，它是 @EventListener 的扩展，允许将事件监听器绑定到事务的某个阶段。

监听器可以绑定到以下四个事务阶段之一：

• AFTER_COMMIT（默认）— 在事务成功提交后触发事件。
• AFTER_ROLLBACK — 如果事务回滚，则触发事件。
• AFTER_COMPLETION — 事务完成后触发事件，是 AFTER_COMMIT 和 AFTER_ROLLBACK 的别名。
• BEFORE_COMMIT — 在事务提交之前触发事件。

默认情况下，@TransactionalEventListener 仅在 CustomSpringEvent 事件被发布到事务中且该事务成功完成后才会触发：

@TransactionalEventListener
public void handleCustom(CustomSpringEvent event) {
    System.out.println("Handling event only when a transaction successfully completes.");
}

需要注意的是，与普通的 @EventListener 方法不同，@TransactionalEventListener 并不会通过 ApplicationEventMulticaster 分发事件。相反，它会通过 TransactionSynchronizationManager#registerSynchronization 注册一个事务同步回调，在指定的事务阶段处理事件。

因此，@TransactionalEventListener 方法会在发布事件的同一个线程中执行，而不受 ApplicationEventMulticaster 中所配置的 TaskExecutor 影响。

如何使 @TransactionalEventListener 异步处理事件？

当我们希望在事务完成后异步处理事件时，可以结合使用 @Async 和 @TransactionalEventListener 注解。例如：

@Async
@TransactionalEventListener
void handleCustom(CustomSpringEvent event) { 
    System.out.println("Handling event only when a transaction successfully completes.");
}

在上面的例子中，我们将 @Async 和 @TransactionalEventListener 注解结合使用，确保当原事务成功完成后，handleCustom() 方法会在一个独立的线程中异步执行。

然而，需要谨慎使用这种方式。因为 Spring 会将事务绑定到当前线程，而当监听器在另一个线程中运行时（由于 @Async），它将无法访问原始事务上下文。这意味着如果我们的事件处理依赖于原始事务的上下文（例如延迟加载的实体、共享的数据库状态或事务回滚逻辑），就不应该在 @TransactionalEventListener 中使用 @Async 注解。

当然，当我们使用 @Async 时，还需要确保在应用程序中启用了 @EnableAsync 支持。