ServletRequestListener 的用法笔记250417

于 2025-04-17 22:11:28 发布
阅读量741 收藏 16
点赞数 23
分类专栏： JAVA 文章标签： 笔记 java tomcat servlet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kfepiza/article/details/147314738
版权

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 的区别

特性ServletRequestListenerFilter
触发时机请求开始/结束时请求处理前/后
修改请求/响应否是
链式调用无支持多个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. 与过滤器的区别

    特性ServletRequestListenerFilter
    触发时机请求创建/销毁时请求到达 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应用的功能和可维护性。













Java Web基础知识之Listener：监控Servlet的每个动作
lmy86263的博客
04-21 8699
之前学习了很多涉及servlet的内容，本小结我们说一下监听器，说起监听器，编过桌面程序和手机App的都不陌生，常见的套路都是拖一个控件，然后给它绑定一个监听器，即可以对该对象的事件进行监听以便发生响应，从本质上来说这些都是观察者模式的具体实现，在web程序中的监听器也不例外。
JavaWeb知识点总结 我的学习笔记
最新发布
qq_60972641的博客
10-28 1992
运行在服务器端的小程序Servlet就是一个接口，定义了java类被浏览器访问到（tomcat识别到）的规则。Servlet就javaweb三大组件之一，三大组件分别是Servlet程序Filter过滤器Listener监听器Servlet是在服务器端运行的Java程序，可以接收客户端请求并做出响应Servlet可以动态生成HTML内容对客户端进行响应Servlet与JSP都可以动态生成HTML内容ServletContext 是应用上下文对象。
ServletRequest listener
weixin_33859231的博客
05-22 141
ServletRequestListener @WebListener public class ServletRequestListenerDemo implements ServletRequestListener { @Override public void requestDestroyed(ServletRequestEvent servletRequestEvent)...
ServletRequestListener
stephen830
07-15 224
  ServletRequestListener接口 MyServletRequestListener public class MyServletRequestListener implements ServletRequestListener {     public void requestDestroyed(ServletRequestEvent sre) { Htt...
监听器03 ServletRequestListener
qq_43749526的博客
07-22 113
[Java][web]利用Spring随时随地获得Request和Session
cihongmo6452的博客
05-26 243
利用Spring随时随地获得Request和Session 一、准备工作： 在web.xml中添加 <listener> <listener-class> org.springframework.w...
传智播客崔希凡javaweb笔记完整版
11-18
崔希凡老师的笔记中可能详细讲解了Servlet的生命周期、服务方法以及如何通过doGet和doPost方法处理HTTP请求。 JSP（JavaServer Pages）是另一种关键组件，它允许开发者在HTML中嵌入Java代码，简化视图层的开发。...
java核心技术-java中监听器和过滤器的使用笔记
05-27
本篇将详细阐述Java中的Filter（过滤器）及其使用方法。 1. **Filter（过滤器）概念** - Filter在Java Web中是一个中间件，它能够拦截用户请求并进行预处理，同时也能够处理服务器响应。它不同于Servlet，因为...
JavaEE学习项目源代码及学习笔记.zip
03-09
【JavaEE学习项目源代码及学习笔记.zip】这个压缩包包含了一系列关于JavaEE技术栈的实践项目源码和对应的学习笔记，旨在帮助开发者深入理解JavaEE的各项核心技术。下面将逐一介绍这些子文件所涵盖的JavaEE知识点。 ...
javaWeb学习笔记+狂神说
01-13
常见的监听器包括HttpSessionListener、ServletRequestListener、ServletContextListener，它们可以在特定事件发生时执行相应的操作，如session创建、销毁、请求开始、结束等。 六、MVC设计模式 在JavaWeb开发中，...
ServletRequestListener监听器
小匠心的博客
04-25 437
它生命周期只存活与一次请求中，在请求时创建，请求结束时销毁。
8.4 ServletRequestListeners 8.4.1 ServletRequestListener
测试
04-15 218
朗读文章8.4 ServletRequestListeners8.4.1 ServletRequestListener实例PerfStatListener方法说明requestInitialized方法requestDestroyed方法运行效果document.querySelector(".post-body > ul").style.display="none"朗读文章朗读:重新朗读:fun...
ServletRequestListener监听器和ServletRequestAttributeListener监听器
weixin_74484843的博客
12-11 759
实现类直接使用HttpSessionAttributeListener监听器中的HiServlet即可(在上一篇博客中)1.可以用来监控某个IP访问网站的频率。
使用ServletRequestListener和ServletRequestAttributeListener
锋行天下
11-06 620
2.13.4  使用ServletRequestListener和ServletRequestAttributeListener ServletRequestListener用于监听用户请求的到达，实现该接口的监听器需要实现如下两个方法。 requestInitialized(ServletRequestEvent sre)：用户请求到底、被初始化时触发该方法。 requestDestroy
servlet——Listener
ccoran的博客
11-29 574
1 概述 Servlet规范中已经定义好了八个监听器接口，它们要监听的对象分别是request、session、servletContext对象，触发监听器事件是这三个对象的创建和销毁，它们的域属性空间中的属性的添加、删除、修改，以及session的钝化和活化操作 在JavaWeb项目中使用监听器，需要在web.xml文件中对监听器进行注册。 &amp;amp;amp;amp;amp;lt;listener&amp;amp;amp;amp;amp;gt; &amp;am
Java监听器(重点)
zhansan的博客
02-04 2876
监听事件 就是你点击那个按钮然后执行相应的事件 java中监听是什么_Java中的监听器 java----监听器的作用
监听器ServletRequestListener的使用
七七的博客
08-26 1175
ServletRequestListener监听器 ServletRequestListener监听器作用 用户监听ServletReguest对象的创建和销毁 ServletRequest对象的创建和销毁。 创建： 从客户端向服务器发送一次请求， 服务器就会创建request对象。 销毁： 服务器对这次请求作出了响应之后，request对象就销毁了。 方法：创建和销毁 监听器代码： 配置： web.xml <listener> <listener-class>list
Servlet 监听器Listener
分享我的点点滴滴，在成长路上与你同行！
01-03 418
一.什么是监听器 监听器可以接收事件，并完成相关的处理. 二.监听器分类 三.如何使用监听器 3.1>定义一个类来实现Listener不同的接口;监听不同Web事件的监听器不相同， 常用的Web事件监听器接口有如下几个： ServletContextListener：用于监听Web应用的启动和关闭。 ServletContext...
Servlet监听器(Listener)
年轻就是资本的专栏
06-25 944
Servlet监听器(Listener) Servlet监听器(Listener)是Java Servlet规范中定义的一种特殊类，它可以监听Web应用程序中的特定事件，并在这些事件发生时执行相应的处理。通过监听器，开发者可以在无需修改已有代码的情况下，对Servlet容器的生命周期事件、Http会话的创建和销毁、Http session属性的增加和删除、Http请求的初始化和结束等进行监控和操...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

kfepiza

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

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

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

打赏作者

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

抵扣说明：

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

余额充值