官方网站:www.xservx.com|备案号:蜀ICP备2026035467号-3

JAVA监听器:事件驱动编程的核心机制

在Java生态体系中,JAVA监听器作为实现事件驱动架构的关键技术,广泛应用于Web开发、微服务架构、消息处理等核心场景。监听器模式本质是观察者模式的一种具体实现,它允许对象在特定事件发生时自动触发预定义行为,从而实现松耦合、高内聚的系统设计。

为什么监听器如此重要?

在现代Java应用开发中,系统复杂度日益提升,模块间依赖关系愈发紧密。若采用紧耦合设计,任何模块变更都可能导致全局性重构。而JAVA监听器

  • ⚡ 实现异步解耦:事件发布者无需等待处理完成即可继续执行
  • ⚙️ 支持多订阅者:同一事件可触发多个监听器并行处理
  • 〔高效资源利用〕:避免轮询机制带来的性能损耗
  • 〈生命周期管理〕:自动感知应用启动/关闭等关键节点

监听器模式的理论基础

JAVA监听器

在Java标准库中,JAVA监听器

  • java.util.EventListener:所有监听器接口的根接口,标记接口
  • java.util.EventObject:所有事件对象的基类
  • PropertyChangeSupport:提供属性变更监听的便捷工具类

值得注意的是,Java EE规范对Web应用中的监听器做了专门扩展,形成Servlet监听器体系,涵盖ServletContext、HttpSession与ServletRequest三个作用域,为Web应用提供生命周期感知能力。

典型应用场景

JAVA监听器

1. Web应用生命周期管理

通过HttpSessionListener监听用户会话的创建与销毁,实现在线人数统计、用户行为分析;通过ServletContextListener监听应用启动/关闭,完成全局资源初始化与释放。

2. 业务流程增强

在订单创建后触发通知监听器,自动发送邮件/短信;在用户登录后触发日志监听器,记录登录行为;在支付完成触发库存监听器,自动扣减库存。

3. 框架扩展点设计

Spring框架的ApplicationEvent机制、Dubbo的EventBus、MyBatis的Plugin机制,均基于监听器模式构建扩展点,允许开发者无侵入式添加自定义逻辑。

监听器与回调的区别

许多开发者混淆监听器与回调机制,二者虽有相似之处,但存在本质差异:

维度 监听器 回调
触发时机 事件发生时自动触发 主动调用时执行
注册方式 动态注册/注销 静态传入
多实例支持 支持多个监听器 通常单个
生命周期感知 可感知应用生命周期 无生命周期概念

例如,在Spring中,JAVA监听器

性能考量与最佳实践

虽然JAVA监听器

  • 监听器过多:大量监听器注册会增加事件发布时的遍历开销
  • 阻塞操作:监听器内执行耗时操作会阻塞事件发布线程
  • 循环依赖:监听器中触发新事件,可能导致事件循环

推荐实践:

  1. 使用异步处理:结合ExecutorService将耗时操作异步化
  2. 事件分类过滤:通过事件类型精确匹配,减少无效触发
  3. 监听器分组管理:按业务域组织监听器,便于维护
  4. 监控与日志:记录监听器执行时间,及时发现性能瓶颈

Java版本演进中的监听器特性

随着Java版本迭代,JAVA监听器

Java 8+:函数式接口支持

通过Lambda表达式简化监听器实现,例如:

button.addActionListener(e -> System.out.println("点击事件"));

Java 9+:模块化改进

java.desktop模块中对事件系统进行模块化重构,提升安全性与性能

Java 17+:虚拟线程支持

在Project Loom中,监听器可配合虚拟线程实现高并发事件处理,大幅提升吞吐量

这些演进使JAVA监听器

JAVA监听器的分类体系

JAVA监听器

1. Servlet监听器(Web容器级)

Servlet规范定义的监听器体系,由Web容器(如Tomcat、Jetty)直接管理,作用于整个Web应用生命周期。Servlet 4.0规范共定义8种监听器,覆盖三个作用域:ServletContext、HttpSession与ServletRequest。

ServletContextListener

监听Web应用启动与关闭事件。常用于全局资源初始化(如数据库连接池、缓存预热)与资源释放(如关闭线程池、保存配置)。典型实现:

public class AppContextListener implements ServletContextListener {
  @Override
  public void contextInitialized(ServletContextEvent sce) {
    // 初始化全局配置
    sce.getServletContext().setAttribute("appVersion", "2.1.0");
    // 启动定时任务
    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
    sce.getServletContext().setAttribute("scheduler", scheduler);
  }
  @Override
  public void contextDestroyed(ServletContextEvent sce) {
    // 关闭定时任务
    ((ScheduledExecutorService)sce.getServletContext().getAttribute("scheduler")).shutdown();
  }
}

HttpSessionListener

监听用户会话的创建与销毁。可用于统计在线用户数、会话超时处理、用户行为追踪。实现时需注意HttpSession的钝化(Passivation)与活化(Activation)机制。

public class SessionCounterListener implements HttpSessionListener {
  private static AtomicInteger sessionCount = new AtomicInteger(0);
  @Override
  public void sessionCreated(HttpSessionEvent se) {
    sessionCount.incrementAndGet();
    se.getSession().setAttribute("sessionStartTime", new Date());
  }
  @Override
  public void sessionDestroyed(HttpSessionEvent se) {
    sessionCount.decrementAndGet();
    // 记录会话时长
    Date startTime = (Date)se.getSession().getAttribute("sessionStartTime");
    if (startTime != null) {
      long duration = new Date().getTime() - startTime.getTime();
      // 记录到日志系统
    }
  }
}

ServletRequestListener

监听HTTP请求的创建与销毁。适用于请求级日志记录、性能监控、跨域请求处理。由于请求频率高,需特别注意监听器实现的轻量级原则。

2. Spring事件监听器(应用框架级)

Spring框架通过ApplicationEventPublisher与ApplicationListener构建事件系统,支持同步与异步事件处理,是构建松耦合系统的核心机制。与Servlet监听器不同,Spring事件完全由应用容器管理,不依赖Web容器。

Spring事件体系包含三个核心组件:

  • ApplicationEvent:事件基类,所有自定义事件需继承此类
  • ApplicationListener:监听器接口,处理特定事件类型
  • ApplicationEventPublisher:事件发布者,用于触发事件

声明式监听器(@EventListener)

Spring 4.2引入的注解驱动方式,极大简化监听器开发:

@Component
public class OrderEventListener {
  @EventListener
  public void handleOrderCreated(OrderCreatedEvent event) {
    logger.info("订单创建: {}", event.getOrder().getId());
    // 发送通知
  }
  @EventListener(condition = "#event.order.amount > 1000")
  public void handleLargeOrder(LargeOrderEvent event) {
    // 处理大额订单
  }
}

异步事件处理

通过@Async注解实现异步事件监听,需配置TaskExecutor:

@Configuration
@EnableAsync
public class AsyncConfig {
  @Bean(name = "eventExecutor")
  public Executor eventExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(200);
    executor.setThreadNamePrefix("event-");
    executor.initialize();
    return executor;
  }
}
@Component
public class AsyncOrderListener {
  @Async("eventExecutor")
  @EventListener
  public void handleOrderCreatedAsync(OrderCreatedEvent event) {
    // 异步处理订单
  }
}

3. 自定义业务监听器(应用层)

开发者基于Java标准库或第三方框架构建的业务监听器,用于实现特定业务逻辑。此类监听器不受容器管理,需手动注册与调用,灵活性高但需自行处理生命周期。

基于接口的实现

// 事件对象
public class PaymentEvent extends ApplicationEvent {
  private final Payment payment;
  public PaymentEvent(Object source, Payment payment) {
    super(source);
    this.payment = payment;
  }
  public Payment getPayment() { return payment; }
}
// 监听器接口
public interface PaymentListener {
  void onPaymentProcessed(PaymentEvent event);
}
// 监听器实现
@Component
public class PaymentNotificationListener implements PaymentListener {
  @Override
  public void onPaymentProcessed(PaymentEvent event) {
    // 发送支付成功通知
  }
}

基于观察者模式的自定义实现

public class EventPublisher {
  private final List listeners = new CopyOnWriteArrayList<>();
  public void addListener(EventListener listener) {
    listeners.add(listener);
  }
  public void removeListener(EventListener listener) {
    listeners.remove(listener);
  }
  public void publishEvent(Event event) {
    for (EventListener listener : listeners) {
      listener.onEvent(event);
    }
  }
}
public interface EventListener {
  void onEvent(Event event);
}

监听器注册机制对比

类型 注册方式 作用域 线程模型
Servlet监听器 web.xml或@WebListener注解 Web容器 容器管理线程
Spring监听器 @Component + @EventListener 应用容器 可配置同步/异步
自定义监听器 手动调用addListener() 应用层 开发者控制

选择建议:

  • Web生命周期管理 → Servlet监听器
  • 业务逻辑解耦 → Spring监听器
  • 特殊框架集成 → 自定义监听器

Servlet监听器详解

JAVA监听器

1. ServletContext监听器

ServletContext代表整个Web应用,其监听器用于监控应用级别的事件。主要涉及两种监听器:

JAVA监听器

  • 初始化全局配置(如数据库连接池、第三方API客户端)
  • 加载静态数据到缓存(如字典表、配置项)
  • 启动后台任务(如数据同步、定时任务)
  • 初始化安全框架(如Spring Security上下文)

实现示例:

@WebListener
public class ApplicationStartupListener implements ServletContextListener {
  @Override
  public void contextInitialized(ServletContextEvent sce) {
    ServletContext context = sce.getServletContext();
    // 加载配置文件
    Properties props = new Properties();
    try (InputStream is = getClass().getClassLoader()
        .getResourceAsStream("app.properties")) {
      props.load(is);
      context.setAttribute("appConfig", props);
    } catch (IOException e) {
      context.log("配置加载失败", e);
    }
    // 初始化数据库连接池
    HikariConfig config = new HikariConfig();
    config.setJdbcUrl(props.getProperty("db.url"));
    config.setUsername(props.getProperty("db.user"));
    config.setPassword(props.getProperty("db.password"));
    HikariDataSource dataSource = new HikariDataSource(config);
    context.setAttribute("dataSource", dataSource);
    // 启动健康检查任务
    ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
    scheduler.scheduleAtFixedRate(() -> {
      try (Connection conn = dataSource.getConnection()) {
        conn.isValid(3);
      } catch (SQLException e) {
        context.log("数据库连接异常", e);
      }
    }, 0, 30, TimeUnit.SECONDS);
    context.setAttribute("healthScheduler", scheduler);
  }
  @Override
  public void contextDestroyed(ServletContextEvent sce) {
    // 优雅关闭资源
    ScheduledExecutorService scheduler =
        (ScheduledExecutorService)sce.getServletContext()
        .getAttribute("healthScheduler");
    if (scheduler != null) {
      scheduler.shutdown();
      try { scheduler.awaitTermination(10, TimeUnit.SECONDS); }
      catch (InterruptedException ignored) {}
    }
    DataSource ds = (DataSource)sce.getServletContext()
        .getAttribute("dataSource");
    if (ds instanceof HikariDataSource) {
      ((HikariDataSource)ds).close();
    }
  }
}

ServletContextAttributeListener监听ServletContext属性的增删改操作,常用于监控配置变更、实现配置热更新。当调用setAttribute/removeAttribute时触发相应方法。

public class ConfigChangeMonitor implements ServletContextAttributeListener {
  @Override
  public void attributeAdded(ServletContextAttributeEvent scab) {
    if ("appConfig".equals(scab.getName())) {
      System.out.println("配置已添加: " + scab.getValue());
    }
  }
  @Override
  public void attributeRemoved(ServletContextAttributeEvent scab) {
    if ("appConfig".equals(scab.getName())) {
      System.out.println("配置已移除,触发重载");
      // 触发配置重载逻辑
    }
  }
  @Override
  public void attributeReplaced(ServletContextAttributeEvent scab) {
    if ("appConfig".equals(scab.getName())) {
      System.out.println("配置已替换");
      // 触发配置热更新
    }
  }
}

2. HttpSession监听器

HttpSession监听器用于监控用户会话的生命周期,是实现用户在线状态管理、会话统计的核心组件。包含三种监听器:

HttpSessionListener监听会话的创建与销毁。会话销毁原因包括:

  • 用户主动注销(调用session.invalidate())
  • 会话超时(默认30分钟,可配置)
  • 服务器关闭
  • 会话钝化后未在有效期内恢复

典型实现:

@WebListener
public class UserSessionTracker implements HttpSessionListener {
  private static final Map activeSessions =
      Collections.synchronizedMap(new HashMap<>());
  @Override
  public void sessionCreated(HttpSessionEvent se) {
    String sessionId = se.getSession().getId();
    activeSessions.put(sessionId, new Date());
    // 更新在线人数计数器
    int count = activeSessions.size();
    se.getSession().getServletContext()
        .setAttribute("onlineCount", count);
  }
  @Override
  public void sessionDestroyed(HttpSessionEvent se) {
    String sessionId = se.getSession().getId();
    Date startTime = activeSessions.remove(sessionId);
    if (startTime != null) {
      long duration = new Date().getTime() - startTime.getTime();
      // 记录会话时长日志
      logger.info("会话{}持续{}秒", sessionId, duration/1000);
    }
    // 更新在线人数
    ServletContext ctx = se.getSession().getServletContext();
    ctx.setAttribute("onlineCount", activeSessions.size());
    // 触发登出事件
    ctx.setAttribute("logoutEvent", sessionId);
  }
}

HttpSessionAttributeListener监听会话属性的变更,适用于监控用户操作、实现会话审计。当属性被添加、移除或替换时触发。

典型用例:记录用户敏感操作(如密码修改、权限变更)

public class SessionAuditListener implements HttpSessionAttributeListener {
  @Override
  public void attributeAdded(HttpSessionBindingEvent event) {
    if ("userPermissions".equals(event.getName())) {
      logger.warn("用户权限变更: {} -> {}",
          event.getSession().getId(), event.getValue());
    }
  }
  @Override
  public void attributeRemoved(HttpSessionBindingEvent event) {
    if ("userPermissions".equals(event.getName())) {
      logger.error("用户权限移除: {}", event.getSession().getId());
    }
  }
}

HttpSessionBindingListener不同于前两者,它不是通过容器注册,而是由对象自身实现。当对象绑定到会话或从会话中移除时自动触发,无需@WebListener注解。

典型场景:实现会话级单例模式

public class UserContext implements HttpSessionBindingListener {
  private String userId;
  private List notifications = new ArrayList<>();
  @Override
  public void valueBound(HttpSessionBindingEvent event) {
    // 对象被添加到会话时触发
    System.out.println("UserContext已绑定到会话: " + event.getSession().getId());
  }
  @Override
  public void valueUnbound(HttpSessionBindingEvent event) {
    // 对象从会话中移除时触发
    System.out.println("UserContext已从会话移除: " + event.getSession().getId());
    // 清理资源
    notifications.clear();
  }
}

3. ServletRequest监听器

ServletRequest监听器监控HTTP请求的生命周期,适用于请求级日志、性能监控与请求预处理。包含两种监听器:

ServletRequestListener监听请求的创建与销毁,每个HTTP请求都会触发这两个方法。由于请求频率高,监听器实现必须轻量级,避免影响性能。

典型应用:请求耗时监控与日志记录

@WebListener
public class RequestPerformanceMonitor implements ServletRequestListener {
  @Override
  public void requestInitialized(ServletRequestEvent sre) {
    // 记录请求开始时间
    long startTime = System.currentTimeMillis();
    sre.getServletRequest().setAttribute("startTime", startTime);
    // 记录请求信息
    HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
    logger.debug("请求开始: {} {}",
        request.getMethod(), request.getRequestURI());
  }
  @Override
  public void requestDestroyed(ServletRequestEvent sre) {
    // 计算耗时
    Long startTime = (Long) sre.getServletRequest()
        .getAttribute("startTime");
    if (startTime != null) {
      long duration = System.currentTimeMillis() - startTime;
      if (duration > 1000) {
        logger.warn("慢请求: {} ms", duration);
      }
    }
  }
}

ServletRequestAttributeListener监听请求属性的变更,适用于调试与监控。当调用request.setAttribute()时触发。

典型用例:监控请求处理链中的数据流转

public class RequestDebugListener implements ServletRequestAttributeListener {
  @Override
  public void attributeAdded(ServletRequestAttributeEvent srae) {
    logger.debug("请求属性添加: {} = {}",
        srae.getName(), srae.getValue());
  }
  @Override
  public void attributeRemoved(ServletRequestAttributeEvent srae) {
    logger.debug("请求属性移除: {}", srae.getName());
  }
}

监听器注册方式

Servlet 3.0+支持两种注册方式:

  • 注解方式:@WebListener注解,需配合@WebServlet等使用
  • web.xml方式:适用于老版本容器或需要精细控制的场景
<listener>
  <listener-class>
    com.example.listeners.AppStartupListener
  </listener-class>
</listener>

监听器执行顺序

当存在多个同类型监听器时,执行顺序遵循:

  1. web.xml中声明顺序优先
  2. @WebListener注解按类名哈希排序
  3. 混合注册时,web.xml优先于注解

建议:在关键业务监听器中避免依赖执行顺序,确保各监听器独立工作。

Spring监听器机制

Spring框架通过ApplicationEventPublisher与ApplicationListener构建了强大的事件系统,成为实现松耦合架构的核心机制。与Servlet监听器不同,Spring事件完全由应用容器管理,不依赖Web容器,支持同步与异步处理,是现代Java应用开发的必备技能。

1. 核心组件解析

Spring事件体系包含三个核心组件:

ApplicationEvent

事件基类,所有自定义事件需继承此类。Spring 4.2后支持无继承方式,但继承类更符合语义。

ApplicationListener

监听器接口,处理特定事件类型。Spring 4.2后推荐使用@EventListener注解替代。

ApplicationEventPublisher

事件发布者,通过自动注入即可使用,支持同步与异步发布。

2. 声明式监听器(@EventListener)

Spring 4.2引入的注解驱动方式,极大简化监听器开发,支持条件表达式与泛型事件类型推断。

基础监听器实现:

@Component
public class OrderEventListeners {
  // 监听自定义事件
  @EventListener
  public void handleOrderCreated(OrderCreatedEvent event) {
    logger.info("订单创建: {}", event.getOrder().getId());
    // 发送通知
  }
  // 监听Spring内置事件
  @EventListener
  public void handleContextRefresh(ContextRefreshedEvent event) {
    logger.info("应用上下文已刷新");
  }
  // 监听所有ApplicationEvent
  @EventListener
  public void handleGenericEvent(ApplicationEvent event) {
    logger.debug("通用事件: {}", event.getClass().getSimpleName());
  }
}

异步事件处理需配置TaskExecutor:

@Configuration
@EnableAsync
public class AsyncConfig {
  @Bean(name = "eventExecutor")
  public Executor eventExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(5);
    executor.setMaxPoolSize(10);
    executor.setQueueCapacity(200);
    executor.setThreadNamePrefix("event-async-");
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
  }
}
@Component
public class AsyncOrderListener {
  @Async("eventExecutor")
  @EventListener
  public void handleOrderCreatedAsync(OrderCreatedEvent event) {
    logger.info("异步处理订单: {}", event.getOrder().getId());
    // 异步发送通知
  }
}

条件触发使用SpEL表达式:

@Component
public class ConditionalOrderListener {
  @EventListener(condition = "#event.order.amount > 1000")
  public void handleLargeOrder(OrderCreatedEvent event) {
    logger.warn("大额订单: {},金额: {}",
        event.getOrder().getId(), event.getOrder().getAmount());
    // 触发风控检查
  }
  @EventListener(condition = "#event.user.role == 'VIP'")
  public void handleVipOrder(OrderCreatedEvent event) {
    logger.info("VIP订单: {}", event.getOrder().getId());
    // 添加优先处理标记
  }
}

3. 事件发布方式

Spring提供多种事件发布方式:

通过自动注入ApplicationEventPublisher发布事件:

@Service
public class OrderService {
  private final ApplicationEventPublisher eventPublisher;
  public OrderService(ApplicationEventPublisher eventPublisher) {
    this.eventPublisher = eventPublisher;
  }
  public Order createOrder(Order order) {
    // 业务逻辑...
    Order saved = repository.save(order);
    // 发布事件
    eventPublisher.publishEvent(new OrderCreatedEvent(this, saved));
    return saved;
  }
}

手动获取事件发布者(适用于工具类):

@Component
public class EventUtil implements ApplicationContextAware {
  private static ApplicationContext context;
  @Override
  public void setApplicationContext(ApplicationContext applicationContext) {
    context = applicationContext;
  }
  public static void publish(Object event) {
    context.publishEvent(event);
  }
}
// 使用
EventUtil.publish(new OrderCreatedEvent(order));

4. 事件传播与异常处理

Spring事件机制支持复杂的传播场景:

事件传播

当监听器中触发新事件时,新事件也会被其他监听器捕获,形成事件链。需注意循环依赖问题:

@Component
public class EventChainListener {
  @Autowired
  private ApplicationEventPublisher publisher;
  @EventListener
  public void handleEventA(EventA event) {
    logger.info("处理事件A");
    publisher.publishEvent(new EventB(event.getSource()));
  }
  @EventListener
  public void handleEventB(EventB event) {
    logger.info("处理事件B");
  }
}

异常处理

监听器抛出异常时,默认会中断事件传播,但不影响事务。可通过ApplicationEventMulticaster自定义异常处理:

@Bean
public ApplicationEventMulticaster applicationEventMulticaster() {
  SimpleApplicationEventMulticaster multicaster =
      new SimpleApplicationEventMulticaster();
  multicaster.setErrorHandler(ex ->
      logger.error("事件处理异常", ex));
  return multicaster;
}

5. 实战应用案例

以下是一个完整的订单处理事件流:

// 事件定义
public class OrderEvent extends ApplicationEvent {
  private final Order order;
  public OrderEvent(Object source, Order order) {
    super(source);
    this.order = order;
  }
  public Order getOrder() { return order; }
}
// 监听器
@Component
public class OrderEventListeners {
  @EventListener
  @Async("eventExecutor")
  public void sendNotification(OrderEvent event) {
    notificationService.send(event.getOrder());
  }
  @EventListener(condition = "#event.order.amount > 10000")
  @Transactional
  public void updateInventory(OrderEvent event) {
    inventoryService.deduct(event.getOrder());
  }
  @EventListener
  public void logAudit(OrderEvent event) {
    auditLogService.record(event.getOrder(), "CREATED");
  }
}
// 服务层发布
@Service
public class OrderService {
  @Autowired
  private ApplicationEventPublisher publisher;
  @Transactional
  public Order createOrder(Order order) {
    // 业务逻辑...
    publisher.publishEvent(new OrderEvent(this, order));
    return order;
  }
}

此设计实现:

  • 解耦核心业务与通知/审计逻辑
  • 大额订单单独处理,避免阻塞主流程
  • 异步处理通知,提升响应速度

自定义监听器设计

当标准监听器无法满足业务需求时,开发者可基于Java标准库或第三方框架构建自定义监听器。此类监听器虽需手动管理注册与生命周期,但灵活性极高,适用于特殊场景与框架集成。

1. 基础实现模式

自定义监听器的核心是定义事件对象、监听器接口与事件发布者。

最小化实现:

// 事件对象
public class PaymentEvent {
  private final Payment payment;
  private final long timestamp;
  public PaymentEvent(Payment payment) {
    this.payment = payment;
    this.timestamp = System.currentTimeMillis();
  }
  public Payment getPayment() { return payment; }
  public long getTimestamp() { return timestamp; }
}
// 监听器接口
public interface PaymentListener {
  void onPaymentProcessed(PaymentEvent event);
}
// 事件发布者
public class PaymentEventPublisher {
  private final List listeners = new CopyOnWriteArrayList<>();
  public void addListener(PaymentListener listener) {
    listeners.add(listener);
  }
  public void removeListener(PaymentListener listener) {
    listeners.remove(listener);
  }
  public void publish(PaymentEvent event) {
    for (PaymentListener listener : listeners) {
      listener.onPaymentProcessed(event);
    }
  }
}

线程安全改进:

public class ConcurrentEventPublisher {
  private final List listeners =
      Collections.synchronizedList(new ArrayList<>());
  public void publish(Event event) {
    listeners.forEach(listener -> {
      try {
        listener.onEvent(event);
      } catch (Exception ex) {
        logger.error("监听器执行失败", ex);
      }
    });
  }
}
// 或使用Reactive Streams
public class AsyncEventPublisher {
  private final List listeners = new CopyOnWriteArrayList<>();
  public void publishAsync(Event event) {
    listeners.forEach(listener ->
        CompletableFuture.runAsync(() -> {
          try { listener.onEvent(event); }
          catch (Exception ex) { logger.error("异步处理失败", ex); }
        }));
  }
}

泛型事件支持:

// 泛型事件
public class GenericEvent {
  private final T payload;
  private final String eventType;
  public GenericEvent(T payload, String eventType) {
    this.payload = payload;
    this.eventType = eventType;
  }
  public T getPayload() { return payload; }
  public String getEventType() { return eventType; }
}
// 泛型监听器
public interface GenericListener {
  void onEvent(GenericEvent event);
}
// 具体监听器
@Component
public class UserUpdatedListener implements GenericListener {
  @Override
  public void onEvent(GenericEvent event) {
    if ("USER_UPDATED".equals(event.getEventType())) {
      logger.info("用户更新: {}", event.getPayload().getId());
    }
  }
}

2. 与Spring集成

自定义监听器可通过Spring容器管理,实现自动注册与依赖注入:

自动注册监听器:

@Component
public class ListenerRegistrar implements ApplicationListener {
  @Autowired
  private PaymentEventPublisher publisher;
  @Autowired
  private List listeners;
  @Override
  public void onApplicationEvent(ContextRefreshedEvent event) {
    listeners.forEach(publisher::addListener);
    logger.info("已注册{}个监听器", listeners.size());
  }
}
// 使用示例
@Component
public class PaymentNotificationListener implements PaymentListener {
  @Autowired
  private NotificationService notificationService;
  @Override
  public void onPaymentProcessed(PaymentEvent event) {
    notificationService.send(event.getPayment());
  }
}

通过BeanPostProcessor自动注册:

@Component
public class ListenerAutoRegistrar implements BeanPostProcessor {
  private final PaymentEventPublisher publisher;
  public ListenerAutoRegistrar(PaymentEventPublisher publisher) {
    this.publisher = publisher;
  }
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean instanceof PaymentListener) {
      publisher.addListener((PaymentListener) bean);
      logger.debug("自动注册监听器: {}", beanName);
    }
    return bean;
  }
}

3. 高级特性实现

构建生产级监听器系统需考虑以下高级特性:

事件过滤器:

public class FilteredEventPublisher {
  private final List listeners = new ArrayList<>();
  public void addListener(FilterableListener listener, String... filters) {
    listener.setFilters(Arrays.asList(filters));
    listeners.add(listener);
  }
  public void publish(Event event) {
    listeners.forEach(listener -> {
      if (listener.getFilters().isEmpty() ||
          listener.getFilters().contains(event.getType())) {
        listener.onEvent(event);
      }
    });
  }
}
public interface FilterableListener {
  void onEvent(Event event);
  void setFilters(List filters);
  List getFilters();
}

执行顺序控制:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface ListenerOrder {
  int value() default 0;
}
@Component
@ListenerOrder(1)
public class FirstListener implements EventListener { ... }
@Component
@ListenerOrder(2)
public class SecondListener implements EventListener { ... }
// 有序发布
public class OrderedPublisher {
  public void publish(Event event) {
    listeners.stream()
        .sorted(Comparator.comparingInt(l ->
            l.getClass().getAnnotation(ListenerOrder.class).value()))
        .forEach(listener -> listener.onEvent(event));
  }
}

重试与失败处理:

public class RetryableListener implements EventListener {
  private static final int MAX_RETRIES = 3;
  @Override
  public void onEvent(Event event) {
    int attempt = 0;
    while (attempt < MAX_RETRIES) {
      try {
        // 处理逻辑
        process(event);
        return; // 成功则退出
      } catch (TemporaryException e) {
        attempt++;
        logger.warn("重试 {} 次: {}", attempt, e.getMessage());
        Thread.sleep(1000 * attempt);
      } catch (PermanentException e) {
        logger.error("永久失败", e);
        return;
      }
    }
    logger.error("超过最大重试次数");
  }
}

4. 监听器生命周期管理

自定义监听器需手动管理注册与注销:

@Component
public class ListenerManager implements DisposableBean {
  private final PaymentEventPublisher publisher;
  private final List tempListeners = new ArrayList<>();
  public ListenerManager(PaymentEventPublisher publisher) {
    this.publisher = publisher;
  }
  public void registerTempListener(PaymentListener listener) {
    publisher.addListener(listener);
    tempListeners.add(listener);
  }
  @Override
  public void destroy() {
    tempListeners.forEach(publisher::removeListener);
    logger.info("已清理{}个临时监听器", tempListeners.size());
  }
}

此设计确保监听器在应用关闭时正确清理,避免内存泄漏。

JAVA监听器实战应用

本节通过完整案例展示JAVA监听器

1. 电商订单事件流

构建完整的订单生命周期事件系统,实现业务解耦与扩展性提升。

事件定义

// 订单事件基类
public abstract class OrderEvent extends ApplicationEvent {
  protected final Order order;
  public OrderEvent(Object source, Order order) {
    super(source);
    this.order = order;
  }
  public Order getOrder() { return order; }
}
// 订单创建事件
public class OrderCreatedEvent extends OrderEvent {
  public OrderCreatedEvent(Object source, Order order) {
    super(source, order);
  }
}
// 支付成功事件
public class PaymentSuccessEvent extends OrderEvent {
  private final PaymentMethod method;
  public PaymentSuccessEvent(Object source, Order order, PaymentMethod method) {
    super(source, order);
    this.method = method;
  }
  public PaymentMethod getMethod() { return method; }
}
// 订单取消事件
public class OrderCancelledEvent extends OrderEvent {
  private final CancelReason reason;
  public OrderCancelledEvent(Object source, Order order, CancelReason reason) {
    super(source, order);
    this.reason = reason;
  }
  public CancelReason getReason() { return reason; }
}

监听器实现

@Component
public class OrderEventListeners {
  @Autowired
  private NotificationService notificationService;
  @Autowired
  private InventoryService inventoryService;
  @Autowired
  private AuditLogService auditLogService;
  // 订单创建后处理
  @EventListener
  @Async("eventExecutor")
  public void onOrderCreated(OrderCreatedEvent event) {
    Order order = event.getOrder();
    // 记录审计日志
    auditLogService.record(order.getId(), "ORDER_CREATED", null);
    // 发送通知
    notificationService.sendOrderCreated(order);
    // 预占库存
    inventoryService.reserve(order.getItems());
  }
  // 支付成功处理
  @EventListener
  @Async("eventExecutor")
  public void onPaymentSuccess(PaymentSuccessEvent event) {
    Order order = event.getOrder();
    // 更新订单状态
    order.setStatus(OrderStatus.PAID);
    // 真正扣减库存
    inventoryService.deduct(order.getItems());
    // 发送支付成功通知
    notificationService.sendPaymentSuccess(order, event.getMethod());
    // 记录审计日志
    auditLogService.record(order.getId(), "PAYMENT_SUCCESS",
        event.getMethod().name());
  }
  // 订单取消处理
  @EventListener
  @Transactional
  public void onOrderCancelled(OrderCancelledEvent event) {
    Order order = event.getOrder();
    // 释放预占库存
    inventoryService.release(order.getItems());
    // 发送取消通知
    notificationService.sendOrderCancelled(order, event.getReason());
    // 记录审计日志
    auditLogService.record(order.getId(), "ORDER_CANCELLED",
        event.getReason().name());
  }
  // 大额订单特殊处理
  @EventListener(condition = "#event.order.amount > 10000")
  public void onLargeOrder(OrderCreatedEvent event) {
    Order order = event.getOrder();
    // 触发风控检查
    riskCheckService.check(order);
    // 标记为VIP订单
    order.setPriority(OrderPriority.HIGH);
  }
}

服务层集成

@Service
public class OrderService {
  @Autowired
  private ApplicationEventPublisher publisher;
  @Transactional
  public Order createOrder(Order order) {
    // 业务逻辑...
    Order saved = repository.save(order);
    // 发布事件
    publisher.publishEvent(new OrderCreatedEvent(this, saved));
    return saved;
  }
  @Transactional
  public void processPayment(String orderId, PaymentMethod method) {
    Order order = repository.findById(orderId)
        .orElseThrow(() -> new OrderNotFoundException(orderId));
    // 支付逻辑...
    paymentService.process(order, method);
    // 发布支付成功事件
    publisher.publishEvent(new PaymentSuccessEvent(this, order, method));
  }
}

2. 用户行为追踪系统

通过监听器实现用户行为数据采集与分析,支持实时与离线处理。

// 行为事件基类
public abstract class UserBehaviorEvent {
  protected final String userId;
  protected final String sessionId;
  protected final long timestamp;
  protected final String ip;
  protected final String userAgent;
  public UserBehaviorEvent(String userId, String sessionId) {
    this.userId = userId;
    this.sessionId = sessionId;
    this.timestamp = System.currentTimeMillis();
    // 从当前请求获取
    HttpServletRequest request = ((ServletRequestAttributes)
        RequestContextHolder.currentRequestAttributes()).getRequest();
    this.ip = request.getRemoteAddr();
    this.userAgent = request.getHeader("User-Agent");
  }
  // Getter methods...
}
// 页面浏览事件
public class PageViewEvent extends UserBehaviorEvent {
  private final String url;
  private final String referer;
  public PageViewEvent(String userId, String sessionId, String url) {
    super(userId, sessionId);
    this.url = url;
    HttpServletRequest request = ((ServletRequestAttributes)
        RequestContextHolder.currentRequestAttributes()).getRequest();
    this.referer = request.getHeader("Referer");
  }
}
// 点击事件
public class ClickEvent extends UserBehaviorEvent {
  private final String elementId;
  private final String elementType;
  public ClickEvent(String userId, String sessionId,
      String elementId, String elementType) {
    super(userId, sessionId);
    this.elementId = elementId;
    this.elementType = elementType;
  }
}
// 购物车操作事件
public class CartEvent extends UserBehaviorEvent {
  private final CartOperation operation;
  private final String productId;
  private final Integer quantity;
  public CartEvent(String userId, String sessionId,
      CartOperation operation, String productId, Integer quantity) {
    super(userId, sessionId);
    this.operation = operation;
    this.productId = productId;
    this.quantity = quantity;
  }
}
@Component
public class BehaviorTrackingListeners {
  @Autowired
  private BehaviorAnalyticsService analyticsService;
  @Autowired
  private UserBehaviorRepository repository;
  // 页面浏览处理
  @EventListener
  public void onPageView(PageViewEvent event) {
    // 保存到数据库
    repository.save(new UserBehavior(event));
    // 实时分析
    analyticsService.trackPageView(event);
    // 更新会话统计
    analyticsService.updateSessionStats(event.getSessionId(),
        session -> session.addPageView(event.getUrl()));
  }
  // 点击处理
  @EventListener
  public void onClick(ClickEvent event) {
    // 保存到数据库
    repository.save(new UserBehavior(event));
    // 实时分析
    analyticsService.trackClick(event);
    // 检测异常点击模式
    if (analyticsService.isSuspiciousClick(event)) {
      // 触发安全警报
    }
  }
  // 购物车操作处理
  @EventListener
  public void onCart(CartEvent event) {
    // 保存到数据库
    repository.save(new UserBehavior(event));
    // 实时分析
    analyticsService.trackCart(event);
    // 购物车 abandoned 检测
    if (event.getOperation() == CartOperation.REMOVE) {
      analyticsService.checkAbandonedCart(event);
    }
  }
  // 会话结束处理
  @EventListener
  public void onSessionEnd(SessionEndEvent event) {
    // 生成会话报告
    analyticsService.generateSessionReport(event.getSessionId());
    // 更新用户画像
    analyticsService.updateUserProfile(event.getUserId());
  }
}

3. 系统监控与告警

通过监听器实现关键业务指标监控,支持动态配置告警阈值。

// 系统事件基类
public abstract class SystemEvent {
  protected final String eventType;
  protected final long timestamp;
  protected final Map metadata;
  public SystemEvent(String eventType) {
    this.eventType = eventType;
    this.timestamp = System.currentTimeMillis();
    this.metadata = new ConcurrentHashMap<>();
  }
  public SystemEvent addMetadata(String key, Object value) {
    metadata.put(key, value);
    return this;
  }
  // Getter methods...
}
// 性能事件
public class PerformanceEvent extends SystemEvent {
  public PerformanceEvent(String metric, double value) {
    super("PERFORMANCE");
    addMetadata("metric", metric)
       .addMetadata("value", value);
  }
}
// 错误事件
public class ErrorEvent extends SystemEvent {
  private final Throwable throwable;
  public ErrorEvent(String errorType, Throwable throwable) {
    super("ERROR");
    addMetadata("errorType", errorType);
    this.throwable = throwable;
  }
  public Throwable getThrowable() { return throwable; }
}
// 告警事件
public class AlertEvent extends SystemEvent {
  private final AlertLevel level;
  private final String message;
  public AlertEvent(AlertLevel level, String message) {
    super("ALERT");
    addMetadata("level", level)
       .addMetadata("message", message);
    this.level = level;
    this.message = message;
  }
  public AlertLevel getLevel() { return level; }
  public String getMessage() { return message; }
}
@Component
public class MonitoringListeners {
  @Autowired
  private MonitoringConfig config;
  @Autowired
  private AlertService alertService;
  @Autowired
  private MetricsRepository metricsRepository;
  // 性能监控
  @EventListener
  public void onPerformance(PerformanceEvent event) {
    String metric = (String) event.getMetadata().get("metric");
    double value = (double) event.getMetadata().get("value");
    // 保存指标
    metricsRepository.save(new MetricEvent(event));
    // 检查阈值
    if (config.getThresholds().containsKey(metric)) {
      double threshold = config.getThresholds().get(metric);
      if (value > threshold) {
        // 发送告警
        alertService.send(new AlertEvent(AlertLevel.WARNING,
            String.format("%s超过阈值: %.2f > %.2f", metric, value, threshold)));
      }
    }
  }
  // 错误监控
  @EventListener
  public void onError(ErrorEvent event) {
    String errorType = (String) event.getMetadata().get("errorType");
    // 保存错误日志
    logger.error("系统错误 [{}]: {}", errorType, event.getThrowable().getMessage());
    // 检查是否需要告警
    if (config.getErrorThresholds().containsKey(errorType)) {
      int count = metricsRepository.getErrorCount(errorType,
          Duration.ofMinutes(5));
      if (count >= config.getErrorThresholds().get(errorType)) {
        alertService.send(new AlertEvent(AlertLevel.CRITICAL,
            String.format("%s错误频率过高: %d次/5分钟", errorType, count)));
      }
    }
    // 特殊错误处理
    if (event.getThrowable() instanceof OutOfMemoryError) {
      alertService.send(new AlertEvent(AlertLevel.CRITICAL,
          "内存溢出错误,立即处理!"));
    }
  }
  // 告警处理
  @EventListener
  public void onAlert(AlertEvent event) {
    // 发送通知
    alertService.notify(event);
    // 记录到监控系统
    monitoringService.record(event);
    // 自动响应
    if (event.getLevel() == AlertLevel.CRITICAL) {
      alertService.triggerAutoResponse(event);
    }
  }
  // 配置热更新
  @EventListener
  public void onConfigUpdate(ConfigUpdateEvent event) {
    if ("monitoring".equals(event.getTarget())) {
      // 重新加载监控配置
      config.reload();
      logger.info("监控配置已更新");
    }
  }
}

4. 插件式扩展机制

通过监听器实现插件式架构,支持第三方扩展点。

// 插件接口
public interface OrderPlugin {
  String getName();
  Order process(Order order);
  int getPriority();
}
// 插件管理器
@Component
public class OrderPluginManager {
  private final List plugins = new ArrayList<>();
  @Autowired
  public OrderPluginManager(List pluginList) {
    plugins.addAll(pluginList);
    plugins.sort(Comparator.comparingInt(OrderPlugin::getPriority));
  }
  public Order process(Order order) {
    for (OrderPlugin plugin : plugins) {
      order = plugin.process(order);
    }
    return order;
  }
}
// 具体插件示例
@Component
@Order(1)
public class VipDiscountPlugin implements OrderPlugin {
  @Override
  public String getName() { return "VIP折扣"; }
  @Override
  public Order process(Order order) {
    if ("VIP".equals(order.getUser().getType())) {
      order.setDiscount(order.getAmount() * 0.9);
    }
    return order;
  }
  @Override
  public int getPriority() { return 1; }
}
@Component
@Order(2)
public class CouponPlugin implements OrderPlugin {
  @Override
  public String getName() { return "优惠券"; }
  @Override
  public Order process(Order order) {
    if (order.getUser().getCoupons() > 0) {
      order.setCouponDiscount(50.0);
    }
    return order;
  }
  @Override
  public int getPriority() { return 2; }
}
// 订单服务集成
@Service
public class OrderService {
  @Autowired
  private OrderPluginManager pluginManager;
  public Order createOrder(Order order) {
    // 处理订单
    order = pluginManager.process(order);
    // 保存订单
    return repository.save(order);
  }
}

此设计实现:

  • 监听器作为插件入口点
  • 通过优先级控制执行顺序
  • 支持动态扩展插件

常见问题与解决方案

本节整理JAVA监听器

1. 监听器注册与调用问题

Q: 为什么监听器没有被触发?

A: 检查以下常见原因:

  • 监听器未被Spring容器管理(缺少@Component等注解)
  • 事件发布者未注入ApplicationEventPublisher
  • 事件类型不匹配(监听器处理特定类型事件)
  • 条件表达式不满足(@EventListener的condition)
  • 异步监听器的线程池配置错误

Q: 监听器执行顺序不确定?

A: Spring默认不保证监听器执行顺序。解决方案:

  • 使用@Order注解指定优先级
  • 实现Ordered接口
  • 自定义监听器管理器控制顺序

2. 性能与稳定性问题

JAVA监听器

  • 监听器内避免阻塞操作,使用@Async异步处理
  • 使用CopyOnWriteArrayList等并发集合
  • 限制监听器数量,定期清理无效监听器
  • 对高频事件使用事件聚合(如批量处理)

示例:批量处理用户行为事件

@Component
public class BatchBehaviorListener {
  private final List buffer = new ArrayList<>();
  private final ScheduledExecutorService scheduler =
      Executors.newSingleThreadScheduledExecutor();
  @PostConstruct
  public void init() {
    scheduler.scheduleWithFixedDelay(this::flushBuffer,
        5, 5, TimeUnit.SECONDS);
  }
  @EventListener
  public void onBehavior(UserBehaviorEvent event) {
    synchronized (buffer) {
      buffer.add(event);
      if (buffer.size() >= 100) {
        flushBuffer();
      }
    }
  }
  private void flushBuffer() {
    synchronized (buffer) {
      if (buffer.isEmpty()) return;
      behaviorService.batchSave(new ArrayList<>(buffer));
      buffer.clear();
    }
  }
}

内存泄漏常见原因与解决方案:

  • 监听器未注销:确保在组件销毁时移除监听器
  • 静态集合持有引用:使用WeakReference包装监听器
  • 循环引用:避免监听器与事件源相互引用

安全监听器注册示例:

public class SafePublisher {
  private final Set listeners =
      Collections.newSetFromMap(new WeakHashMap<>());
  public void addListener(EventListener listener) {
    listeners.add(listener);
  }
  public void removeListener(EventListener listener) {
    listeners.remove(listener);
  }
  public void publish(Event event) {
    // 创建副本避免ConcurrentModificationException
    for (EventListener listener : new ArrayList<>(listeners)) {
      try {
        listener.onEvent(event);
      } catch (Exception ex) {
        logger.error("监听器执行失败", ex);
      }
    }
  }
}

3. 事务与异常处理

JAVA监听器

  • 默认情况下,监听器与事件发布在同一事务中
  • 异步监听器在独立事务中执行
  • 事务回滚时,事件不会发布

事务控制建议:

@Component
public class TransactionalListener {
  @EventListener
  @Transactional
  public void handleEvent(Event event) {
    // 此监听器在独立事务中执行
  }
  @EventListener
  public void handleEventAsync(Event event) {
    // 异步监听器自动在独立事务中执行
  }
}

监听器异常处理最佳实践:

  • 监听器内部捕获并处理异常
  • 记录详细日志,避免异常传播
  • 使用@Async时配置ErrorHandler
  • 对关键事件实现重试机制

全局异常处理器:

@Component
public class GlobalEventListenerExceptionHandler
    implements ApplicationListener {
  @Override
  public void onApplicationEvent(ThrowableEvent event) {
    logger.error("监听器异常", event.getThrowable());
    alertService.send(event.getThrowable());
  }
}
// 使用
@EventListener
public void handleEvent(Event event) {
  try {
    // 业务逻辑
  } catch (Exception ex) {
    publisher.publishEvent(new ThrowableEvent(ex));
  }
}

4. 特殊场景解决方案

分布式系统中事件传播方案:

  • 使用消息队列(Kafka/RabbitMQ)实现跨服务事件
  • 结合Spring Cloud Stream构建事件总线
  • 使用Redis发布订阅实现本地缓存同步

Kafka集成示例:

@Component
public class DistributedEventPublisher {
  @Autowired
  private KafkaTemplate kafkaTemplate;
  @EventListener
  public void publishToKafka(Event event) {
    kafkaTemplate.send("event-topic",
        objectMapper.writeValueAsString(event));
  }
}
@Component
public class DistributedEventListener {
  @KafkaListener(topics = "event-topic")
  public void consumeEvent(String eventData) {
    Event event = objectMapper.readValue(eventData, Event.class);
    // 处理事件
  }
}

单元测试监听器方法:

@SpringBootTest
class OrderEventListenerTest {
  @Autowired
  private ApplicationEventPublisher publisher;
  @Autowired
  private MockMvc mockMvc;
  @Test
  void testOrderCreatedEvent() {
    // 模拟订单创建
    mockMvc.post("/orders")
        .andExpect(status().isOk());
    // 验证监听器执行
    // 1. 检查数据库记录
    // 2. 检查通知发送
    // 3. 检查库存更新
  }
  // 手动触发事件
  @Test
  void testListener() {
    Order order = new Order();
    publisher.publishEvent(new OrderCreatedEvent(this, order));
    // 验证结果
  }
}

工具与资源

本节推荐JAVA监听器

1. 开发工具

推荐IDE配置:

  • IntelliJ IDEA:
    • 安装Spring Assistant插件,可视化事件流
    • 启用"Optimize Imports on the Fly"自动整理导入
    • 配置Spring Event Navigation插件
  • Eclipse:
    • 安装Spring Tools Suite插件
    • 启用"Save Actions"自动格式化代码

调试技巧:

  • 使用Spring Boot DevTools实现热部署
  • 配置日志级别:logging.level.org.springframework.context.event=DEBUG
  • 使用@ConditionalOnProperty动态启用监听器

日志配置示例:

logging:
  level:
    org.springframework.context.event: DEBUG
    com.example.listeners: TRACE
  pattern:
    console: "%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n"

2. 第三方库

Spring Boot Event Libraries

  • spring-boot-starter-web:基础Web支持
  • spring-boot-starter-data-jpa:数据库事件支持
  • spring-boot-starter-redis:Redis事件总线
  • spring-cloud-stream:消息中间件集成

监控与分析工具

  • Spring Boot Actuator:健康检查与指标暴露
  • Prometheus + Grafana:事件指标可视化
  • Elastic APM:分布式事件追踪

3. 学习资源

官方文档

推荐书籍

  • 《Spring微服务实战》 - John Carnell
  • 《Java事件驱动架构》 - Mark Richards
  • 《Spring Boot实战》 - Craig Walls

在线资源

4. 代码模板库

以下提供常用JAVA监听器

// Servlet监听器模板
import javax.servlet.annotation.WebListener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
@WebListener
public class AppStartupListener implements ServletContextListener {
  @Override
  public void contextInitialized(ServletContextEvent sce) {
    // 初始化逻辑
  }
  @Override
  public void contextDestroyed(ServletContextEvent sce) {
    // 清理逻辑
  }
}
// Spring监听器模板
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;
@Component
public class OrderCreatedListener implements ApplicationListener {
  @Override
  public void onApplicationEvent(OrderCreatedEvent event) {
    // 处理逻辑
  }
}
// 或使用@EventListener
@Component
public class OrderCreatedListener {
  @EventListener
  public void handleOrderCreated(OrderCreatedEvent event) {
    // 处理逻辑
  }
}

总结

JAVA监听器

通过本文的深入探讨,我们系统性地学习了:

  • 监听器的分类体系与适用场景
  • Servlet监听器的完整生命周期管理
  • Spring监听器的声明式与异步处理
  • 自定义监听器的高级设计模式
  • 电商、行为追踪、系统监控等实战案例
  • 常见问题与最佳实践

掌握JAVA监听器

网站持续更新更多监听器实践案例与最佳实践,欢迎关注:www.xservx.com

JAVA监听器 - 专业Java事件驱动开发指南

官方网站:www.xservx.com

备案号:蜀ICP备2026035467号-3

© 2026 JAVA监听器. All rights reserved.