Java Spring 中的监听器(Listener)详解与实战教程

一、Spring 监听器概述

在Spring框架中，监听器(Listener)是一种非常重要的机制，它允许应用程序对特定事件做出响应。Spring的监听器机制基于观察者模式(Observer Pattern)，当某个事件发生时，所有注册的监听器都会收到通知并执行相应的处理逻辑。

Spring中的监听器主要分为以下几类：

Servlet容器监听器：基于Servlet规范的监听器，用于监听Web应用生命周期事件
Spring应用上下文监听器：监听Spring应用上下文的生命周期事件
自定义事件监听器：监听应用程序自定义的事件

二、Servlet容器监听器

这些监听器实现了javax.servlet.ServletContextListener、javax.servlet.ServletRequestListener等接口，用于监听Web容器的生命周期事件。

1. 常用Servlet容器监听器接口

ServletContextListener：监听Web应用的启动和销毁事件
ServletContextAttributeListener：监听Web应用上下文属性的变化
ServletRequestListener：监听HTTP请求的创建和销毁
ServletRequestAttributeListener：监听HTTP请求属性的变化
HttpSessionListener：监听HTTP会话的创建和销毁
HttpSessionAttributeListener：监听HTTP会话属性的变化

2. 实现示例

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Web应用启动了！");
        // 可以在这里进行一些初始化操作，如加载配置、初始化资源等
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Web应用销毁了！");
        // 可以在这里进行一些清理操作，如释放资源等
    }
}

注意：如果使用的是Spring Boot，通常不需要直接使用Servlet容器监听器，因为Spring Boot提供了更高级的抽象。

三、Spring应用上下文监听器

Spring提供了自己的应用上下文监听器机制，用于监听Spring容器的生命周期事件。

1. 常用Spring应用上下文监听器接口

ApplicationContextAware：使Bean可以获取ApplicationContext引用
ApplicationListener<E>：监听特定类型的事件
ApplicationEventPublisherAware：使Bean可以发布事件

2. 实现示例

2.1 监听Spring上下文启动事件

import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

@Component
public class MyContextRefreshedListener implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 当Spring上下文初始化或刷新时执行
        System.out.println("Spring上下文已初始化或刷新！");
        // 可以在这里进行一些初始化操作
    }
}

2.2 监听自定义事件

首先定义一个自定义事件：

import org.springframework.context.ApplicationEvent;

public class MyCustomEvent extends ApplicationEvent {
    private String message;

    public MyCustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

然后创建监听器：

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyCustomEventListener implements ApplicationListener<MyCustomEvent> {

    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        System.out.println("收到自定义事件: " + event.getMessage());
        // 处理自定义事件
    }
}

发布自定义事件：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

@Service
public class MyEventPublisherService {

    @Autowired
    private ApplicationContext applicationContext;

    public void publishCustomEvent(final String message) {
        System.out.println("发布自定义事件: " + message);
        MyCustomEvent customEvent = new MyCustomEvent(this, message);
        applicationContext.publishEvent(customEvent);
    }
}

四、Spring Boot中的监听器

在Spring Boot中，监听器的使用更加简单，通常不需要直接使用Servlet容器监听器，而是使用Spring的事件机制。

1. Spring Boot启动完成监听器

import org.springframework.boot.context.event.ApplicationReadyEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyApplicationReadyListener implements ApplicationListener<ApplicationReadyEvent> {

    @Override
    public void onApplicationEvent(ApplicationReadyEvent event) {
        System.out.println("Spring Boot应用已启动完成，可以开始处理业务逻辑了！");
        // 可以在这里执行一些需要在应用启动后立即执行的操作
    }
}

2. Spring Boot环境准备就绪监听器

import org.springframework.boot.context.event.ApplicationEnvironmentPreparedEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

@Component
public class MyEnvironmentPreparedListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {

    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        Environment env = event.getEnvironment();
        System.out.println("Spring Boot环境已准备就绪，当前环境: " + env.getActiveProfiles());
        // 可以在这里根据环境进行一些配置
    }
}

五、实战应用场景

1. 系统初始化

在应用启动时加载配置、初始化缓存、建立数据库连接池等：

@Component
public class SystemInitializer implements ApplicationListener<ContextRefreshedEvent> {

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (event.getApplicationContext().getParent() == null) { // 确保是根上下文
            // 加载系统配置
            loadSystemConfig();
            // 初始化缓存
            initCache();
            // 建立数据库连接池
            initDatabaseConnectionPool();
        }
    }

    private void loadSystemConfig() {
        // 加载配置逻辑
    }

    private void initCache() {
        // 初始化缓存逻辑
    }

    private void initDatabaseConnectionPool() {
        // 初始化数据库连接池逻辑
    }
}

2. 业务事件处理

例如订单创建后发送通知：

// 自定义事件
public class OrderCreatedEvent extends ApplicationEvent {
    private Order order;

    public OrderCreatedEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }

    public Order getOrder() {
        return order;
    }
}

// 监听器
@Component
public class OrderNotificationListener implements ApplicationListener<OrderCreatedEvent> {

    @Override
    public void onApplicationEvent(OrderCreatedEvent event) {
        Order order = event.getOrder();
        // 发送通知逻辑，如短信、邮件等
        sendNotification(order);
    }

    private void sendNotification(Order order) {
        // 发送通知实现
    }
}

// 事件发布者
@Service
public class OrderService {

    @Autowired
    private ApplicationContext applicationContext;

    public void createOrder(Order order) {
        // 创建订单逻辑
        // ...

        // 发布订单创建事件
        applicationContext.publishEvent(new OrderCreatedEvent(this, order));
    }
}

3. 异步事件处理

对于耗时操作，可以使用异步事件处理：

import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class AsyncOrderProcessor {

    @Async
    @EventListener
    public void processOrder(OrderCreatedEvent event) {
        // 异步处理订单
        System.out.println("异步处理订单: " + event.getOrder().getId());
        // 耗时操作...
    }
}

需要在配置类上启用异步支持：

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
    // 可以配置线程池等
}