数据仓库与分析HttpSessionListener 的用法笔记250417

没腿的鸟 发表于 2025-4-19 02:21:59

HttpSessionListener 的用法笔记250417

HttpSessionListener 的用法笔记250417

https://i-blog.csdnimg.cn/direct/6ae8cc406a4948e498e4d3738615ee01.png
以下是关于 HttpSessionListener 的用法详解，涵盖核心方法、实现步调、典范应用场景及注意事项，资助您全面把握会话（Session）生命周期的监听与管理：
1. 核心功能

HttpSessionListener 用于监听 HTTP 会话（Session）的创建与销毁，实用于跟踪用户会话状态（如在线用户统计）、会话级资源管理（如初始化用户数据）等场景。
2. 核心方法

[*] sessionCreated(HttpSessionEvent se)
当新会话（Session）创建时触发（如用户首次访问或调用 request.getSession(true)）。
[*] sessionDestroyed(HttpSessionEvent se)
当会话失效时触发（如超时、调用 session.invalidate() 或应用关闭）。
3. 实现步调

步调 1：创建监听器类

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener // Servlet 3.0+ 注解注册
public class SessionTrackerListener implements HttpSessionListener {

@Override
public void sessionCreated(HttpSessionEvent se) {
   // 获取当前会话对象
   HttpSession session = se.getSession();

   // 统计在线用户数（存储在应用上下文中）
   ServletContext context = session.getServletContext();
   AtomicInteger userCount = (AtomicInteger) context.getAttribute("userCount");
   if (userCount == null) {
         userCount = new AtomicInteger(0);
         context.setAttribute("userCount", userCount);
   }
   int count = userCount.incrementAndGet();
   System.out.println("会话创建 | 当前在线用户: " + count);

   // 初始化会话级属性（如用户令牌）
   session.setAttribute("loginTime", new Date());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   HttpSession session = se.getSession();
   ServletContext context = session.getServletContext();

   // 减少在线用户数
   AtomicInteger userCount = (AtomicInteger) context.getAttribute("userCount");
   if (userCount != null) {
         int count = userCount.decrementAndGet();
         System.out.println("会话销毁 | 剩余在线用户: " + count);
   }

   // 清理会话资源（如断开关联的数据库连接）
   Object resource = session.getAttribute("userResource");
   if (resource instanceof AutoCloseable) {
         try {
            ((AutoCloseable) resource).close();
         } catch (Exception e) {
            e.printStackTrace();
         }
   }
}
}
步调 2：注册监听器

[*] 方式一：通过 web.xml 配置
<web-app>
<listener>
   <listener-class>com.example.SessionTrackerListener</listener-class>
</listener>

<session-config>
   <session-timeout>30</session-timeout>
</session-config>
</web-app>

[*] 方式二：利用 @WebListener 注解
直接在类上添加注解（需支持 Servlet 3.0+）。
4. 关键应用场景

[*]在线用户统计：实时监控活跃会话数目。
[*]会话超时管理：自动清理闲置会话关联的资源。
[*]用户举动跟踪：记录用户登录/退出时间、访问路径。
[*]资源绑定与释放：如为会话分配临时文件、数据库连接。
[*]安全控制：检测异常会话（如短时间内大量新会话创建）。
5. 注意事项

(1) 线程安全问题

[*]HttpSession 是线程安全的（每个会话由同一用户独占），但存储在 ServletContext 中的全局变量（如在线用户计数）需利用线程安全对象（如 AtomicInteger）或同步控制。
(2) 会话销毁触发条件

[*]超时：通过 <session-timeout> 配置或 session.setMaxInactiveInterval(int) 设置。
[*]显式失效：调用 session.invalidate()。
[*]应用关闭：若服务器正常关闭，未超时的会话也会触发 sessionDestroyed；非正常关闭大概无法触发。
(3) 分布式环境

[*]会话复制：在集群中，会话大概被复制到多个节点，监听器大概在差异节点触发，需确保逻辑幂等性（如利用分布式计数器统计在线用户）。
[*]长期化会话：若会话长期化到数据库，需在 sessionDestroyed 中清理外部存储的会话数据。
(4) 克制内存走漏

[*]移除无效引用：在 sessionDestroyed 中清除会话属性中大概持有的大对象或外部资源引用。
[*]谨慎利用静态集合：若在监听器中用静态 Map 缓存会话数据，需在销毁时及时移除条目。
(5) 会话创建机遇

[*]惰性创建：默认情况下，会话在首次调用 request.getSession() 时创建。可通过 request.getSession(false) 克制自动创建。
6. 示例：会话超时提示

@Override
public void sessionCreated(HttpSessionEvent se) {
HttpSession session = se.getSession();
// 设置会话超时提醒逻辑（如定时任务）
session.setAttribute("lastActiveTime", System.currentTimeMillis());
Timer timer = new Timer();
timer.schedule(new TimerTask() {
   @Override
   public void run() {
         long lastActive = (long) session.getAttribute("lastActiveTime");
         if (System.currentTimeMillis() - lastActive > 15 * 60 * 1000) {
            System.out.println("会话即将超时，用户ID: " + session.getId());
         }
   }
}, 10 * 60 * 1000); // 提前10分钟提醒
session.setAttribute("timeoutTimer", timer);
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
HttpSession session = se.getSession();
Timer timer = (Timer) session.getAttribute("timeoutTimer");
if (timer != null) {
   timer.cancel(); // 销毁时取消定时任务
}
}
7. 与其他监听器对比

监听器作用范围触发机遇典范用途ServletContextListener应用级别应用启动/关闭全局资源管理（如连接池）ServletRequestListener请求级别每次请求开始/结束请求日记、性能监控HttpSessionListener会话级别会话创建/销毁在线用户统计、会话资源管理 8. 最佳实践

[*]轻量化操纵：克制在监听器中执行耗时任务（如远程调用），防止会话创建/销毁延迟。
[*]联合 HttpSessionAttributeListener：若需监听会话属性变革（如用户登录状态更新），可共同利用。
[*]日记记录：记录关键事件（如会话 ID、创建时间），便于审计和调试。
总结

HttpSessionListener 是管理用户会话生命周期的核心工具，实用于在线统计、资源绑定及安全监控。重点在于合理处剖析话创建/销毁事件、确保线程安全与资源释放，并在分布式环境中计划幂等逻辑。联合其他监听器和过滤器，可构建完备的会话管理体系。

1️⃣ 参考 1

HttpSessionListener 是 Java Servlet 规范中用于监听 HTTP 会话（Session）生命周期的接口，可在会话创建时和销毁时执行自界说逻辑。以下是其核心用法、示例及典范场景：
核心用法步调

1. 实现 HttpSessionListener 接口

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener // Servlet 3.0+ 使用注解（无需 web.xml）
public class MySessionListener implements HttpSessionListener {

@Override
public void sessionCreated(HttpSessionEvent se) {
   // 会话创建时触发
   System.out.println("Session 创建，ID: " + se.getSession().getId());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   // 会话销毁时触发
   System.out.println("Session 销毁，ID: " + se.getSession().getId());
}
}
2. 配置监听器

[*]方式一：利用 web.xml（兼容全部版本）<listener>
<listener-class>com.example.MySessionListener</listener-class>
</listener>

[*]方式二：利用 @WebListener 注解（Servlet 3.0+）
直接在类上添加注解即可（如上例）。
典范应用场景

1. 统计在线用户数

private AtomicInteger onlineUsers = new AtomicInteger(0); // 线程安全计数器

@Override
public void sessionCreated(HttpSessionEvent se) {
onlineUsers.incrementAndGet();
se.getSession().getServletContext().setAttribute("onlineUsers", onlineUsers.get());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
onlineUsers.decrementAndGet();
se.getSession().getServletContext().setAttribute("onlineUsers", onlineUsers.get());
}
2. 记录用户登录/登出举动

@Override
public void sessionCreated(HttpSessionEvent se) {
// 用户首次访问时创建 Session（可能未登录）
System.out.println("新会话创建: " + se.getSession().getId());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
// 用户登出或会话超时
String username = (String) se.getSession().getAttribute("username");
if (username != null) {
   System.out.println("用户登出: " + username);
}
}
3. 会话资源管理

@Override
public void sessionCreated(HttpSessionEvent se) {
// 初始化会话级资源（如临时文件目录）
String tempDir = createTempDirectory();
se.getSession().setAttribute("tempDir", tempDir);
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
// 清理会话级资源
String tempDir = (String) se.getSession().getAttribute("tempDir");
if (tempDir != null) {
   deleteDirectory(tempDir); // 自定义清理方法
}
}
注意事项

[*] 会话销毁的触发条件
会话销毁大概由以下缘故原由触发：

[*]显式调用 session.invalidate()
[*]会话超时（通过 session.setMaxInactiveInterval() 或 web.xml 配置）
[*]服务器重启或应用重新部署

[*] 线程安全问题
HttpSessionListener 是单例的，但每个会话的 HttpSession 对象是独立的。若操纵全局变量（如在线用户计数器），需利用线程安全类（如 AtomicInteger）。
[*] 克制壅闭操纵
监听器逻辑应轻量，克制壅闭会话创建或销毁流程（如克制在 sessionCreated 中执行耗时数据库操纵）。
[*] 会话超时配置
默认超时时间由容器决定，可在 web.xml 中全局配置：
<session-config>
<session-timeout>30</session-timeout> 
</session-config>

与其他监听器的协作

[*]HttpSessionAttributeListener
监听会话属性变革（如用户登录时设置 username 属性）。
[*]ServletContextListener
管理全局资源（如数据库连接池），供全部会话共享。
[*]ServletRequestListener
监听单个请求的生命周期（如记录请求耗时）。
总结

HttpSessionListener 是管理 HTTP 会话的核心工具，实用于在线用户统计、会话级资源管理、用户举动跟踪等场景。通过合理利用，可提拔 Web 应用的安全性和可维护性。

2️⃣ 参考 2

HttpSessionListener 是 Java Web 开辟中用于监听用户会话（Session）生命周期的接口，它允许你在会话创建和销毁时执行自界说逻辑。以下是其核心用法：
一、核心作用

[*]会话创建时：执行初始化操纵（如记录用户登录、初始化会话数据）。
[*]会话销毁时：执行清理操纵（如统计在线人数、释放用户资源）。
二、实现步调

1. 创建监听器类

实现 javax.servlet.http.HttpSessionListener 接口，重写两个方法：
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.concurrent.atomic.AtomicInteger;

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

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

@Override
public void sessionCreated(HttpSessionEvent se) {
   // 会话创建时触发（如用户首次访问）
   activeSessions.incrementAndGet();
   System.out.println("新会话创建，当前活跃会话数: " + activeSessions.get());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   // 会话销毁时触发（如超时、手动失效）
   activeSessions.decrementAndGet();
   System.out.println("会话销毁，剩余活跃会话数: " + activeSessions.get());
}
}
2. 配置监听器（两种方式）

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

[*]利用 @WebListener 注解，无需额外配置。
方式二：web.xml 配置（传统方式）
<listener>
<listener-class>com.example.MySessionListener</listener-class>
</listener>
三、典范应用场景

[*]统计在线人数public class OnlineUserCounter implements HttpSessionListener {
private static int activeUsers = 0;

public void sessionCreated(HttpSessionEvent se) {
   activeUsers++;
   // 更新到数据库或缓存
}

public void sessionDestroyed(HttpSessionEvent se) {
   activeUsers--;
   // 更新到数据库或缓存
}
}

[*]用户活动跟踪public void sessionCreated(HttpSessionEvent se) {
HttpSession session = se.getSession();
session.setAttribute("loginTime", System.currentTimeMillis());
}

[*]会话超时处理public void sessionDestroyed(HttpSessionEvent se) {
// 检查是否是超时导致的销毁
if (se.getSession().getMaxInactiveInterval() < 0) {
   System.out.println("用户会话超时");
}
}

四、注意事项

[*]线程安全：监听器实例会被全部会话共享，确保利用线程安全的数据结构（如 AtomicInteger）。
[*]性能影响：克制在监听器中执行耗时操纵（如复杂盘算、数据库操纵）。
[*]会话失效缘故原由：可通过 session.getMaxInactiveInterval() 判定是否因超时失效（返回负数表示未超时）。
五、与 HttpSessionAttributeListener 的区别

特性HttpSessionListenerHttpSessionAttributeListener监听对象会话生命周期会话属性的增编削典范用途统计在线人数、会话超时处理跟踪用户属性变更触发频率每个会话只触发两次每次属性操纵均触发通过合理利用 HttpSessionListener，可以实现对用户会话状态的精准管理，实用于实时统计、资源清理等场景。

3️⃣ 参考 3

以下是 HttpSessionListener 的详细用法说明，联合知识库中的信息和实际应用场景：
1. 核心方法

HttpSessionListener 是 Java Web 开辟中用于监听 HttpSession 对象生命周期的接口，紧张在会话创建和销毁时触发相应方法。需实现以下两个方法：

[*]sessionCreated(HttpSessionEvent se)
当新 HttpSession 对象被创建时调用，可用于初始化会话相干操纵（如记录用户登录、统计在线人数）。
[*]sessionDestroyed(HttpSessionEvent se)
当 HttpSession 对象被销毁时调用，可用于清理资源或记录用户退出（如释放数据库连接、更新在线人数）。
2. 实现步调

步调 1：创建监听器类

实现 HttpSessionListener 接口，并重写上述方法。
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.concurrent.atomic.AtomicInteger;

@WebListener// 使用注解注册（Servlet 3.0+）
public class OnlineUserCounter implements HttpSessionListener {

// 使用线程安全的计数器统计在线人数
private static final AtomicInteger activeSessions = new AtomicInteger(0);

@Override
public void sessionCreated(HttpSessionEvent event) {
   activeSessions.incrementAndGet();
   System.out.println("Session created: " + event.getSession().getId());
   System.out.println("当前在线人数：" + activeSessions.get());
}

@Override
public void sessionDestroyed(HttpSessionEvent event) {
   activeSessions.decrementAndGet();
   System.out.println("Session destroyed: " + event.getSession().getId());
   System.out.println("当前在线人数：" + activeSessions.get());
}
}
步调 2：注册监听器

有两种方式注册监听器：
方式 1：在 web.xml 中配置

<web-app>

<listener>
   <listener-class>com.example.OnlineUserCounter</listener-class>
</listener>
</web-app>
方式 2：利用注解（Java EE 6+）

在监听器类上添加 @WebListener 注解（如示例代码中所示）。
3. 典范应用场景

场景 1：统计在线人数

这是最常见的用途，通过监听会话的创建和销毁来维护在线用户数目：
// 在监听器中使用线程安全的计数器（推荐）
private static final AtomicInteger activeSessions = new AtomicInteger(0);

// 或者通过 ServletContext 保存计数器（需处理线程安全）
public void sessionCreated(HttpSessionEvent event) {
ServletContext context = event.getSession().getServletContext();
Integer count = (Integer) context.getAttribute("onlineCount");
if (count == null) {
   context.setAttribute("onlineCount", 1);
} else {
   context.setAttribute("onlineCount", count + 1);
}
}
场景 2：设置会话属性

在会话创建时初始化默认属性：
@Override
public void sessionCreated(HttpSessionEvent event) {
HttpSession session = event.getSession();
session.setMaxInactiveInterval(30 * 60); // 设置超时时间为30分钟
session.setAttribute("lastAccessTime", System.currentTimeMillis());
}
场景 3：资源管理

在会话销毁时释放资源（如数据库连接）：
@Override
public void sessionDestroyed(HttpSessionEvent event) {
HttpSession session = event.getSession();
Object resource = session.getAttribute("databaseConnection");
if (resource != null && resource instanceof Connection) {
   try {
         ((Connection) resource).close();
   } catch (SQLException e) {
         e.printStackTrace();
   }
}
}
4. 生命周期说明

[*]会话创建条件：

[*]调用 request.getSession() 且当前没有会话时。
[*]客户端携带有效 JSESSIONID 返回时（需服务器支持）。

[*]会话销毁条件：

[*]调用 session.invalidate()。
[*]会话超时（默认 30 分钟，可通过 session.setMaxInactiveInterval() 修改）。
[*]服务器非正常关闭（正常关闭时会话会被序列化，不会触发销毁）。

5. 注意事项

[*]线程安全：

[*]利用 AtomicInteger 或 synchronized 确保计数器安全。
[*]克制在监听器中直接操纵非线程安全的集合（如 Vector）。

[*]浏览器举动影响：

[*]关闭浏览器后，若未调用 session.invalidate()，会话大概因超时才销毁，导致统计延迟。
[*]差异浏览器或标签页会天生独立的会话。

[*]服务器重启：

[*]Tomcat 等容器会将会话序列化到文件（如 SESSIONS.ser），重启后会话大概恢复，需手动清理测试数据。

[*]计数器准确性：

[*]利用 ServletContext 保存计数器时，需确保线程安全（如 AtomicInteger 或 synchronized 方法）。

6. 完备示例

以下是一个完备的在线人数统计示例：
监听器类

import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.concurrent.atomic.AtomicInteger;

@WebListener
public class OnlineUserCounter implements HttpSessionListener {

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

@Override
public void sessionCreated(HttpSessionEvent event) {
   activeSessions.incrementAndGet();
   System.out.println("新会话创建，当前在线人数：" + activeSessions.get());
}

@Override
public void sessionDestroyed(HttpSessionEvent event) {
   activeSessions.decrementAndGet();
   System.out.println("会话销毁，当前在线人数：" + activeSessions.get());
}

// 提供获取当前在线人数的方法（可选）
public static int getActiveSessions() {
   return activeSessions.get();
}
}
测试控制器

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpSession;

@RestController
public class SessionTestController {

@GetMapping("/login")
public String login(HttpSession session) {
   session.setAttribute("user", "张三");
   return "登录成功";
}

@GetMapping("/logout")
public String logout(HttpSession session) {
   session.invalidate();
   return "退出成功";
}

@GetMapping("/online")
public String online() {
   return "当前在线人数：" + OnlineUserCounter.getActiveSessions();
}
}
7. 常见问题解答

Q1：为什么关闭浏览器后在线人数未减少？

[*]缘故原由：浏览器关闭不会立即触发 sessionDestroyed，需等待会话超时或调用 invalidate()。
[*]解决：在退出接口中显式调用 session.invalidate()。
Q2：多个浏览器标签页是否算多个会话？

[*]是的：每个浏览器标签页共享一个会话（共享 JSESSIONID），但多个浏览器实例（如 Chrome 和 Edge）会天生独立会话。
Q3：怎样克制计数器在服务器重启后重置？

[*]方案：将计数器保存到数据库或分布式缓存（如 Redis），而非内存中的 AtomicInteger。
8. 总结

HttpSessionListener 是监控会话生命周期的核心工具，实用于用户举动统计、资源管理和会话控制。通过联合线程安全计数器和合理的会话策略，可以实现高效可靠的在线人数统计。根据需求选择 web.xml 或注解注册监听器，并注意浏览器和服务器的交互特性以克制计数毛病。

4️⃣ 参考 4

HttpSessionListener 是 Java Servlet 规范中用于监听 HttpSession 对象生命周期的接口。借助这个接口，你能够在 HttpSession 对象创建大概销毁时执行特定操纵，例如统计在线用户数目、记录会话创建和销毁的日记等。
用法步调

[*]创建一个类实现 HttpSessionListener 接口：需要实现 sessionCreated 和 sessionDestroyed 这两个方法。
[*]在 sessionCreated 方法中编写会话创建时要执行的代码。
[*]在 sessionDestroyed 方法中编写会话销毁时要执行的代码。
[*]配置监听器：可以通过 web.xml 文件大概利用注解的方式举行配置。
示例代码

以下是一个利用 HttpSessionListener 统计在线用户数目的示例：
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import javax.servlet.annotation.WebListener;

// 使用 @WebListener 注解配置监听器
@WebListener
public class OnlineUserCounter implements HttpSessionListener {
private static int onlineUserCount = 0;

// 当 HttpSession 被创建时调用
@Override
public void sessionCreated(HttpSessionEvent se) {
   onlineUserCount++;
   System.out.println("新会话创建，当前在线用户数量: " + onlineUserCount);
}

// 当 HttpSession 被销毁时调用
@Override
public void sessionDestroyed(HttpSessionEvent se) {
   if (onlineUserCount > 0) {
         onlineUserCount--;
   }
   System.out.println("会话销毁，当前在线用户数量: " + onlineUserCount);
}

public static int getOnlineUserCount() {
   return onlineUserCount;
}
}
代码解释

[*]@WebListener 注解：此注解把 OnlineUserCounter 类注册成一个监听器。
[*]sessionCreated 方法：当有新的 HttpSession 对象创建时，该方法会被调用，在这个方法里将在线用户数目加 1 并输出日记。
[*]sessionDestroyed 方法：当 HttpSession 对象销毁时，该方法会被调用，在这个方法里将在线用户数目减 1 并输出日记。
[*]getOnlineUserCount 方法：这是一个静态方法，用于获取当前在线用户的数目。
利用 web.xml 配置监听器

若不利用注解，也可以通过 web.xml 文件来配置监听器，示例如下：
<listener>
<listener-class>com.example.OnlineUserCounter</listener-class>
</listener>
要把 com.example.OnlineUserCounter 替换成你实际的监听器类的全限定名。

5️⃣ 参考 5

HttpSessionListener 是用于监听 HttpSession 生命周期的接口，紧张监听会话的创建和销毁事件。以下是其用法的详细说明：
核心方法

[*]sessionCreated(HttpSessionEvent se)：当 HttpSession 被创建时触发。可以在这个方法中记录会话的创建时间、用户信息等。
[*]sessionDestroyed(HttpSessionEvent se)：当 HttpSession 被销毁时触发。可以在这个方法中执行清理操纵，例如记录会话的销毁时间。
实现步调

（1）创建监听器类

创建一个类并实现 HttpSessionListener 接口，重写上述两个方法。例如：
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class MyHttpSessionListener implements HttpSessionListener {
private int activeSessions = 0;

@Override
public void sessionCreated(HttpSessionEvent se) {
   activeSessions++;
   System.out.println("会话创建：" + se.getSession().getId());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   activeSessions--;
   System.out.println("会话销毁：" + se.getSession().getId());
}

public int getActiveSessions() {
   return activeSessions;
}
}
（2）注册监听器

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

[*]在 web.xml 中配置：<listener>
<listener-class>com.example.MyHttpSessionListener</listener-class>
</listener>

[*]利用 @WebListener 注解（推荐，实用于 Servlet 3.0 及以上版本）：import javax.servlet.annotation.WebListener;

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

[*]通过 Java 配置（实用于 Spring 等框架）：import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;

@Configuration
public class ListenerConfig {
@Bean
public ServletListenerRegistrationBean<MyHttpSessionListener> sessionListener() {
   return new ServletListenerRegistrationBean<>(new MyHttpSessionListener());
}
}

示例应用

（1）统计在线用户数

通过监听会话的创建和销毁，统计当前在线的用户数：
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class OnlineUserCounter implements HttpSessionListener {
private int activeSessions = 0;

@Override
public void sessionCreated(HttpSessionEvent se) {
   activeSessions++;
   System.out.println("当前在线用户数：" + activeSessions);
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   activeSessions--;
   System.out.println("当前在线用户数：" + activeSessions);
}
}
（2）记录会话的创建和销毁时间

在会话创建和销毁时记录时间戳，便于后续分析：
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

public class SessionLogger implements HttpSessionListener {
@Override
public void sessionCreated(HttpSessionEvent se) {
   System.out.println("会话创建于：" + new java.util.Date());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   System.out.println("会话销毁于：" + new java.util.Date());
}
}
通过以上方式，HttpSessionListener 可以在 Web 应用中对会话的生命周期举行监听，从而实现会话管理、在线用户统计等功能。

6️⃣ 参考 6

HttpSessionListener 是一个接口，用于监听 HTTP 会话（session）的生命周期事件。通过实现这个接口，可以在会话创建和销毁时执行特定的代码。
步调：

[*]创建一个类，实现 HttpSessionListener 接口。
[*]重写两个方法：

[*]sessionCreated(HttpSessionEvent se)：在会话创建时调用。
[*]sessionDestroyed(HttpSessionEvent se)：在会话销毁时调用。

[*]在 web.xml 文件中注册监听器，大概利用注解 @WebListener。
代码示例：

1. 创建监听器类

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;

@WebListener
public class MyHttpSessionListener implements HttpSessionListener {

@Override
public void sessionCreated(HttpSessionEvent se) {
   System.out.println("会话创建，ID: " + se.getSession().getId());
   // 在这里执行会话创建时的操作，例如记录日志、初始化会话相关资源等
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   System.out.println("会话销毁，ID: " + se.getSession().getId());
   // 在这里执行会话销毁时的操作，例如释放资源等
}
}
2. 利用 web.xml 注册监听器（可选）

如果你不利用注解，可以在 web.xml 文件中注册监听器：
<listener>
<listener-class>com.example.MyHttpSessionListener</listener-class>
</listener>
解释：

[*]@WebListener 注解：这是 Servlet 3.0 及以上版本提供的注解，用于简化监听器的注册。
[*]sessionCreated 方法：在会话创建时调用，可以在这里举行一些初始化操纵。
[*]sessionDestroyed 方法：在会话销毁时调用，可以在这里举行一些清理操纵。
通过这种方式，你可以更好地控制会话的生命周期，执行必要的初始化和清理任务。

7️⃣ 参考 7

https://i-blog.csdnimg.cn/direct/c2785c07cba64bec9f1ade5b7fcd004e.png
HttpSessionListener 利用详解及示例代码

一、核心作用

HttpSessionListener 用于监听 HTTP 会话的创建与销毁事件，紧张应用于：

[*]会话生命周期监控：统计在线用户数目
[*]资源自动释放：会话过期时自动释放数据库连接等资源
[*]登录状态跟踪：记录用户登录/退出时间
[*]安全审计：检测异常会话创建举动（如短时间内高频创建会话）
二、实现步调

1. 创建监听器类
实现 javax.servlet.http.HttpSessionListener 接口：
import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.concurrent.atomic.AtomicInteger;

@WebListener
public class SessionMonitor implements HttpSessionListener {
// 使用原子类保证线程安全
private final AtomicInteger activeSessions = new AtomicInteger();

@Override
public void sessionCreated(HttpSessionEvent se) {
   activeSessions.incrementAndGet();
   System.out.printf("[会话创建] ID: %s | 当前活跃会话数: %d%n",
                     se.getSession().getId(), activeSessions.get());
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   activeSessions.decrementAndGet();
   System.out.printf("[会话销毁] ID: %s | 剩余活跃会话数: %d%n",
                     se.getSession().getId(), activeSessions.get());

   // 清理会话关联资源示例
   cleanSessionResources(se.getSession());
}

private void cleanSessionResources(HttpSession session) {
   Object dbConnection = session.getAttribute("DB_CONNECTION");
   if (dbConnection != null) {
         ((AutoCloseable)dbConnection).close();
   }
}
}
2. 配置方式（二选一）

[*]注解配置（Servlet 3.0+）：@WebListener // 类注解直接生效

[*]XML 配置（兼容旧版本）：<web-app>
<listener>
   <listener-class>com.example.SessionMonitor</listener-class>
</listener>
</web-app>

三、典范应用场景

场景实现方法技术要点在线用户统计通过原子计数器增减会话数目利用 AtomicInteger 保证线程安全会话超时管理在 web.xml 配置超时时间<session-config><session-timeout>30</session-timeout></session-config>登录状态跟踪联合 HttpSessionAttributeListener监听 USER_LOGIN 属性的变革异常会话检测记录会话创建时间戳和 IP 地址通过 se.getSession().getCreationTime() 和 request.getRemoteAddr() 四、进阶用法示例

1. 联合 Spring 管理 Bean
（需配置 Listener 的 Spring 托管）：
@Component
public class SpringAwareSessionListener implements HttpSessionListener {
@Autowired
private AuditService auditService; // Spring 管理的 Bean

@Override
public void sessionCreated(HttpSessionEvent se) {
   auditService.logSessionActivity(se.getSession().getId(), "CREATED");
}
}
2. 会话超时动态配置
通过 HttpSession.setMaxInactiveInterval() 实现差异化超时：
@Override
public void sessionCreated(HttpSessionEvent se) {
if (isVIPUser(se.getSession())) {
   se.getSession().setMaxInactiveInterval(3600); // VIP用户1小时超时
} else {
   se.getSession().setMaxInactiveInterval(900); // 普通用户15分钟
}
}
五、注意事项

[*] 线程安全计划
全部会话共享监听器实例，必须利用线程安全容器：
private final ConcurrentHashMap<String, SessionInfo> sessionMap = new ConcurrentHashMap<>();

[*] 内存走漏防范
克制在监听器中直接存储 Session 对象：
// 错误示例
static List<HttpSession> sessions = new ArrayList<>();

// 正确做法：存储必要元数据
sessionMap.put(session.getId(), new SessionInfo(session.getCreationTime()));

[*] 与 ServletRequestListener 的协作
监听器类型触发场景典范用途HttpSessionListener会话创建/销毁全局会话统计ServletRequestListener每个 HTTP 请求请求级日记记录
六、调试技巧

在 web.xml 中设置会话超时时间（单位：分钟）：
<session-config>
<session-timeout>5</session-timeout> 
</session-config>

8️⃣ 参考 8

HttpSessionListener 是 Java Servlet 规范中用于监听 HTTP 会话（Session）生命周期的核心接口，紧张用于在会话创建和销毁时执行全局业务逻辑。以下是其核心用法及实践指南：
一、接口核心方法与作用

[*] sessionCreated(HttpSessionEvent se)
触发机遇：当用户首次访问 Web 应用或新会话被显式创建时触发。
典范应用：
• 在线人数统计：通过原子计数器递增在线用户数
• 会话初始化：预加载用户个性化配置到会话属性
@Override
public void sessionCreated(HttpSessionEvent se) {
AtomicInteger onlineUsers = (AtomicInteger) se.getSession().getServletContext().getAttribute("onlineUsers");
onlineUsers.incrementAndGet();// 在线人数+1
}

[*] sessionDestroyed(HttpSessionEvent se)
触发机遇：会话超时（默认 30 分钟）或调用session.invalidate()时触发。
典范应用：
• 资源清理：释放会话占用的数据库连接或文件句柄
• 数据长期化：将用户临时数据保存到数据库
@Override
public void sessionDestroyed(HttpSessionEvent se) {
HttpSession session = se.getSession();
User user = (User) session.getAttribute("currentUser");
userService.saveUserActivity(user);// 保存用户行为日志
}

二、实现与配置步调

[*] 创建监听器类
实现接口并重写两个核心方法，可通过@WebListener注解（Servlet 3.0+）或web.xml配置：
@WebListener
public class OnlineUserListener implements HttpSessionListener {
private static final AtomicInteger counter = new AtomicInteger(0);

@Override
public void sessionCreated(HttpSessionEvent se) {
   counter.incrementAndGet();
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   counter.decrementAndGet();
}
}

[*] XML 配置（传统方式）
在web.xml中添加：
<listener>
<listener-class>com.example.OnlineUserListener</listener-class>
</listener>
<context-param>
<param-name>onlineUsers</param-name>
<param-value>0</param-value>
</context-param>

三、典范应用场景

场景实现方案技术要点在线人数统计利用AtomicInteger或ServletContext属性维护计数需考虑并发安全，推荐利用原子类会话超时管理在web.xml中配置<session-timeout>（单位：分钟）超时时间过短大概导致用户体验差，过长大概占用服务器资源分布式会话同步联合 Redis 等缓存中间件存储会话数据需重写sessionDestroyed实现跨节点数据同步资源释放在sessionDestroyed中关闭会话相干的 I/O 流或线程池需捕获异常防止资源走漏四、注意事项

[*] 并发安全性
在线人数统计需利用线程安全对象（如AtomicInteger），克制直接操纵ServletContext中的普通整型变量。
[*] 会话销毁触发条件
除了显式调用invalidate()，服务器重启、应用重新部署也会触发销毁事件，需在代码中处理异常中断情况。
[*] 性能影响
克制在监听器中执行耗时操纵（如复杂 SQL 查询），否则大概壅闭请求处理线程。
通过合理应用 HttpSessionListener，开辟者可以实现风雅化的会话管理，为 Web 应用提供可靠的用户状态跟踪本领。详细实现细节可参考Servlet 官方文档及示例代码。

9️⃣ 参考 9

HttpSessionListener 是 Java Web 开辟中用于监听 HTTP 会话（HttpSession）生命周期的接口。它允许你在会话创建和销毁时执行自界说逻辑（如统计在线用户、记录会话信息、分配资源等）。以下是其核心用法：
核心方法

[*] sessionCreated(HttpSessionEvent se)

[*]在会话对象（HttpSession）被创建时触发（当客户端首次访问需要会话支持的资源时）。
[*]常用于初始化会话级数据（如记录用户登录时间、分配唯一标识等）。

[*] sessionDestroyed(HttpSessionEvent se)

[*]在会话对象被销毁时触发（当会话超时、调用 invalidate() 或应用关闭时）。
[*]常用于清理资源或记录会话结束信息（如记录用户下线时间、释放临时文件等）。

利用步调

[*] 实现接口
创建一个类实现 HttpSessionListener 接口，并重写两个方法：
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import javax.servlet.annotation.WebListener;

@WebListener // 使用注解注册监听器（Servlet 3.0+）
public class MySessionListener implements HttpSessionListener {
@Override
public void sessionCreated(HttpSessionEvent se) {
   System.out.println("会话已创建！ID: " + se.getSession().getId());
   // 初始化逻辑（如记录用户登录时间）
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
   System.out.println("会话已销毁！ID: " + se.getSession().getId());
   // 清理逻辑（如清除用户缓存数据）
}
}

[*] 配置监听器

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

典范应用场景

[*] 统计在线用户数：
通过监听器维护全局计数器（如在 ServletContext 中保存在线人数），在 sessionCreated 时增加计数，在 sessionDestroyed 时减少计数。
// 示例：在 sessionCreated 中增加计数
int count = (int) se.getSession().getServletContext().getAttribute("onlineCount");
se.getSession().getServletContext().setAttribute("onlineCount", count + 1);

[*] 资源分配与释放：
如为每个会话分配临时文件或数据库连接，并在会话销毁时释放资源。
[*] 安全监控：
记录会话创建和销毁时间，检测异常举动（如频仍创建会话）。
注意事项

[*]线程安全：
会话大概被多个请求并发访问，需确保共享资源（如计数器）的操纵线程安全。例如利用 AtomicInteger 或同步块。
[*]分布式环境：
在集群中，会话大概分布于多个服务器，需通过粘性会话或共享存储（如 Redis）确保监听器逻辑的一致性。
[*]销毁机遇：
会话销毁的触发条件包括超时、invalidate() 调用或应用关闭。需确保逻辑在全部场景下精确执行。
[*]与 HttpSessionBindingListener 的区别：
HttpSessionListener 监听会话的创建和销毁，而 HttpSessionBindingListener 监听对象绑定到会话或解除绑定的事件。
通过 HttpSessionListener，你可以有效管剖析话生命周期，实现会话级别的监控、资源控制和业务逻辑扩展。

页: [1]

IT评测·应用市场-qidao123.com技术社区's Archiver

HttpSessionListener 的用法笔记250417