ServletRequestListener 的用法笔记250417

发布于：2025-04-18 ⋅ 阅读:(18) ⋅ 点赞:(0)

ServletRequestListener 的用法笔记250417

ServletRequestListener 是 Java Servlet 规范中用于监听 HTTP 请求生命周期的接口，可以在请求创建时和销毁时触发自定义逻辑。以下是其核心用法、示例及典型场景：

核心用法步骤

1. 实现 ServletRequestListener 接口
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener // Servlet 3.0+ 使用注解配置（无需 web.xml）
public class MyRequestListener implements ServletRequestListener {

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // 请求创建时触发
        System.out.println("HTTP 请求创建：" + sre.getServletRequest().getRemoteAddr());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        // 请求销毁时触发
        System.out.println("HTTP 请求销毁：" + sre.getServletRequest().getRemoteAddr());
    }
}
2. 配置监听器
  • 方式一：使用 web.xml（兼容所有版本）
    <listener>
    <listener-class>com.example.MyRequestListener</listener-class>
</listener>
  • 方式二：使用 @WebListener 注解（Servlet 3.0+）
    直接在类上添加注解即可（如上例）。

典型应用场景

1. 请求性能监控
@Override
public void requestInitialized(ServletRequestEvent sre) {
    // 记录请求开始时间
    sre.getServletRequest().setAttribute("startTime", System.currentTimeMillis());
}

@Override
public void requestDestroyed(ServletRequestEvent sre) {
    // 计算请求耗时
    long startTime = (Long) sre.getServletRequest().getAttribute("startTime");
    long duration = System.currentTimeMillis() - startTime;
    System.out.println("请求耗时：" + duration + "ms");
}
2. 请求日志记录
@Override
public void requestInitialized(ServletRequestEvent sre) {
    HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
    String url = request.getRequestURL().toString();
    String params = request.getQueryString();
    System.out.println("请求路径：" + url + "?" + params);
}
3. 请求级资源管理
@Override
public void requestInitialized(ServletRequestEvent sre) {
    // 为每个请求初始化资源（如 ThreadLocal 变量）
    Connection conn = DatabasePool.getConnection();
    sre.getServletRequest().setAttribute("dbConnection", conn);
}

@Override
public void requestDestroyed(ServletRequestEvent sre) {
    // 请求结束时释放资源
    Connection conn = (Connection) sre.getServletRequest().getAttribute("dbConnection");
    if (conn != null) conn.close();
}

注意事项

  1. 线程安全问题
    ServletRequestListener 是单例的，但每个请求的 ServletRequest 对象是独立的，需避免在监听器中操作共享变量。

  2. 性能影响
    监听器的逻辑应尽量轻量，避免阻塞请求处理（如避免在 requestInitialized 中执行耗时操作）。

  3. 作用范围
    监听的是所有 HTTP 请求（包括静态资源请求），可通过 request.getRequestURI() 过滤特定路径。

  4. 异常处理
    在 requestDestroyed 中仍需处理可能抛出的异常，避免影响容器正常销毁请求。

与 ServletContextListener 的区别

监听器 作用范围 触发时机 典型用途
ServletContextListener 全局应用 应用启动/关闭时 初始化全局配置、连接池
ServletRequestListener 单个 HTTP 请求 每个请求创建/销毁时 日志、性能监控、资源管理
监听器 作用范围 触发时机 典型应用场景
ServletContextListener 应用级别 应用启动/关闭 全局资源管理（如连接池）
HttpSessionListener 会话级别 会话创建/销毁 在线用户统计、会话超时处理
ServletRequestListener 请求级别 每次请求开始/结束 请求日志、性能监控

总结

ServletRequestListener 是监听 HTTP 请求生命周期的核心工具，适用于需要精细化控制请求级资源的场景。通过合理使用，可以实现请求日志、性能分析、资源清理等功能，提升 Web 应用的可维护性和健壮性。







1️⃣ 参考 1

以下是关于 ServletRequestListener 的用法详解，包括核心方法、实现步骤、应用场景及注意事项：

1. 核心功能

ServletRequestListener 是用于监听 HTTP 请求生命周期 的接口，允许在每次请求开始和结束时执行自定义逻辑。适用于跟踪请求级操作（如日志记录、性能统计、请求属性初始化等）。

2. 核心方法

  • requestInitialized(ServletRequestEvent sre)
    当请求到达容器时触发（在请求处理前执行）。

  • requestDestroyed(ServletRequestEvent sre)
    当请求处理完成且响应返回后触发（资源清理阶段）。

3. 实现步骤

步骤 1：创建监听器类
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener // 注解方式注册（Servlet 3.0+）
public class CustomRequestListener implements ServletRequestListener {

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // 获取请求对象
        HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
        
        // 记录请求开始时间
        request.setAttribute("startTime", System.currentTimeMillis());
        
        // 日志记录请求信息
        System.out.println("请求开始: " + request.getRequestURI());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
        long startTime = (long) request.getAttribute("startTime");
        long duration = System.currentTimeMillis() - startTime;
        
        // 输出请求耗时
        System.out.println("请求结束: " + request.getRequestURI() + " | 耗时: " + duration + "ms");
    }
}
步骤 2：注册监听器

  • 方式一：通过 web.xml 配置

    <web-app>
    <listener>
        <listener-class>com.example.CustomRequestListener</listener-class>
    </listener>
</web-app>

  • 方式二：使用 @WebListener 注解（推荐）
    直接在类上添加 @WebListener 注解（需 Servlet 3.0+ 支持）。

4. 关键应用场景

  • 请求耗时统计：记录每个请求的处理时间。
  • 请求日志记录：跟踪请求路径、参数、来源 IP 等。
  • 请求级资源管理：在请求开始时初始化资源（如数据库连接），结束时释放。
  • 安全审计：记录可疑请求或异常访问行为。
  • 上下文属性传递：在请求范围内设置全局可访问的属性（如用户身份信息）。

5. 注意事项

(1) 线程安全问题
  • ServletRequestListener 的每个请求都在独立线程中执行，需确保代码线程安全（避免共享变量竞争）。
  • 示例：使用 ThreadLocal 存储请求级数据。
(2) 性能影响
  • 该监听器会在每次请求时触发，避免在此处执行耗时操作（如复杂计算、同步阻塞 I/O）。
(3) 请求对象类型转换
  • sre.getServletRequest() 返回的是 ServletRequest，需转换为 HttpServletRequest 以获取 HTTP 相关方法：
    HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
(4) 异常处理
  • 在 requestInitialized 中抛出异常会导致请求直接返回 500 错误，需捕获异常并处理：
    try {
    // 业务逻辑
} catch (Exception e) {
    // 记录日志或设置错误状态
}
(5) 请求销毁时机
  • requestDestroyed 的触发可能因容器实现而异（如异步请求），确保资源释放逻辑可靠。

6. 示例：记录请求参数

@Override
public void requestInitialized(ServletRequestEvent sre) {
    HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
    
    // 记录请求参数（避免敏感信息）
    Map<String, String[]> params = request.getParameterMap();
    params.forEach((key, values) -> {
        System.out.println("参数: " + key + " = " + Arrays.toString(values));
    });
}

7. 与其他监听器对比

监听器 作用范围 触发时机 典型应用场景
ServletContextListener 应用级别 应用启动/关闭 全局资源管理（如连接池）
HttpSessionListener 会话级别 会话创建/销毁 在线用户统计、会话超时处理
ServletRequestListener 请求级别 每次请求开始/结束 请求日志、性能监控

8. 最佳实践

  • 轻量化逻辑：仅执行必要操作（如记录关键日志），避免阻塞请求处理。
  • 结合 Filter 使用：若需拦截请求并修改请求/响应，优先使用 Filter。
  • 避免存储大对象：请求属性（request.setAttribute）应存放轻量级数据，防止内存泄漏。

总结

ServletRequestListener 是监控 HTTP 请求生命周期的核心工具，适用于请求级跟踪、日志记录和资源管理。合理使用可提升应用的可观测性，但需注意线程安全和性能影响。结合 ServletContextListener 和 HttpSessionListener，可构建完整的 Web 应用生命周期监控体系。







2️⃣ 参考 2

在Java Web开发中，ServletRequestListener 用于监听 单个HTTP请求的生命周期事件，它允许你在请求开始（初始化）和结束时执行自定义逻辑。以下是其核心用法：

一、核心作用

  1. 请求开始时：执行初始化操作（如记录请求时间、校验权限）。
  2. 请求结束时：执行清理操作（如统计耗时、释放临时资源）。

二、实现步骤

1. 创建监听器类

实现 javax.servlet.ServletRequestListener 接口，重写两个方法：

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpServletRequest;

@WebListener // 注解方式（Servlet 3.0+）
public class MyRequestListener implements ServletRequestListener {

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        // 请求到达时触发
        HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
        String uri = request.getRequestURI();
        long startTime = System.currentTimeMillis();
        
        request.setAttribute("startTime", startTime); // 存储开始时间
        System.out.println("请求开始: " + uri);
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        // 请求响应后触发
        HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
        long startTime = (Long) request.getAttribute("startTime");
        long duration = System.currentTimeMillis() - startTime;
        
        System.out.println("请求耗时: " + duration + "ms");
    }
}
2. 配置监听器（两种方式）

方式一：注解配置（推荐）

  • 使用 @WebListener 注解，无需额外配置。

方式二：web.xml 配置（传统方式）

<listener>
    <listener-class>com.example.MyRequestListener</listener-class>
</listener>

三、典型应用场景

  1. 请求耗时统计
    public void requestDestroyed(ServletRequestEvent sre) {
    long startTime = (Long) request.getAttribute("startTime");
    log.info("请求 {} 耗时 {}ms", request.getRequestURI(), System.currentTimeMillis() - startTime);
}
  2. 请求参数校验
    public void requestInitialized(ServletRequestEvent sre) {
    String param = request.getParameter("token");
    if (param == null || !isValidToken(param)) {
        throw new SecurityException("无效令牌");
    }
}
  3. 请求日志记录
    public void requestInitialized(ServletRequestEvent sre) {
    log.info("收到请求: {} {}", request.getMethod(), request.getRequestURI());
}

四、注意事项

  1. 性能影响：避免在监听器中执行耗时操作（如数据库查询），以免影响请求处理速度。
  2. 线程安全：监听器实例会被所有请求共享，确保代码线程安全。
  3. 作用域限制：requestDestroyed 在响应提交后触发，此时不能再修改响应内容。

五、与 Filter 的区别

特性 ServletRequestListener Filter
触发时机 请求开始/结束时 请求处理前/后
修改请求/响应 否 是
链式调用 无 支持多个Filter串联
典型用途 日志、统计、简单校验 编码转换、权限验证、日志

通过合理使用 ServletRequestListener，可以实现对请求生命周期的精细化控制，适用于审计、监控等场景。







3️⃣ 参考 3

ServletRequestListener 是 Java Web 开发中用于监听 ServletRequest 对象生命周期的接口，主要用于在 请求创建 和 销毁 时执行特定操作。它常用于记录请求日志、性能监控、资源管理等场景。以下是其用法的详细说明：

1. 核心方法

要使用 ServletRequestListener，需实现以下两个方法：

  • requestInitialized(ServletRequestEvent event)
    当 ServletRequest 对象被创建时调用，通常用于初始化请求相关的资源或记录请求开始时间。
  • requestDestroyed(ServletRequestEvent event)
    当 ServletRequest 对象被销毁时调用，通常用于清理资源或记录请求结束时间。

2. 实现步骤

步骤 1：创建监听器类

实现 ServletRequestListener 接口，并重写上述方法。

import javax.servlet.ServletRequest;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;

public class MyRequestListener implements ServletRequestListener {

    @Override
    public void requestInitialized(ServletRequestEvent event) {
        ServletRequest request = event.getServletRequest();
        // 请求初始化操作（如记录请求开始时间、设置上下文信息）
        long startTime = System.currentTimeMillis();
        request.setAttribute("startTime", startTime);
        System.out.println("请求 [" + request.getRequestURI() + "] 已初始化，开始时间：" + startTime);
    }

    @Override
    public void requestDestroyed(ServletRequestEvent event) {
        ServletRequest request = event.getServletRequest();
        // 请求销毁操作（如记录请求结束时间、计算耗时、清理资源）
        Long startTime = (Long) request.getAttribute("startTime");
        if (startTime != null) {
            long endTime = System.currentTimeMillis();
            System.out.println("请求 [" + request.getRequestURI() + "] 已销毁，耗时：" + (endTime - startTime) + "ms");
        }
    }
}
步骤 2：注册监听器

有两种方式注册监听器：

方式 1：在 web.xml 中配置
<web-app>
    <!-- 其他配置 -->
    <listener>
        <listener-class>com.example.MyRequestListener</listener-class>
    </listener>
</web-app>
方式 2：使用注解（Java EE 6+）

在监听器类上添加 @WebListener 注解：

import javax.servlet.annotation.WebListener;

@WebListener
public class MyRequestListener implements ServletRequestListener {
    // 方法同上
}

3. 典型应用场景

场景 1：请求性能监控

记录每个请求的处理时间：

@Override
public void requestInitialized(ServletRequestEvent event) {
    ServletRequest request = event.getServletRequest();
    long startTime = System.currentTimeMillis();
    request.setAttribute("startTime", startTime);
}

@Override
public void requestDestroyed(ServletRequestEvent event) {
    ServletRequest request = event.getServletRequest();
    Long startTime = (Long) request.getAttribute("startTime");
    if (startTime != null) {
        long duration = System.currentTimeMillis() - startTime;
        // 将耗时记录到日志或数据库
        System.out.println("请求耗时：" + duration + "ms");
    }
}
场景 2：请求计数器

统计当前活跃的请求数量：

private static AtomicInteger activeRequests = new AtomicInteger(0);

@Override
public void requestInitialized(ServletRequestEvent event) {
    activeRequests.incrementAndGet();
    System.out.println("当前活跃请求数：" + activeRequests.get());
}

@Override
public void requestDestroyed(ServletRequestEvent event) {
    activeRequests.decrementAndGet();
    System.out.println("当前活跃请求数：" + activeRequests.get());
}
场景 3：资源管理

在请求开始时分配资源（如线程绑定的数据库连接），在请求结束时释放：

@Override
public void requestInitialized(ServletRequestEvent event) {
    // 分配资源（如线程绑定的数据库连接）
    Connection connection = DataSource.getConnection();
    event.getServletRequest().setAttribute("connection", connection);
}

@Override
public void requestDestroyed(ServletRequestEvent event) {
    Connection connection = (Connection) event.getServletRequest().getAttribute("connection");
    if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

4. 生命周期说明

  • 执行顺序：
    • requestInitialized 在 Servlet 或 Filter 处理请求之前 调用。
    • requestDestroyed 在 Servlet 或 Filter 处理完成后 调用。
  • 触发条件：
    • 创建：当客户端发送请求时，容器创建 ServletRequest 对象时触发。
    • 销毁：当请求处理完成且 ServletRequest 对象不再需要时触发。

5. 注意事项

  1. 线程安全：
    • 每个请求在独立线程中处理，监听器的方法在 当前请求的线程 中执行，无需额外线程同步。
  2. 资源管理：
    • 在 requestDestroyed 中确保资源正确释放（如关闭流、数据库连接等）。
  3. 性能影响：
    • 避免在监听器中执行耗时操作，以免影响请求处理速度。
  4. 与 ServletRequestAttributeListener 的区别：
    • ServletRequestListener 监听的是 请求对象的生命周期。
    • ServletRequestAttributeListener 监听的是 请求对象属性的增删改。

6. 完整示例

以下是一个完整的监听器示例，结合了请求计时和资源管理：

import javax.servlet.annotation.WebListener;
import javax.servlet.ServletRequest;
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.atomic.AtomicInteger;

@WebListener
public class MyRequestListener implements ServletRequestListener {

    private static final AtomicInteger activeRequests = new AtomicInteger(0);

    @Override
    public void requestInitialized(ServletRequestEvent event) {
        ServletRequest request = event.getServletRequest();
        // 记录请求开始时间
        request.setAttribute("startTime", System.currentTimeMillis());
        // 统计活跃请求数
        activeRequests.incrementAndGet();
        System.out.println("请求 [" + ((HttpServletRequest) request).getRequestURI() + "] 开始，当前活跃请求数：" + activeRequests.get());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent event) {
        ServletRequest request = event.getServletRequest();
        // 计算请求耗时
        Long startTime = (Long) request.getAttribute("startTime");
        if (startTime != null) {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println("请求 [" + ((HttpServletRequest) request).getRequestURI() + "] 结束，耗时：" + duration + "ms");
        }
        // 减少活跃请求数
        activeRequests.decrementAndGet();
    }
}

7. 总结

ServletRequestListener 是管理 单个请求生命周期 的关键工具，适用于请求计时、资源分配、性能监控等场景。通过合理使用，可以提升应用的可观测性和资源利用率。根据需求选择 web.xml 或注解注册监听器，确保代码简洁高效。







4️⃣ 参考 4

ServletRequestListener 是 Java Servlet API 里的一个接口，它属于 Servlet 监听器的范畴。其主要功能是对 ServletRequest 对象的生命周期进行监听，当一个 ServletRequest 对象被创建（也就是有请求到达时）或者被销毁（请求处理完毕），会触发相应的事件，进而执行特定的操作。

用法步骤

  1. 创建一个类实现 ServletRequestListener 接口：需要实现 requestInitialized 和 requestDestroyed 这两个方法。
  2. 在 requestInitialized 方法中编写请求初始化时要执行的代码。
  3. 在 requestDestroyed 方法中编写请求销毁时要执行的代码。
  4. 配置监听器：可以通过 web.xml 文件或者使用注解的方式进行配置。

示例代码

以下是一个使用 ServletRequestListener 的示例：

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

// 使用 @WebListener 注解配置监听器
@WebListener
public class MyServletRequestListener implements ServletRequestListener {

    // 当 ServletRequest 被创建时调用
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("请求初始化，请求来源: " + sre.getServletRequest().getRemoteAddr());
        // 可以在这里进行一些请求初始化操作，比如记录请求日志
    }

    // 当 ServletRequest 被销毁时调用
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("请求处理完毕，销毁请求对象");
        // 可以在这里进行一些请求销毁后的清理操作
    }
}

代码解释

  • @WebListener 注解：该注解用于将 MyServletRequestListener 类注册为一个监听器。
  • requestInitialized 方法：当有新的请求到达，ServletRequest 对象创建时，此方法会被调用，可在此方法中执行请求初始化操作，如记录请求日志。
  • requestDestroyed 方法：当请求处理完毕，ServletRequest 对象销毁时，此方法会被调用，可在此方法中执行请求销毁后的清理操作。

使用 web.xml 配置监听器

若不使用注解，也可以通过 web.xml 文件来配置监听器，示例如下：

<listener>
    <listener-class>com.example.MyServletRequestListener</listener-class>
</listener>

要把 com.example.MyServletRequestListener 替换成你实际的监听器类的全限定名。







5️⃣ 参考 5

ServletRequestListener 是 Java Servlet 规范中定义的一个接口，用于监听 ServletRequest 对象的创建和销毁。以下是它的具体用法：

核心方法

  • requestInitialized(ServletRequestEvent sre)：当 ServletRequest 对象被创建时触发。可以在该方法中执行一些初始化操作，例如记录请求的来源地址等。
  • requestDestroyed(ServletRequestEvent sre)：当 ServletRequest 对象被销毁时触发。可以在该方法中执行一些清理操作。

实现步骤

（1）创建监听器类

创建一个类并实现 ServletRequestListener 接口，重写上述两个方法。例如：

package com;

import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;

public class MyServletRequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("请求初始化：" + sre.getServletRequest().getRemoteAddr());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("请求销毁：" + sre.getServletRequest().getRemoteAddr());
    }
}
（2）注册监听器

将监听器注册到 Web 应用程序中，可以通过以下两种方式：

  • 在 web.xml 中配置：

    <listener>
    <listener-class>com.MyServletRequestListener</listener-class>
</listener>

  • 使用 @WebListener 注解（推荐，适用于 Servlet 3.0 及以上版本）：

    import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletRequestListener implements ServletRequestListener {
    // 方法实现与上面相同
}

注意事项

  • ServletRequest 对象的创建和销毁非常频繁，因此实际开发中很少直接使用 ServletRequestListener。
  • 如果需要监听请求属性的变化，可以使用 ServletRequestAttributeListener。
  • 如果需要监听会话的创建和销毁，应使用 HttpSessionListener。

通过以上方式，ServletRequestListener 可以在 Web 应用中对请求的生命周期进行监听，从而实现一些特定的逻辑。







6️⃣ 参考 6

ServletRequestListener 是一个接口，用于监听 Servlet 请求的生命周期事件。通过实现这个接口，可以在请求到达和请求结束时执行特定的代码。

步骤：

  1. 创建一个类，实现 ServletRequestListener 接口。
  2. 重写两个方法：
    • requestInitialized(ServletRequestEvent sre)：在请求到达时调用。
    • requestDestroyed(ServletRequestEvent sre)：在请求结束时调用。
  3. 在 web.xml 文件中注册监听器，或者使用注解 @WebListener。

代码示例：

1. 创建监听器类
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletRequestListener implements ServletRequestListener {

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("请求到达...");
        // 在这里执行请求到达时的操作，例如记录日志、初始化请求相关资源等
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("请求结束...");
        // 在这里执行请求结束时的操作，例如释放资源等
    }
}
2. 使用 web.xml 注册监听器（可选）

如果你不使用注解，可以在 web.xml 文件中注册监听器：

<listener>
    <listener-class>com.example.MyServletRequestListener</listener-class>
</listener>

解释：

  • @WebListener 注解：这是 Servlet 3.0 及以上版本提供的注解，用于简化监听器的注册。
  • requestInitialized 方法：在请求到达时调用，可以在这里进行一些初始化操作。
  • requestDestroyed 方法：在请求结束时调用，可以在这里进行一些清理操作。

通过这种方式，你可以更好地控制每个请求的生命周期，执行必要的初始化和清理任务。







7️⃣ 参考 7

在这里插入图片描述

ServletRequestListener 使用方法及示例代码

一、核心作用

ServletRequestListener 用于监听 HTTP 请求的创建和销毁事件，主要应用于：

  1. 请求生命周期监控：记录请求到达和结束时间
  2. 全局请求参数处理：过滤非法请求或统一参数校验
  3. 性能统计：统计请求耗时（如结合 requestInitialized 和 requestDestroyed 时间差）
二、实现步骤

  1. 创建监听器类
    实现 javax.servlet.ServletRequestListener 接口：

    import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class RequestTracker implements ServletRequestListener {
    // 请求创建时触发
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        long startTime = System.currentTimeMillis();
        sre.getServletRequest().setAttribute("startTime", startTime);
        System.out.println("▶️ 请求到达：" + sre.getServletRequest().getRemoteAddr());
    }

    // 请求销毁时触发
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        long endTime = System.currentTimeMillis();
        long duration = endTime - (Long)sre.getServletRequest().getAttribute("startTime");
        System.out.println("⏹️ 请求处理完成，耗时：" + duration + "ms");
    }
}

  2. 配置方式（二选一）

    • 注解配置（Servlet 3.0+）：
      @WebListener // 直接添加注解即可
    • XML 配置（适用于所有版本）：
      <listener>
    <listener-class>com.example.RequestTracker</listener-class>
</listener>
三、典型应用场景
场景 实现方法示例 技术要点
请求日志记录 在 requestInitialized() 记录客户端 IP 通过 ServletRequest.getRemoteAddr() 获取客户端信息
耗时统计 计算 requestInitialized 与 requestDestroyed 时间差 使用 System.currentTimeMillis() 存储时间戳
全局参数过滤 在请求初始化时检查特定 Header 通过 ServletRequest.getHeader("X-Auth-Token") 进行鉴权验证
流量控制 统计单位时间内的请求数量 结合 ConcurrentHashMap 实现线程安全的计数器
四、注意事项

  1. 作用域限制
    每个 HTTP 请求都会触发监听器，不要在其中存储请求级以上的状态（应使用 ServletContext 或 HttpSession）

  2. 性能影响
    高频触发的监听器代码需保持轻量，避免阻塞：

    @Override
public void requestInitialized(ServletRequestEvent sre) {
    // 错误示例：执行耗时数据库操作
    // Database.query(...); 

    // 正确做法：仅记录必要信息，异步处理复杂逻辑
    ExecutorService.submit(() -> processAsync(sre)); 
}

  3. 与过滤器的区别

    特性 ServletRequestListener Filter
    触发时机 请求创建/销毁时 请求到达 Servlet 前/响应返回前
    访问控制能力 仅监控，无法拦截请求 可通过 chain.doFilter() 控制流程
    适用场景 数据采集、监控 权限验证、编码转换
五、进阶用法示例

统计全局活跃请求数：

public class RequestCounter implements ServletRequestListener {
    private static final AtomicInteger counter = new AtomicInteger(0);

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        counter.incrementAndGet();
        sre.getServletContext().setAttribute("activeRequests", counter.get());
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        counter.decrementAndGet();
        sre.getServletContext().setAttribute("activeRequests", counter.get());
    }
}

在 JSP 页面显示：当前活跃请求数：${applicationScope.activeRequests}







8️⃣ 参考 8

ServletRequestListener是Java Web应用中用于监听HTTP请求对象生命周期的接口，主要用于在请求创建和销毁时执行预处理或资源管理操作。以下为其核心用法及实践要点：

一、核心方法与作用

  1. requestInitialized(ServletRequestEvent sre)
    在HTTP请求创建时触发（客户端请求到达服务器后立即执行），早于Servlet的service()方法调用。适用于：
    • 记录请求日志（如IP地址、请求路径、时间戳）
    • 初始化请求级资源（如临时文件、线程局部变量）
    • 统计请求参数或流量（如统计高频请求路径）
    示例代码片段：

    public void requestInitialized(ServletRequestEvent sre) {
    HttpServletRequest request = (HttpServletRequest) sre.getServletRequest();
    String clientIP = request.getRemoteAddr();
    System.out.println("Request from IP: " + clientIP + " at " + new Date());
}

  2. requestDestroyed(ServletRequestEvent sre)
    在请求处理完成、响应返回客户端后触发，晚于所有Filter和Servlet的处理流程。适用于：
    • 清理请求级资源（如关闭临时文件句柄）
    • 记录请求处理耗时（结合初始化阶段的时间戳计算）
    示例：

    public void requestDestroyed(ServletRequestEvent sre) {
    // 计算请求处理时长
    Long startTime = (Long) sre.getServletRequest().getAttribute("startTime");
    long duration = System.currentTimeMillis() - startTime;
    System.out.println("Request processed in " + duration + "ms");
}

二、实现与配置步骤

  1. 创建监听器类
    实现ServletRequestListener接口并重写上述方法，可通过注解或XML配置：

    @WebListener  // Servlet 3.0+ 注解方式
public class MyRequestListener implements ServletRequestListener { ... }

  2. XML配置（传统方式）
    在web.xml中添加（需注意监听器加载顺序）：

    <listener>
    <listener-class>com.example.MyRequestListener</listener-class>
</listener>

  3. 访问请求参数
    通过ServletRequestEvent获取请求对象：

    public void requestInitialized(ServletRequestEvent sre) {
    String paramValue = sre.getServletRequest().getParameter("key");
    if (paramValue != null) {
        // 处理参数逻辑
    }
}

三、典型应用场景

场景 实现方式 来源
请求日志记录 记录客户端IP、请求路径、时间戳，用于审计或异常排查
参数预处理 在请求到达Servlet前统一验证参数有效性（如非空检查、格式校验）
性能监控 统计请求处理时间，识别慢接口并优化
请求级缓存 为高频请求路径缓存计算结果，减少重复处理耗时

四、注意事项

  1. 生命周期范围
    • 每个HTTP请求都会触发独立的监听器实例，转发（forward）不会创建新请求，而重定向（redirect）会产生新请求
    • 请求销毁事件可能因客户端断开连接未触发，需通过超时机制兜底处理

  2. 执行顺序
    多个ServletRequestListener按web.xml声明顺序执行，需注意依赖关系

  3. 资源管理
    避免在监听器中执行耗时操作（如数据库查询），否则可能阻塞请求处理线程







9️⃣ 参考 9

ServletRequestListener 是 Java Web 开发中用于监听 单个 HTTP 请求生命周期的接口。它允许你在每个请求的创建和销毁时执行自定义逻辑（如记录日志、初始化请求范围的变量等）。以下是其核心用法：

核心方法

  1. requestInitialized(ServletRequestEvent sre)

    • 在请求对象（ServletRequest）被创建时触发（即客户端发起请求时）。
    • 常用于初始化请求级资源（如设置默认参数、记录请求开始时间等）。

  2. requestDestroyed(ServletRequestEvent sre)

    • 在请求对象被销毁时触发（即请求处理完成后）。
    • 常用于清理资源或执行后置操作（如记录请求耗时、关闭流资源等）。

使用步骤

  1. 实现接口
    创建一个类实现 ServletRequestListener 接口，并重写两个方法：

    import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;

@WebListener // 使用注解注册监听器（Servlet 3.0+）
public class MyRequestListener implements ServletRequestListener {
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("请求已创建！" + sre.getServletRequest().getMethod());
        // 初始化逻辑（如记录请求开始时间）
    }

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("请求已销毁！");
        // 清理逻辑（如关闭请求关联的资源）
    }
}

  2. 配置监听器

    • 方式 1：通过 @WebListener 注解（推荐，无需额外配置）。
    • 方式 2：在 web.xml 中声明：
      <listener>
    <listener-class>com.example.MyRequestListener</listener-class>
</listener>

典型应用场景

  • 请求初始化：
    如记录请求开始时间、设置请求级的默认参数、绑定全局变量到请求作用域。
  • 请求销毁：
    如统计请求耗时、关闭未关闭的流（如 InputStream）、清理敏感数据。

注意事项

  • 通过 sre.getServletRequest() 可直接获取当前请求对象，操作其参数、属性等。
  • 线程安全：每个请求由独立线程处理，监听器方法默认线程安全，但需避免共享非线程安全的资源。
  • 与 Filter 的区别：
    • ServletRequestListener 监听请求对象的生命周期，在请求创建/销毁时触发。
    • Filter 则在请求的处理过程中拦截（如请求到达时、响应返回前）。

通过 ServletRequestListener，你可以更精细地控制每个请求的生命周期，实现请求级别的监控或资源管理。







🔟 参考 10

ServletRequestListener用于监听客户端请求（HttpServletRequest）的创建和销毁事件，其用法主要包括以下几个方面：

  1. 接口介绍：

    • ServletRequestListener是一个接口，包含两个方法：requestInitialized(ServletRequestEvent sre)和requestDestroyed(ServletRequestEvent sre)。当请求即将进入Web应用程序范围时，会调用requestInitialized方法；当请求即将超出Web应用程序的范围时，会调用requestDestroyed方法[1]。

  2. 实现类：

    • 创建一个类实现ServletRequestListener接口，并重写上述两个方法。例如，可以创建一个名为MyServletRequestListener的类，并在其中实现requestInitialized和requestDestroyed方法[3][4]。

  3. 注册监听器：

    • 在web.xml文件中配置<listener>元素来注册监听器。指定监听器的类名，以便Servlet容器在启动或关闭Web应用时能够调用相应的方法[2]。
    • 在Spring Boot等现代Java框架中，可以通过使用注解（如@WebListener）来简化配置，无需在web.xml中进行配置[2]。

  4. 应用场景举例：

    • 资源管理：在请求初始化时分配资源，如数据库连接、文件句柄等；在请求销毁时释放这些资源，以防止资源泄漏[1]。
    • 性能监控：记录请求的处理时间、响应时间等性能指标，以便对Web应用的性能进行监控和优化。
    • 日志记录：在请求初始化和销毁时记录日志信息，如请求的来源IP地址、请求时间等，以便进行审计和故障排查[3]。
    • 权限验证：在请求初始化时进行用户身份验证和权限检查，确保只有合法的用户才能访问受保护的资源。

综上所述，ServletRequestListener为开发者提供了一个方便的机制来监听客户端请求的生命周期事件，通过合理利用这一监听器，可以增强Web应用的功能和可维护性。













网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布