Spring事件的高级玩法，90%的程序员根本不会用！

技术崽崽
6 阅读12分钟

🚀 Spring事件的高级玩法，90%的程序员根本不会用！

一句话总结：Spring事件 = 观察者模式 + 发布订阅 + 业务解耦神器

🎯 为什么你需要Spring事件？

想象一下你去吃火锅，点完菜后，服务员按下呼叫器：

"A区3号桌已下单！"

这个消息一广播：

  • 🍳 后厨开始切菜
  • 🥣 配菜员准备料碗
  • 🚶 传菜小哥进入待命状态

每个岗位听到"出餐事件"后，各自执行自己的活，互不干扰，但又配合默契！

这就是Spring事件的魅力：零侵入、零样板、零耦合的组件通信！

📊 传统代码的痛点（对比）

❌ 传统耦合写法

@Service
public class UserService {
    
    @Autowired
    private EmailService emailService;
    
    @Autowired
    private SmsService smsService;
    
    @Autowired
    private LogService logService;
    
    @Autowired
    private RecommendationService recommendationService;
    
    public void register(User user) {
        // 1. 保存用户
        userRepository.save(user);
        
        // 2. 一堆耦合的后续处理
        emailService.sendWelcomeEmail(user.getEmail());
        smsService.sendWelcomeSms(user.getPhone());
        logService.recordUserBehavior(user.getId(), "REGISTER");
        recommendationService.generateRecommendations(user.getId());
        
        // 3. 问题来了：
        // - 代码臃肿，难以维护
        // - 新增需求要改核心代码
        // - 单元测试困难
        // - 无法灵活控制执行顺序
    }
}

✅ Spring事件解耦写法

@Service
public class UserService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void register(User user) {
        // 1. 保存用户
        userRepository.save(user);
        
        // 2. 只需发布一个事件！
        eventPublisher.publishEvent(new UserRegisterEvent(user));
        
        // 3. 后续处理交给监听器，核心代码清爽！
    }
}

// 邮件监听器
@Component
public class EmailListener {
    @EventListener
    public void handle(UserRegisterEvent event) {
        emailService.sendWelcomeEmail(event.getUser().getEmail());
    }
}

// 短信监听器
@Component
public class SmsListener {
    @EventListener
    public void handle(UserRegisterEvent event) {
        smsService.sendWelcomeSms(event.getUser().getPhone());
    }
}

// 行为日志监听器
@Component
public class LogListener {
    @EventListener
    public void handle(UserRegisterEvent event) {
        logService.recordUserBehavior(event.getUser().getId(), "REGISTER");
    }
}

// 推荐系统监听器
@Component
public class RecommendationListener {
    @EventListener
    public void handle(UserRegisterEvent event) {
        recommendationService.generateRecommendations(event.getUser().getId());
    }
}

优势对比：

维度传统写法Spring事件
代码耦合度高零耦合
新增需求改核心代码新增监听器
单元测试困难简单
执行控制固定顺序灵活控制
性能优化难支持异步

🔥 7大高级玩法（附完整代码）

1️⃣ 异步事件处理 - 提升系统吞吐量

场景：用户注册后发送邮件、短信等耗时操作，不想阻塞主流程

@Configuration
@EnableAsync
public class AsyncEventConfig {
    
    @Bean(name = "eventExecutor")
    public Executor eventExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("event-async-");
        executor.initialize();
        return executor;
    }
}

@Component
public class AsyncEventListener {
    
    // 方式1：方法级别异步
    @Async("eventExecutor")
    @EventListener
    public void handleAsync(UserRegisterEvent event) {
        // 耗时操作
        emailService.sendWelcomeEmail(event.getUser().getEmail());
        smsService.sendWelcomeSms(event.getUser().getPhone());
    }
    
    // 方式2：监听器级别异步
    @Async("eventExecutor")
    @Component
    public static class AsyncListener {
        @EventListener
        public void handle(UserRegisterEvent event) {
            // 异步执行
        }
    }
}

性能对比：

  • 同步：100次注册 ≈ 100秒（每次1秒）
  • 异步：100次注册 ≈ 10秒（并发执行）

2️⃣ 条件监听 - 精准过滤事件

场景：只处理VIP用户的注册事件

@Component
public class VipUserListener {
    
    // 只处理VIP用户
    @EventListener(condition = "#event.user.vip == true")
    public void handleVipUserRegister(UserRegisterEvent event) {
        // 给VIP用户发专属优惠券
        couponService.sendVipCoupon(event.getUser().getId());
    }
    
    // 复杂条件：VIP且年龄大于18
    @EventListener(condition = "#event.user.vip == true && #event.user.age > 18")
    public void handleAdultVip(UserRegisterEvent event) {
        // 发送成人专属内容
    }
    
    // 使用SpEL表达式
    @EventListener(condition = "#event.user.email.contains('vip')")
    public void handleEmailVip(UserRegisterEvent event) {
        // 邮箱包含vip的用户
    }
}

SpEL条件语法：

// 基础比较
#event.status == 'SUCCESS'
#event.count > 10
#event.name != null

// 逻辑运算
#event.vip && #event.age > 18
#event.type == 'A' || #event.type == 'B'

// 集合操作
#event.tags.contains('hot')
#event.users.size() > 5

// 方法调用
#event.user.isAdult()

3️⃣ 事件链 - 级联触发事件

场景：订单创建 → 库存扣减 → 发货通知 → 物流跟踪

// 1. 订单创建事件
public class OrderCreateEvent extends ApplicationEvent {
    private Order order;
    // 构造方法、getter...
}

// 2. 库存扣减事件
public class InventoryDeductEvent extends ApplicationEvent {
    private Order order;
    // 构造方法、getter...
}

// 3. 发货通知事件
public class ShippingNotifyEvent extends ApplicationEvent {
    private Order order;
    // 构造方法、getter...
}

// 监听器1：订单创建 → 扣减库存
@Component
public class OrderCreateListener {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    @EventListener
    public void handleOrderCreate(OrderCreateEvent event) {
        // 1. 扣减库存
        inventoryService.deduct(event.getOrder());
        
        // 2. 触发下一个事件
        publisher.publishEvent(new InventoryDeductEvent(event.getOrder()));
    }
}

// 监听器2：库存扣减 → 发货通知
@Component
public class InventoryDeductListener {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    @EventListener
    public void handleInventoryDeduct(InventoryDeductEvent event) {
        // 1. 通知仓库发货
        warehouseService.notifyShipping(event.getOrder());
        
        // 2. 触发发货通知事件
        publisher.publishEvent(new ShippingNotifyEvent(event.getOrder()));
    }
}

// 监听器3：发货通知 → 物流跟踪
@Component
public class ShippingNotifyListener {
    @EventListener
    public void handleShippingNotify(ShippingNotifyEvent event) {
        // 1. 创建物流跟踪
        logisticsService.createTracking(event.getOrder());
        
        // 2. 通知用户
        smsService.notifyUser(event.getOrder().getUserId(), "您的订单已发货");
    }
}

事件链优势：

  • ✅ 业务流程清晰可视化
  • ✅ 每个环节独立可测试
  • ✅ 支持环节重试和补偿
  • ✅ 易于监控和排查问题

4️⃣ 事务事件 - 保证数据一致性

场景：用户注册成功后发送欢迎邮件，但注册失败不能发邮件

@Service
public class UserService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Transactional
    public void register(User user) {
        // 1. 保存用户（在事务中）
        userRepository.save(user);
        
        // 2. 发布事务事件（事务提交后才触发）
        eventPublisher.publishEvent(new UserRegisterEvent(user));
    }
}

@Component
public class TransactionalEventListenerDemo {
    
    // 事务提交后执行（默认）
    @TransactionalEventListener
    public void afterCommit(UserRegisterEvent event) {
        // 事务成功提交后发送邮件
        emailService.sendWelcomeEmail(event.getUser().getEmail());
    }
    
    // 事务回滚后执行
    @TransactionalEventListener(fallbackExecution = true)
    public void afterRollback(UserRegisterEvent event) {
        // 事务回滚后的补偿操作
        logService.recordFailedRegistration(event.getUser().getId());
    }
    
    // 事务提交前执行
    @TransactionalEventListener(phase = TransactionPhase.BEFORE_COMMIT)
    public void beforeCommit(UserRegisterEvent event) {
        // 事务提交前的预处理
    }
    
    // 事务完成后执行（无论成功失败）
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMPLETION)
    public void afterCompletion(UserRegisterEvent event) {
        // 清理临时资源
    }
}

事务阶段说明：

阶段说明使用场景
BEFORE_COMMIT事务提交前预处理、验证
AFTER_COMMIT事务提交后（默认）发送邮件、通知
AFTER_ROLLBACK事务回滚后补偿操作、日志记录
AFTER_COMPLETION事务完成后（无论成功失败）资源清理

5️⃣ 执行顺序控制 - 精确掌控流程

场景：用户注册后，先记录日志，再发邮件，最后生成推荐

@Component
public class OrderedEventListeners {
    
    // 优先级1：最先执行
    @EventListener
    @Order(1)
    public void logFirst(UserRegisterEvent event) {
        logService.record(event.getUser().getId(), "REGISTER_START");
    }
    
    // 优先级2：第二执行
    @EventListener
    @Order(2)
    public void sendEmail(UserRegisterEvent event) {
        emailService.sendWelcomeEmail(event.getUser().getEmail());
    }
    
    // 优先级3：最后执行
    @EventListener
    @Order(3)
    public void generateRecommendations(UserRegisterEvent event) {
        recommendationService.generate(event.getUser().getId());
    }
    
    // 使用Ordered接口（更灵活）
    @Component
    @Order(4)
    public static class CustomOrderedListener implements Ordered {
        @EventListener
        public void handle(UserRegisterEvent event) {
            // 执行逻辑
        }
        
        @Override
        public int getOrder() {
            return 4; // 返回优先级
        }
    }
}

优先级规则：

  • 数值越小，优先级越高
  • 默认值：Integer.MAX_VALUE（最后执行）
  • 相同优先级：执行顺序不确定

6️⃣ 继承+多态 - 一个监听器处理所有子事件

场景：订单事件、支付事件、退款事件统一处理

// 1. 事件基类
public abstract class BusinessEvent extends ApplicationEvent {
    private String businessType;
    private String operator;
    private LocalDateTime createTime;
    
    public BusinessEvent(Object source, String businessType, String operator) {
        super(source);
        this.businessType = businessType;
        this.operator = operator;
        this.createTime = LocalDateTime.now();
    }
    
    // getter...
}

// 2. 子事件：订单事件
public class OrderEvent extends BusinessEvent {
    private Order order;
    
    public OrderEvent(Object source, Order order, String operator) {
        super(source, "ORDER", operator);
        this.order = order;
    }
    
    // getter...
}

// 3. 子事件：支付事件
public class PaymentEvent extends BusinessEvent {
    private Payment payment;
    
    public PaymentEvent(Object source, Payment payment, String operator) {
        super(source, "PAYMENT", operator);
        this.payment = payment;
    }
    
    // getter...
}

// 4. 子事件：退款事件
public class RefundEvent extends BusinessEvent {
    private Refund refund;
    
    public RefundEvent(Object source, Refund refund, String operator) {
        super(source, "REFUND", operator);
        this.refund = refund;
    }
    
    // getter...
}

// 5. 通用监听器：处理所有业务事件
@Component
public class BusinessEventListener {
    
    // 通用处理：记录所有业务事件
    @EventListener
    public void handleAllBusinessEvents(BusinessEvent event) {
        auditLogService.record(
            event.getBusinessType(),
            event.getOperator(),
            event.getCreateTime()
        );
    }
    
    // 特定处理：只处理订单事件
    @EventListener
    public void handleOrderEvent(OrderEvent event) {
        // 订单专属逻辑
        orderService.updateStatus(event.getOrder().getId(), "PROCESSING");
    }
    
    // 特定处理：只处理支付事件
    @EventListener
    public void handlePaymentEvent(PaymentEvent event) {
        // 支付专属逻辑
        paymentService.confirm(event.getPayment().getId());
    }
}

优势：

  • ✅ 通用逻辑统一处理
  • ✅ 特定逻辑单独处理
  • ✅ 新增事件类型无需修改通用监听器
  • ✅ 代码复用率高

7️⃣ 泛型事件精准路由 - 类型安全的事件分发

场景：不同类型的数据变更事件，需要精准路由到对应处理器

// 1. 泛型事件基类
public class DataChangeEvent<T> extends ApplicationEvent {
    private T data;
    private String operation; // CREATE, UPDATE, DELETE
    
    public DataChangeEvent(Object source, T data, String operation) {
        super(source);
        this.data = data;
        this.operation = operation;
    }
    
    // getter...
}

// 2. 用户数据变更事件
public class UserDataChangeEvent extends DataChangeEvent<User> {
    public UserDataChangeEvent(Object source, User user, String operation) {
        super(source, user, operation);
    }
}

// 3. 商品数据变更事件
public class ProductDataChangeEvent extends DataChangeEvent<Product> {
    public ProductDataChangeEvent(Object source, Product product, String operation) {
        super(source, product, operation);
    }
}

// 4. 精准路由监听器
@Component
public class DataChangeListeners {
    
    // 只处理用户数据变更
    @EventListener
    public void handleUserDataChange(UserDataChangeEvent event) {
        if ("CREATE".equals(event.getOperation())) {
            // 新用户处理
        } else if ("UPDATE".equals(event.getOperation())) {
            // 用户更新处理
        }
    }
    
    // 只处理商品数据变更
    @EventListener
    public void handleProductDataChange(ProductDataChangeEvent event) {
        if ("CREATE".equals(event.getOperation())) {
            // 新商品处理
        } else if ("UPDATE".equals(event.getOperation())) {
            // 商品更新处理
        }
    }
    
    // 通用监听器：处理所有数据变更（类型安全）
    @EventListener
    public <T> void handleGenericDataChange(DataChangeEvent<T> event) {
        // 类型安全的通用处理
        auditService.log(event.getData().getClass().getSimpleName(), 
                        event.getOperation());
    }
}

发布事件示例：

@Service
public class UserService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void updateUser(User user) {
        userRepository.save(user);
        // 精准发布用户数据变更事件
        publisher.publishEvent(new UserDataChangeEvent(this, user, "UPDATE"));
    }
}

@Service
public class ProductService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void updateProduct(Product product) {
        productRepository.save(product);
        // 精准发布商品数据变更事件
        publisher.publishEvent(new ProductDataChangeEvent(this, product, "UPDATE"));
    }
}

🎮 完整实战案例：电商订单全流程

// ==================== 事件定义 ====================

// 订单创建事件
public class OrderCreateEvent extends ApplicationEvent {
    private Order order;
    public OrderCreateEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
    // getter...
}

// 库存扣减事件
public class InventoryDeductEvent extends ApplicationEvent {
    private Order order;
    public InventoryDeductEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
    // getter...
}

// 支付成功事件
public class PaymentSuccessEvent extends ApplicationEvent {
    private Order order;
    private Payment payment;
    public PaymentSuccessEvent(Object source, Order order, Payment payment) {
        super(source);
        this.order = order;
        this.payment = payment;
    }
    // getter...
}

// 订单发货事件
public class OrderShipEvent extends ApplicationEvent {
    private Order order;
    private String logisticsNo;
    public OrderShipEvent(Object source, Order order, String logisticsNo) {
        super(source);
        this.order = order;
        this.logisticsNo = logisticsNo;
    }
    // getter...
}

// ==================== 服务层 ====================

@Service
public class OrderService {
    
    @Autowired
    private ApplicationEventPublisher publisher;
    
    @Transactional
    public Order createOrder(OrderCreateRequest request) {
        // 1. 创建订单
        Order order = orderRepository.save(buildOrder(request));
        
        // 2. 发布订单创建事件
        publisher.publishEvent(new OrderCreateEvent(this, order));
        
        return order;
    }
    
    @Transactional
    public void confirmPayment(Long orderId, Payment payment) {
        // 1. 确认支付
        orderRepository.updateStatus(orderId, "PAID");
        
        // 2. 发布支付成功事件
        Order order = orderRepository.findById(orderId);
        publisher.publishEvent(new PaymentSuccessEvent(this, order, payment));
    }
    
    public void shipOrder(Long orderId, String logisticsNo) {
        // 1. 更新发货状态
        orderRepository.updateStatus(orderId, "SHIPPED");
        
        // 2. 发布发货事件
        Order order = orderRepository.findById(orderId);
        publisher.publishEvent(new OrderShipEvent(this, order, logisticsNo));
    }
}

// ==================== 监听器层 ====================

// 监听器1：订单创建 → 扣减库存 + 发送确认邮件
@Component
public class OrderCreateListener {
    
    @Autowired
    private ApplicationEventPublisher publisher;
    
    @EventListener
    @Order(1)
    public void deductInventory(OrderCreateEvent event) {
        // 扣减库存
        inventoryService.deduct(event.getOrder());
        // 触发库存扣减事件
        publisher.publishEvent(new InventoryDeductEvent(this, event.getOrder()));
    }
    
    @EventListener
    @Order(2)
    @Async("eventExecutor")
    public void sendConfirmEmail(OrderCreateEvent event) {
        // 异步发送确认邮件
        emailService.sendOrderConfirm(event.getOrder().getEmail());
    }
}

// 监听器2：支付成功 → 更新订单状态 + 发送支付成功通知
@Component
public class PaymentSuccessListener {
    
    @EventListener
    @TransactionalEventListener
    public void updateOrderStatus(PaymentSuccessEvent event) {
        // 更新订单状态为已支付
        orderService.updateStatus(event.getOrder().getId(), "PAID");
    }
    
    @EventListener
    @Async("eventExecutor")
    public void sendPaymentSuccessNotification(PaymentSuccessEvent event) {
        // 异步发送支付成功通知
        smsService.sendPaymentSuccess(event.getOrder().getUserId());
    }
}

// 监听器3：订单发货 → 创建物流跟踪 + 通知用户
@Component
public class OrderShipListener {
    
    @EventListener
    public void createLogisticsTracking(OrderShipEvent event) {
        // 创建物流跟踪
        logisticsService.createTracking(event.getOrder(), event.getLogisticsNo());
    }
    
    @EventListener
    @Async("eventExecutor")
    public void notifyUserShipped(OrderShipEvent event) {
        // 异步通知用户已发货
        pushService.notifyShipped(event.getOrder().getUserId(), event.getLogisticsNo());
    }
}

// 监听器4：通用审计日志（所有事件）
@Component
public class AuditLogListener {
    
    @EventListener
    @Async("eventExecutor")
    public void logAllEvents(ApplicationEvent event) {
        // 记录所有事件到审计日志
        if (event instanceof OrderCreateEvent) {
            auditLogService.record("ORDER_CREATE", ((OrderCreateEvent) event).getOrder().getId());
        } else if (event instanceof PaymentSuccessEvent) {
            auditLogService.record("PAYMENT_SUCCESS", ((PaymentSuccessEvent) event).getOrder().getId());
        } else if (event instanceof OrderShipEvent) {
            auditLogService.record("ORDER_SHIP", ((OrderShipEvent) event).getOrder().getId());
        }
    }
}

业务流程图：

用户下单
  ↓
[OrderService.createOrder]
  ↓
发布 OrderCreateEvent
  ↓
┌─────────────────────────────────┐
│ OrderCreateListener             │
│ ├─ 扣减库存                      │
│ ├─ 发布 InventoryDeductEvent    │
│ └─ 异步发送确认邮件              │
└─────────────────────────────────┘
  ↓
用户支付
  ↓
[OrderService.confirmPayment]
  ↓
发布 PaymentSuccessEvent
  ↓
┌─────────────────────────────────┐
│ PaymentSuccessListener          │
│ ├─ 更新订单状态（事务内）         │
│ └─ 异步发送支付成功通知          │
└─────────────────────────────────┘
  ↓
仓库发货
  ↓
[OrderService.shipOrder]
  ↓
发布 OrderShipEvent
  ↓
┌─────────────────────────────────┐
│ OrderShipListener               │
│ ├─ 创建物流跟踪                  │
│ └─ 异步通知用户已发货            │
└─────────────────────────────────┘

⚠️ 常见陷阱与避坑指南

1. 事件循环依赖

// ❌ 错误：A事件触发B事件，B事件又触发A事件，死循环！
@Component
public class CircularEventListener {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    @EventListener
    public void handleEventA(EventA event) {
        publisher.publishEvent(new EventB());
    }
    
    @EventListener
    public void handleEventB(EventB event) {
        publisher.publishEvent(new EventA()); // 死循环！
    }
}

// ✅ 正确：添加防重机制
@Component
public class SafeEventListener {
    private final Set<String> processedEvents = ConcurrentHashMap.newKeySet();
    
    @EventListener
    public void handleEventA(EventA event) {
        if (processedEvents.add(event.getId())) {
            publisher.publishEvent(new EventB(event.getId()));
        }
    }
}

2. 异常处理不当

// ❌ 错误：异常未捕获，导致后续监听器不执行
@EventListener
public void handleWithError(UserRegisterEvent event) {
    emailService.sendEmail(event.getUser().getEmail()); // 可能抛异常
    smsService.sendSms(event.getUser().getPhone()); // 不会执行！
}

// ✅ 正确：捕获异常，保证流程继续
@EventListener
public void handleWithTryCatch(UserRegisterEvent event) {
    try {
        emailService.sendEmail(event.getUser().getEmail());
    } catch (Exception e) {
        log.error("发送邮件失败", e);
    }
    
    try {
        smsService.sendSms(event.getUser().getPhone());
    } catch (Exception e) {
        log.error("发送短信失败", e);
    }
}

// ✅ 更好的方式：使用@ExceptionHandler
@Component
public class ExceptionHandlingListener {
    
    @EventListener
    public void handle(UserRegisterEvent event) {
        emailService.sendEmail(event.getUser().getEmail());
    }
    
    @ExceptionHandler
    public void handleException(Exception e, UserRegisterEvent event) {
        log.error("处理事件失败: {}", event, e);
        // 补偿逻辑
    }
}

3. 事务失效问题

@Service
public class UserService {
    
    @Autowired
    private ApplicationEventPublisher publisher;
    
    // ❌ 错误：同一个类内方法调用，事务失效
    public void register(User user) {
        saveUser(user); // 事务不生效！
        publisher.publishEvent(new UserRegisterEvent(user));
    }
    
    @Transactional
    public void saveUser(User user) {
        userRepository.save(user);
    }
    
    // ✅ 正确：使用AopContext或注入自身
    @Autowired
    private UserService self;
    
    public void registerCorrect(User user) {
        self.saveUser(user); // 事务生效
        publisher.publishEvent(new UserRegisterEvent(user));
    }
}

📈 Spring事件 vs 消息队列对比

维度Spring事件消息队列（RabbitMQ/Kafka）
适用场景单体应用内部解耦分布式系统、微服务
性能内存级，极快网络传输，稍慢
可靠性应用重启丢失持久化，高可靠
复杂度简单，零配置需要中间件部署
事务支持完美支持需要额外处理
监控简单完善的监控体系
学习成本低中等

选择建议：

  • 单体应用：优先使用Spring事件
  • 微服务架构：使用消息队列
  • 混合架构：内部用Spring事件，服务间用消息队列

🎯 最佳实践总结

1. 事件命名规范

// 好的命名
UserRegisterEvent          // 用户注册事件
OrderCreateEvent           // 订单创建事件
PaymentSuccessEvent        // 支付成功事件

// 避免模糊命名
UserEvent                  // ❌ 不清楚是什么事件
BusinessEvent              // ❌ 太宽泛

2. 事件数据封装

// ✅ 好：封装完整上下文
public class OrderCreateEvent extends ApplicationEvent {
    private Order order;
    private User operator;
    private String source; // 来源：APP/PC/小程序
    // 完整的业务上下文
}

// ❌ 差：只传ID
public class OrderEvent extends ApplicationEvent {
    private Long orderId; // 需要重新查询，性能差
}

3. 监听器职责单一

// ✅ 好：每个监听器只做一件事
@Component
public class EmailListener {
    @EventListener
    public void sendEmail(UserRegisterEvent event) {
        // 只负责发送邮件
    }
}

@Component
public class SmsListener {
    @EventListener
    public void sendSms(UserRegisterEvent event) {
        // 只负责发送短信
    }
}

// ❌ 差：一个监听器做太多事
@Component
public class AllInOneListener {
    @EventListener
    public void handle(UserRegisterEvent event) {
        sendEmail(event);
        sendSms(event);
        recordLog(event);
        generateRecommendation(event);
        // 职责混乱，难以维护
    }
}

4. 异步事件使用场景

// 适合异步的场景
@Async @EventListener public void sendEmail(...) // 耗时的IO操作
@Async @EventListener public void sendSms(...)   // 耗时的IO操作
@Async @EventListener public void recordLog(...) // 不影响主流程

// 不适合异步的场景
@EventListener public void deductInventory(...) // 需要事务保证
@EventListener public void updateStatus(...)    // 需要同步返回

📚 总结

7大高级玩法速查表

玩法核心注解使用场景代码量
异步事件@Async + @EventListener耗时操作不阻塞主流程⭐⭐
条件监听@EventListener(condition=...)精准过滤特定事件⭐
事件链publishEvent()级联触发多步骤流程⭐⭐⭐
事务事件@TransactionalEventListener保证数据一致性⭐⭐
顺序控制@Order精确控制执行顺序⭐
继承多态继承ApplicationEvent通用+特定逻辑分离⭐⭐⭐
泛型路由泛型事件类类型安全的事件分发⭐⭐⭐⭐

一句话记住核心

Spring事件 = 发布一个事件，N个监听器各干各的活，互不干扰，完美解耦！

现在，你已经掌握了90%程序员不会用的Spring事件高级玩法！快去重构你的代码，让它变得更优雅、更易维护吧！🚀

avatar
文章
阅读
粉丝