科普文：软件架构Spring系列之【Spring事件机制ApplicationEvent】

于 2025-06-30 18:27:23 发布
阅读量963 收藏 17
点赞数 29
CC 4.0 BY-SA版权
分类专栏： 软件架构 Spring 业务场景 文章标签： spring java 后端 事件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Rookie_CEO/article/details/149028394

概叙

科普文：软件架构Spring系列之【状态机：Spring Statemachine】-CSDN博客

科普文：软件架构Spring系列之【Spring Statemachine状态机示例】-CSDN博客

科普文：软件架构Spring系列之【Spring状态机的设计模式：状态模式（State Pattern）】-CSDN博客

状态机

状态机是一种模型，用于描述对象在其生命周期中可能经历的多种状态以及在这些状态之间转换的规则。在Spring框架中，你可以使用Spring State Machine库来实现状态机。这个库提供了丰富的API来定义状态、事件、转换以及状态机的行为。

状态机的应用场景：

  • 工作流管理

  • 订单处理流程

  • 用户权限管理

事件

事件是系统中的一个重要概念，用于表示系统状态的改变或某些操作的触发。

在Spring框架中，事件通常用于解耦应用程序的不同部分，例如，当某个操作发生时，可以发布一个事件，其他组件可以监听这个事件并作出相应的反应。

事件的应用场景：

  • 用户登录、注销事件

  • 订单创建、更新事件

  • 系统配置变更事件

是不是和前面的spring状态机很像，其实这两个区别很大：

  • 状态机关注于对象在其生命周期中的状态转换和这些转换的规则。它主要用于处理复杂的业务流程和状态管理。

  • 事件关注于系统中的事件发布与监听机制，用于实现组件间的解耦和异步通信。它主要用于通知和响应系统中的各种变化。

  • 在Spring框架中，你可以同时使用状态机和事件机制来构建灵活和可维护的应用程序。状态机适合于处理具有明确状态转换逻辑的业务流程，而事件则适用于需要异步通信和解耦的系统组件。

 在Spring框架中，状态机和事件是两种不同的概念，它们在处理复杂业务逻辑和异步消息传递时发挥着重要作用。

Spring 事件机制

Spring事件（Spring Event）是基于观察者模式实现的轻量级消息通信机制，允许组件间通过发布-订阅模型解耦交互。

核心思想：基于发布-订阅模式实现组件间解耦，事件发布者（Publisher）与监听者（Listener）无需直接依赖，通过事件（Event）传递业务状态变更；事件发布者发布事件，事件监听器异步或同步监听并处理事件。

适用于订单状态变更、用户注册后异步操作等场景。

一、核心原理

Spring事件机制基于观察者模式(Observer Pattern)实现，包含三个核心要素：

  1. ‌事件(Event)‌：继承ApplicationEvent的业务状态对象
  2. ‌发布者(Publisher)‌：通过ApplicationEventPublisher接口发布事件
  3. ‌监听器(Listener)‌：通过接口或注解方式订阅事件

工作机制：发布者产生事件→事件多播器广播→监听器接收处理。默认同步执行，但支持配置异步处理。

工作原理：

  1. 观察者模式：事件发布者（Publisher）不直接调用监听器（Listener），而是通过事件广播器（ApplicationEventMulticaster）通知所有注册的监听器。
  2.  同步/异步：默认同步执行（发布者阻塞直到监听器处理完成），可通过@Async实现异步。

二、核心类与方法

组件类/接口核心功能
事件ApplicationEvent所有事件的基类，自定义事件需继承此类
事件发布器ApplicationEventPublisher事件发布接口，提供publishEvent()方法
监听器 接口ApplicationListener监听器接口，实现onApplicationEvent()方法
监听器 注解@EventListener方法级监听注解，简化监听器实现
广播器ApplicationEventMulticaster事件多播器，默认实现为SimpleApplicationEventMulticaster
事务绑定@TransactionalEventListener指定事件触发时机（如 AFTER_COMMIT）

核心原理：

  1. 观察者模式升华：事件源（如订单服务）发布事件 → 事件广播器（ApplicationEventMulticaster）分发 → 监听器执行响应逻辑。

  2. 事务集成：通过 @TransactionalEventListener 绑定事务阶段（如 AFTER_COMMIT），确保事件在事务提交后触发，避免数据不一致。

三、核心流程

1. 发布事件：调用ApplicationEventPublisher.publishEvent()。

2. 事件广播：ApplicationEventMulticaster遍历所有监听器，调用其处理方法。

3. 监听处理：监听器执行业务逻辑（同步或异步）。

  1. ‌定义事件类‌：创建继承ApplicationEvent的子类
public class OrderEvent extends ApplicationEvent {
    private String orderId;
    public OrderEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }
    // getter方法
}
  1. ‌发布事件‌：通过注入的ApplicationEventPublisher
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void createOrder() {
        publisher.publishEvent(new OrderEvent(this, "ORD123"));
    }
}
  1. ‌监听事件‌：实现ApplicationListener或使用@EventListener注解
// 注解方式
@Component
public class OrderListener {
    @EventListener
    public void handleOrder(OrderEvent event) {
        System.out.println("处理订单事件：" + event.getOrderId());
    }
}

// 接口方式
@Component
public class LogListener implements ApplicationListener<OrderEvent> {
    @Override
    public void onApplicationEvent(OrderEvent event) {
        System.out.println("记录订单日志：" + event.getOrderId());
    }
}

四、优缺点分析

维度优点缺点
耦合度组件解耦，新增监听器无需修改发布者事件链过长时调试困难
性能异步监听器可提升吞吐量（需配线程池）同步监听阻塞主线程
事务控制支持事务绑定（如 AFTER_COMMIT）跨监听器事务需手动管理（ChainedTransactionManager）
可靠性轻量级，无外部依赖默认内存广播，服务重启事件丢失
优点缺点
1. 解耦：发布者和监听器无直接依赖。1. 同步阻塞：默认同步，可能影响性能。
2. 扩展性：新增监听器无需修改发布者代码。2. 顺序问题：监听器执行顺序需额外配置（如@Order）。
3. 轻量级：无需引入额外中间件（如MQ）。3. 事务一致性：默认不支持事务传播（需结合@TransactionalEventListener）。

‌优势：‌

  • 实现组件解耦，提高代码可维护性
  • 支持同步/异步处理模式
  • 与Spring生态无缝集成
  • 简化复杂业务流程拆分

‌局限：‌

  • 单机版实现，不适用于分布式场景
  • 异步处理需注意线程安全问题
  • 事件链过长可能影响性能

五、适用场景

Spring事件适合轻量级、解耦的场景，通过简单配置即可实现组件间通信。复杂场景（如跨服务）需结合消息队列（如Kafka、RabbitMQ）。

适用场景优先级：

  1. 强解耦需求：跨模块协作（如订单→积分）。

  2. 异步非核心操作：日志、消息通知。

  3. 事务敏感操作：结合 @TransactionalEventListener 确保数据一致性。

慎用场景：高实时性同步调用、需严格顺序执行的链式操作。

  1. 业务解耦：如订单创建后发送通知、更新缓存。

  2. 异步处理：耗时操作（如日志记录、邮件发送）。

  3. 跨模块通信：不同服务或层间的事件通知。‌

  4. 业务状态变更通知‌：如订单状态变化、用户注册等
  5. ‌审计日志记录‌：关键操作的事件日志
  6. ‌缓存更新‌：数据变更时触发缓存刷新
  7. ‌异步任务触发‌：耗时操作异步化处理‘

典型场景：

  • 订单支付后流程：支付成功 → 扣库存、发物流、加积分

  • 用户注册：注册成功 → 发邮件、初始化画像、送优惠券

  • 日志/埋点：业务操作 → 异步记录日志，避免阻塞主流程

六、完整案例

案例一：用户注册流程

// 1. 定义事件
public class UserRegisterEvent extends ApplicationEvent {
    private String username;
    public UserRegisterEvent(Object source, String username) {
        super(source);
        this.username = username;
    }
    // getter
}

// 2. 发布事件
@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void register(String username) {
        // 注册逻辑...
        publisher.publishEvent(new UserRegisterEvent(this, username));
    }
}

// 3. 监听处理
@Component
public class EmailListener {
    @EventListener
    @Async  // 异步执行
    public void sendWelcomeEmail(UserRegisterEvent event) {
        System.out.println("发送欢迎邮件给：" + event.getUsername());
    }
}

@Component
public class ScoreListener {
    @EventListener
    public void addRegisterScore(UserRegisterEvent event) {
        System.out.println("为用户增加注册积分：" + event.getUsername());
    }
}

案例二：创建订单事件

1. 定义事件：

public class OrderCreatedEvent extends ApplicationEvent {
    private String orderId;
    public OrderCreatedEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }
    // getter...
}

2. 发布事件：

@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder(String orderId) {
        // 创建订单逻辑...
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
    }
}

3. 监听事件：

@Component
public class OrderEventListener {
    @EventListener
    @Async // 异步处理
    public void sendNotification(OrderCreatedEvent event) {
        System.out.println("发送订单通知，ID: " + event.getOrderId());
    }

    @EventListener
    public void updateCache(OrderCreatedEvent event) {
        System.out.println("更新缓存，ID: " + event.getOrderId());
    }
}

注意事项

1. 事务边界：

  • 默认事件在发布者事务提交后触发（@TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)）。
  • 若需在事务前触发，使用TransactionPhase.BEFORE_COMMIT。

2. 性能：高频事件建议异步化（@Async）。

3. 顺序控制：通过@Order注解指定监听器优先级。

4. 异常处理：监听器抛出异常可能导致事务回滚（需根据业务决定是否捕获异常）。

 案例三：订单支付成功事件

// 1. 定义事件
public class PaymentSuccessEvent extends ApplicationEvent {
    private Long orderId;
    public PaymentSuccessEvent(Object source, Long orderId) {
        super(source);
        this.orderId = orderId;
    }
}

// 2. 发布事件（支付服务中）
@Service
public class PaymentService {
    @Autowired 
    private ApplicationEventPublisher publisher;

    @Transactional
    public void confirmPayment(Long orderId) {
        // 更新订单状态...
        publisher.publishEvent(new PaymentSuccessEvent(this, orderId));
    }
}

// 3. 监听器处理
@Component
public class PaymentListeners {

    @EventListener
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT) // 事务提交后触发
    public void deductInventory(PaymentSuccessEvent event) {
        inventoryService.deductStock(event.getOrderId());
    }

    @Async // 异步执行
    @EventListener
    public void addPoints(PaymentSuccessEvent event) {
        userService.addPoints(event.getOrderId());
    }
}

七、注意事项

  1. ‌作用域限制‌：默认仅限单个应用上下文内传播
  2. ‌异常处理‌：监听器异常会中断事件传播链
  3. ‌执行顺序‌：可通过@Order注解控制监听器执行顺序
  4. ‌异步配置‌：需显式启用@EnableAsync并配置线程池
  5. ‌性能考量‌：高频事件建议采用异步处理
  6. ‌避免循环‌：注意事件发布可能导致的循环调用

八、Spring事件如何实现异步处理？

在Spring中实现事件异步处理主要通过@Async注解结合事件监听器来完成，以下是详细步骤和说明：

1. 启用异步支持

在Spring配置类上添加@EnableAsync注解，启用异步方法执行能力：

@Configuration
@EnableAsync  // 关键：启用异步支持
public class AsyncConfig {
    // 可选：自定义线程池（默认使用SimpleAsyncTaskExecutor）
    @Bean
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("AsyncEvent-");
        executor.initialize();
        return executor;
    }
}

2. 在事件监听器方法上添加`@Async`

通过@Async注解标记监听器方法，使其异步执行：

@Component
public class OrderEventListener {

    // 异步处理订单创建事件
    @Async  // 关键：声明该方法异步执行
    @EventListener
    public void handleOrderCreatedEvent(OrderCreatedEvent event) {
        // 模拟耗时操作（如发送邮件、通知等）
        System.out.println("异步处理订单事件，ID: " + event.getOrderId() + "，线程: " + Thread.currentThread().getName());
        try {
            Thread.sleep(3000); // 模拟耗时
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

3. 事件发布（无需修改）

事件发布代码保持不变，Spring会自动将事件分发到异步监听器：

@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    public void createOrder(String orderId) {
        // 业务逻辑...
        System.out.println("发布订单事件，线程: " + Thread.currentThread().getName());
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
    }
}

4. 关键注意事项

1. 代理机制：

  • @Async基于Spring AOP实现，要求监听器类由Spring容器管理（如添加@Component）。
  • 同类内调用无效：若在同一个类中直接调用@Async方法，异步不会生效（需通过代理对象调用）。

2. 异常处理：异步方法抛出的异常不会传播到调用方（发布者），需在监听器内部捕获处理。

3. 事务边界：异步方法默认在新线程中执行，与发布者的事务隔离。若需事务支持，需在异步方法上单独添加@Transactional。

4. 线程池配置：默认使用SimpleAsyncTaskExecutor（每次创建新线程），生产环境建议自定义线程池（如示例中的asyncExecutor）。

5. 完整流程示例

1. 发布事件（同步调用）：


orderService.createOrder("123"); // 发布事件，主线程立即继续执行。

2. 异步处理：

  • Spring将事件交给OrderEventListener的handleOrderCreatedEvent方法。
  • 方法在独立线程中执行，主线程不受阻塞。

6. 验证异步效果

通过日志输出线程名称可验证异步是否生效：

发布订单事件，线程: main          # 发布者在主线程
异步处理订单事件，ID: 123，线程: AsyncEvent-1  # 监听器在独立线程

通过以上步骤，Spring事件即可实现完全异步处理，提升系统吞吐量和响应速度。

九、Spring事件的事务传播行为如何控制？

在Spring中，事件的事务传播行为可以通过@TransactionalEventListener注解来控制，它允许你将事件监听器与事务生命周期绑定。

以下是具体控制方式及示例：

1. `@TransactionalEventListener` 的事务阶段（Transaction Phase）

通过phase属性指定监听器在事务的哪个阶段触发，可选值如下：

  • `TransactionPhase.BEFORE_COMMIT`

事务提交前触发（若事务回滚，则不会执行监听器）。

  • `TransactionPhase.AFTER_COMMIT`（默认值）

事务成功提交后触发（最常用，确保事件处理在事务完成后执行）。

  • `TransactionPhase.AFTER_ROLLBACK`

事务回滚后触发（可用于记录失败日志或补偿操作）。

  • `TransactionPhase.AFTER_COMPLETION`

事务完成（无论提交或回滚）后触发（适合清理资源等操作）。

示例代码

@Component
public class OrderEventListener {

    // 在事务提交后异步处理事件
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void handleOrderEventAfterCommit(OrderCreatedEvent event) {
        System.out.println("事务提交后处理事件，ID: " + event.getOrderId());
    }

    // 在事务回滚后处理事件（如记录失败日志）
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void handleOrderEventAfterRollback(OrderCreatedEvent event) {
        System.out.println("事务回滚后处理事件，ID: " + event.getOrderId());
    }
}

2. 结合`@Async`实现异步+事务控制

若需异步处理且受事务约束，需同时使用@Async和@TransactionalEventListener：

@Component
public class OrderEventListener {

    // 异步 + 事务提交后触发
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void asyncHandleAfterCommit(OrderCreatedEvent event) {
        System.out.println("异步处理（事务提交后），线程: " + Thread.currentThread().getName());
    }
}

3. 注意事项

1. 默认行为：

  • 若未指定phase，默认值为AFTER_COMMIT，即事务提交后触发。

2. 事务传播的局限性：

  • @TransactionalEventListener本身不直接控制事务传播（如REQUIRED、REQUIRES_NEW），它仅绑定到当前线程的事务上下文。
  • 若监听器方法需要独立事务，需额外添加@Transactional(propagation = Propagation.REQUIRES_NEW)。

3. 异步与事务的顺序：

  • 当同时使用@Async和@TransactionalEventListener时，事务的提交可能先于异步任务的执行（因为异步任务在新线程中运行）。此时需确保事件处理不依赖发布者的事务状态。

4. 监听器异常处理：

  • 在AFTER_COMMIT阶段，若监听器抛出异常，不会影响已提交的事务，但需自行处理异常（如重试或告警）。

4. 完整示例：订单创建事件的事务控制

事件定义

public class OrderCreatedEvent extends ApplicationEvent {
    private String orderId;
    public OrderCreatedEvent(Object source, String orderId) {
        super(source);
        this.orderId = orderId;
    }
    // getter...
}

事件发布（带事务）

@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;

    @Transactional  // 发布事件的方法需在事务中
    public void createOrder(String orderId) {
        // 1. 保存订单到数据库（事务内操作）
        // 2. 发布事件
        publisher.publishEvent(new OrderCreatedEvent(this, orderId));
        // 事务提交后，AFTER_COMMIT阶段的监听器才会触发
    }
}

监听器（事务+异步）

@Component
public class OrderEventListener {

    // 事务提交后异步处理
    @Async
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    public void asyncAfterCommit(OrderCreatedEvent event) {
        System.out.println("异步处理订单事件（事务已提交），ID: " + event.getOrderId());
    }

    // 事务回滚后同步处理（如补偿）
    @TransactionalEventListener(phase = TransactionPhase.AFTER_ROLLBACK)
    public void syncAfterRollback(OrderCreatedEvent event) {
        System.out.println("同步处理订单回滚事件，ID: " + event.getOrderId());
    }
}

总结
  • 控制事务传播行为：通过@TransactionalEventListener的phase属性绑定到事务生命周期阶段。
  • 异步+事务结合：需同时使用@Async和@TransactionalEventListener，但需注意线程隔离问题。
  • 适用场景：
  • AFTER_COMMIT：确保事件处理依赖事务成功（如发送通知、更新缓存）。
  • AFTER_ROLLBACK：处理失败补偿逻辑（如记录日志、解锁资源）。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

01Byte空间

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值