Skip to content

会话-Session ​

[TOC]

概述 ​

HTTP 无状态痛点 ​

HTTP(HyperText Transfer Protocol)本质上是一种无状态(Stateless)协议。Web 容器在处理每一次 HTTP 请求时,都会将其视为完全独立的事务,协议栈自身不会记录当前请求与历史请求之间的上下文关联。

在只读静态页面场景下,无状态设计能够简化服务端实现并提升吞吐量;但在需要连续交互的动态 Web 应用(如用户登录认证、多步表单提交、权限校验与购物车结算)中,无状态特性会带来直接的业务痛点:

  1. 跨请求身份丢失:客户端在 /login 接口完成账号密码认证后,紧接着发起 /profile 请求访问个人中心。由于两次请求各自使用独立的 HttpServletRequest 实例,服务端无法直接判断第二次请求是否来自刚刚登录成功的同一客户端。

  2. 客户端 Cookie 方案的局限性:虽然可以通过向浏览器下发 Cookie 在客户端保存状态,但 Cookie 存在明显的架构瓶颈:

    • 安全风险高:Cookie 明文存储在浏览器端,且随每次 HTTP 请求在网络中传输,若直接存放用户权限、账户余额等敏感业务状态,极易遭遇抓包窃取或客户端恶意篡改。
    • 容量与类型受限:单个 Cookie 的大小通常被限制在 4KB 以内,且仅支持存储 ASCII 字符串,无法直接存放复杂的 Java 业务对象。
    • 网络带宽损耗:同一域名路径下的所有请求都会自动携带匹配的 Cookie 请求头,若存储大量业务数据,会显著增加每次请求的报文体积。

HttpSession ​

为了解决客户端存储的安全与容量瓶颈,Servlet 规范提供了以 HttpSession 接口为核心的服务端会话方案。其核心设计思想是“客户端持有轻量级凭证,服务端托管重量级状态数据”。

image-20261116141003792

在一次完整的跨请求交互周期中,HttpSession 的协作流程如下:

  1. 按需创建服务端会话:当客户端首次访问需要记录状态的业务接口时,Servlet 调用 request.getSession()。容器在服务端内存中实例化一个 HttpSession 对象,并为其分配一个全局唯一、高熵随机的会话标识符(Session ID)。

  2. 绑定属性与下发凭证:服务端将当前用户的业务状态(如已认证的 User 实体、权限集合等)以键值对形式存储在服务端 HttpSession 对象的内存容器中;同时,容器在 HTTP 响应头中自动写入 Set-Cookie: JSESSIONID=<SessionID>,仅将该唯一标识作为凭证下发给浏览器。

  3. 客户端自动回传凭证:浏览器接收到响应后,将 JSESSIONID 保存在会话级 Cookie 中。当该浏览器再次向同一 Web 应用发起后续请求时,会在请求头中自动附带 Cookie: JSESSIONID=<SessionID>。

  4. 服务端寻址与状态恢复:Web 容器解析后续请求中的 JSESSIONID 值,在服务端会话管理器(Manager)的哈希表中检索出对应的 HttpSession 实例,将其挂载到当前 HttpServletRequest 上下文中,从而实现跨请求的状态共享。

Cookie 与 HttpSession 并非互斥替代关系,在绝大多数标准 Web 场景下,HttpSession 底层恰恰依赖 Cookie(即 JSESSIONID)来完成客户端与服务端会话实例的绑定。二者在存储机制与工程特性上的核心差异如下表所示:

对比维度CookieHttpSession
数据存储位置客户端浏览器(内存或本地磁盘文件)服务端容器内存(可配置持久化至磁盘或外部缓存如 Redis)
存储数据类型仅支持纯文本字符串(String)支持任意 Java 对象(Object,涉及分布式传输或钝化时需实现 Serializable)
存储容量上限单个 Cookie 严格受限(约 4KB),且单域名下总数量受限协议层无硬性上限,取决于服务端 JVM 堆内存容量(需控制单会话体积防 OOM)
数据安全性暴露在客户端,易被查看、伪造或篡改,敏感数据必须加密签名业务数据保留在服务端受控环境,客户端仅持有无业务语义的 JSESSIONID 标识
网络传输开销每次同路径请求均完整携带所有匹配的键值对,数据量大时浪费带宽每次请求仅传输固定长度的 JSESSIONID 字符串,网络带宽开销恒定且极小
服务端资源消耗不占用服务端内存资源活跃会话常驻服务端堆内存,高并发场景下需合理配置超时时间与清理策略
默认生命周期默认随浏览器进程关闭而销毁;设置正数 MaxAge 后可跨进程持久化默认空闲超时销毁(Tomcat 默认为 30 分钟滑动窗口),与浏览器是否关闭无直接绑定

示例: 登录状态保持与跨请求共享 ​

下面通过两个相互配合的 Servlet 演示 HttpSession 的基本工作流程:LoginServlet 负责验证用户身份并在服务端写入会话状态,ProfileServlet 负责在后续独立请求中校验会话并读取共享数据。

LoginServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

// 1. 处理用户登录请求并在服务端创建 HttpSession 会话
@WebServlet("/login")
public class LoginServlet extends HttpServlet {

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    req.setCharacterEncoding("UTF-8");
    String username = req.getParameter("username");
    String password = req.getParameter("password");

    // 2. 校验账号密码,认证通过后获取或创建当前客户端关联的 HttpSession
    if ("admin".equals(username) && "secret".equals(password)) {
      HttpSession session = req.getSession();

      // 3. 将登录用户标识写入服务端 Session 域,容器自动下发 JSESSIONID
      session.setAttribute("currentUser", username);
      resp.sendRedirect(req.getContextPath() + "/profile");
    } else {
      resp.sendError(HttpServletResponse.SC_UNAUTHORIZED, "用户名或密码错误");
    }
  }
}

ProfileServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

// 1. 在后续跨请求中读取已存在的 HttpSession 验证登录状态
@WebServlet("/profile")
public class ProfileServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType("text/plain;charset=UTF-8");

    // 2. 传入 false 仅检索当前已存在的会话,避免未登录请求无故创建空会话
    HttpSession session = req.getSession(false);
    if (session == null || session.getAttribute("currentUser") == null) {
      resp.sendError(HttpServletResponse.SC_FORBIDDEN, "请先登录");
      return;
    }

    // 3. 从服务端会话域中提取绑定属性并响应客户端
    String currentUser = (String) session.getAttribute("currentUser");
    resp.getWriter().write("当前登录用户: " + currentUser + ", SessionID: " + session.getId());
  }
}

API: HttpSession ​

属性管理 ​

  • abstract Object getAttribute():(String name),读取绑定属性。返回当前会话域中指定名称绑定的对象引用;若该名称下未绑定任何对象,则返回 null。

  • abstract Enumeration<String> getAttributeNames():(),获取属性名枚举。返回包含当前会话域中所有已绑定属性名称的 Enumeration<String> 枚举对象,常用于遍历审查会话状态。

  • abstract void setAttribute():(String name, Object value),绑定或覆盖属性。使用指定名称将对象绑定到当前会话域中;若同名属性已存在则覆盖旧值,若传入的 value 为 null 则等效于调用 removeAttribute() 删除该属性。

  • abstract void removeAttribute():(String name),移除指定属性。从当前会话域中解绑并删除指定名称对应的属性;若该名称不存在则不执行任何操作。

注意事项:

  1. 传入 null 值的隐式删除语义:底层容器(如 Tomcat 的 StandardSession)使用 ConcurrentHashMap 存储属性,不支持存入 null 值。当调用 setAttribute(name, null) 时,容器内部会自动将其转换为 removeAttribute(name) 调用并触发属性移除监听事件。
  2. 废弃方法替代说明:早期 Servlet 规范中的 getValue(String)、putValue(String, Object)、removeValue(String) 以及 getValueNames() 自 Servlet 2.2 起均已标记为 @Deprecated,在现代开发中应统一使用 getAttribute、setAttribute、removeAttribute 与 getAttributeNames 替代。
  3. 已销毁会话的非法状态异常:一旦当前会话因超时或调用 invalidate() 失效,再次调用上述任意属性读写方法均会立即抛出 IllegalStateException。
java
import org.springframework.mock.web.MockHttpSession;
import javax.servlet.http.HttpSession;
import java.util.Enumeration;

// 1. 演示 HttpSession 会话域属性的绑定、读取、遍历与移除
public class SessionAttributeDemo {

  public static void main(String[] args) {
    HttpSession session = new MockHttpSession();

    // 2. 向当前会话域绑定业务属性,同名键会自动覆盖旧值
    session.setAttribute("username", "admin");
    session.setAttribute("role", "USER");
    session.setAttribute("role", "SUPER_ADMIN");

    // 3. 按属性名读取会话域中绑定的对象并转型
    String role = (String) session.getAttribute("role");
    System.out.println("当前角色: " + role);

    // 4. 获取所有属性名的枚举快照并遍历输出
    Enumeration<String> names = session.getAttributeNames();
    while (names.hasMoreElements()) {
      String name = names.nextElement();
      System.out.println(name + " = " + session.getAttribute(name));
    }

    // 5. 显式移除指定属性,或通过传入 null 值等效删除属性
    session.removeAttribute("role");
    session.setAttribute("username", null);
  }
}

元数据获取 ​

  • abstract String getId():(),获取会话唯一标识。返回由 Servlet 容器分配给当前会话的全局唯一标识符字符串(即 JSESSIONID 的值)。

  • abstract long getCreationTime():(),获取创建时间戳。返回当前会话被创建的毫秒级时间戳(自 GMT 1970 年 1 月 1 日 00:00:00 起的毫秒数)。

  • abstract long getLastAccessedTime():(),获取最后访问时间。返回客户端最后一次发送携带该会话标识请求时的毫秒级时间戳,容器依据该值计算会话空闲时长。

  • abstract ServletContext getServletContext():(),获取所属应用上下文。返回当前会话所属 Web 应用的全局 ServletContext 实例引用。

注意事项:

  1. getLastAccessedTime() 的更新时机:应用层对会话属性执行 getAttribute 或 setAttribute 不会刷新 lastAccessedTime;只有当客户端发起一次新的 HTTP 请求并由容器检索命中该会话时,容器才会在请求入口处更新该时间戳。
  2. getSessionContext() 已废弃且失效:接口中早期的 getSessionContext() 方法因允许遍历获取全站所有会话 ID 而存在严重安全隐患,自 Servlet 2.1 起已被彻底废弃,现代容器实现固定返回空的虚拟对象或 null。
java
import org.springframework.mock.web.MockHttpSession;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpSession;

// 1. 演示 HttpSession 唯一标识、时间戳及所属应用上下文的获取
public class SessionMetadataDemo {

  public static void main(String[] args) {
    HttpSession session = new MockHttpSession();

    // 2. 获取容器分配的全局唯一会话标识符(JSESSIONID)
    String sessionId = session.getId();
    System.out.println("Session ID: " + sessionId);

    // 3. 获取会话创建时间戳与最后一次请求访问时间戳
    long creationTime = session.getCreationTime();
    long lastAccessedTime = session.getLastAccessedTime();
    System.out.println("创建时间(ms): " + creationTime + ", 最后访问(ms): " + lastAccessedTime);

    // 4. 获取当前会话归属的全局 ServletContext 容器上下文
    ServletContext context = session.getServletContext();
    System.out.println("Context 路径: " + context.getContextPath());
  }
}

生命周期管理 ​

  • abstract void setMaxInactiveInterval():(int interval),设置最大空闲时间。指定客户端两次连续请求之间的最大允许空闲秒数,超过该时长会话将被容器自动销毁;设为 0 或负数表示当前会话永不超时。

  • abstract int getMaxInactiveInterval():(),获取最大空闲时间。返回当前会话配置的最大允许空闲秒数(默认继承自 web.xml 的配置值),负数表示永不超时。

  • abstract boolean isNew():(),判断是否为新建会话。若服务端刚刚创建该会话,但客户端尚未确认或尚未在后续请求中回传该会话标识(如首次响应阶段或客户端禁用了 Cookie),则返回 true。

  • abstract void invalidate():(),显式销毁当前会话。立即使当前会话失效,将其从容器会话管理器中移除并解绑内部存储的所有业务属性,常用于用户主动退出登录。

注意事项:

  1. 时间单位差异:setMaxInactiveInterval(int) 与 getMaxInactiveInterval() 的参数及返回值单位均为秒(Seconds),而 web.xml 中 <session-timeout> 标签的配置单位为分钟(Minutes),且代码级设置仅对当前单个 HttpSession 实例生效。
  2. 慎用永不超时配置:将 maxInactiveInterval 设置为 0 或负数会使该会话脱离后台清理线程的超时回收机制,若客户端关闭浏览器流失凭证且未主动调用 invalidate(),该会话将常驻 JVM 堆内存直至容器停机,高并发下极易引发内存泄漏。
java
import org.springframework.mock.web.MockHttpSession;
import javax.servlet.http.HttpSession;

// 1. 演示 HttpSession 超时阈值设置、新建状态判定与显式销毁
public class SessionLifecycleDemo {

  public static void main(String[] args) {
    HttpSession session = new MockHttpSession();

    // 2. 判断当前会话是否为客户端尚未回传确认的新建状态
    boolean isNew = session.isNew();
    System.out.println("是否为新建会话: " + isNew);

    // 3. 设置当前会话的最大允许空闲秒数并读取生效配置
    session.setMaxInactiveInterval(1800);
    int maxIdleSeconds = session.getMaxInactiveInterval();
    System.out.println("最大允许空闲时间(秒): " + maxIdleSeconds);

    // 4. 立即销毁当前会话并解绑所有属性,销毁后再次读写将抛出 IllegalStateException
    session.invalidate();
  }
}

JSESSIONID 会话追踪 ​

会话寻址与创建流程 ​

由于 HTTP 协议本身不具备状态感知能力,Web 容器必须在每次请求到达时,通过一套标准化的凭证提取与哈希寻址流程,将当前 HttpServletRequest 与服务端内存中的 HttpSession 实例重新关联。

在 Tomcat 容器中,HttpServletRequest.getSession() 与 getSession(boolean create) 底层统一委托给 org.apache.catalina.connector.Request.doGetSession(boolean create) 执行。

image-20261116141036375

容器在单次请求中解析 JSESSIONID 并定位会话的完整执行步骤如下:

  1. 请求级缓存复用:容器首先检查当前 Request 对象内部是否已持有 Session 引用(this.session != null)。若同一请求链路(例如前置 Filter 或 RequestDispatcher.forward 转发)已经解析过会话,容器仅校验该会话的 isValid() 状态;若有效则直接返回缓存引用,避免重复寻址。

  2. **解析客户端 requestedSessionId**:若当前请求尚未绑定会话,容器在请求预处理阶段(CoyoteAdapter.postParseRequest)按已启用的追踪模式提取会话标识:

    • 优先扫描请求 URI 中是否包含路径参数 ;jsessionid=<id>,若存在则将其提取为 requestedSessionId,并标记 requestedSessionIdFromURL = true。
    • 若 URI 中未携带,则遍历 Cookie 请求头查找名为 JSESSIONID(或自定义名称)的键值对,若存在则提取为 requestedSessionId,并标记 requestedSessionIdFromCookie = true。
  3. Manager 哈希表寻址:当 requestedSessionId 非空时,容器调用当前 Context 关联的会话管理器 Manager.findSession(requestedSessionId),在服务端内存的 ConcurrentHashMap 中检索匹配的 Session 对象:

    • 若成功命中且该会话未超时失效,容器调用 session.access() 刷新其最后访问时间戳(lastAccessedTime),将其缓存至当前 Request 并直接返回。
    • 若未命中或命中的会话已过期销毁,则视为寻址失败,进入后续创建决策分支。
  4. create 参数分支决策:当客户端未携带 JSESSIONID 或携带的旧标识在服务端已失效时,容器根据传入的 create 布尔参数决定行为:

    • create == false:立即终止流程并返回 null,不会在服务端分配任何内存,也不会向响应头写入 Set-Cookie。
    • create == true:调用 Manager.createSession(null) 创建全新的 StandardSession 实例,由 StandardSessionIdGenerator 基于 SecureRandom 生成 16 字节(编码为 32 位十六进制字符串)的高熵随机 JSESSIONID,将其注册到管理器的并发哈希表中,同时当追踪模式包含 COOKIE 时自动向 HTTP 响应头写入 Set-Cookie: JSESSIONID=<newId>。

在工程实践中,应当根据接口职责严格区分两种重载方法的调用场景:

调用方式寻址命中时寻址未命中时响应头副作用典型适用场景
getSession() / getSession(true)刷新访问时间并返回已有 HttpSession分配新 StandardSession 并生成新 JSESSIONID自动追加 Set-Cookie: JSESSIONID=...用户登录成功写入身份、首次向购物车添加商品、生成图形验证码
getSession(false)刷新访问时间并返回已有 HttpSession不创建对象,直接返回 null无任何响应头副作用权限认证 Filter 校验登录态、只读业务接口检查状态、安全退出登录(logout)

SessionTrackingMode ​

Servlet 3.0 规范引入了 javax.servlet.SessionTrackingMode 枚举,用于定义客户端与服务端之间传递会话标识的底层通道。规范共支持三种标准追踪模式:

COOKIE 是所有 Servlet 容器默认启用的核心追踪模式。当服务端首次创建会话时,容器会自动向响应报文注入如下响应头:

http
Set-Cookie: JSESSIONID=4A9F8B2C1D3E5F6A7B8C9D0E1F2A3B4C; Path=/app; HttpOnly

在使用默认 COOKIE 追踪模式时,必须注意以下两个核心特性:

  1. 浏览器关闭导致会话失联(默认 MaxAge = -1):容器自动生成的 JSESSIONID 默认不设置 Max-Age 或 Expires 属性(即 maxAge = -1),属于浏览器内存级的会话 Cookie。一旦用户关闭浏览器进程,客户端内存中的 JSESSIONID 会被立即清除;但此时服务端内存中的 HttpSession 对象并未销毁,它会继续驻留在服务端堆内存中直至空闲超时(如 30 分钟后)。当用户重新打开浏览器访问站点时,由于请求不再携带原来的 JSESSIONID,服务端无法找回原会话,只能重新分配一个新的 HttpSession。若业务要求关闭浏览器后再打开仍能恢复原会话,必须显式为 JSESSIONID 设置正数的 MaxAge。

  2. HttpOnly 防护:现代容器(如 Tomcat 7+)默认在 JSESSIONID 响应头中附加 HttpOnly 标记,禁止前端通过 document.cookie 读取该凭证,从而防范跨站脚本(XSS)攻击窃取会话标识。

URL ​

当客户端浏览器因隐私策略彻底禁用 Cookie 时,客户端将无法保存并回传 Set-Cookie 下发的 JSESSIONID。此时可通过 URL 重写(URL Rewriting)模式作为降级方案,将会话标识作为路径参数(Matrix Parameter)直接拼接在请求地址中:

text
http://localhost:8080/app/profile;jsessionid=4A9F8B2C1D3E5F6A7B8C9D0E1F2A3B4C?tab=security

使用 URL 追踪模式时需遵循以下规则与安全边界:

  1. 语法位置规范:;jsessionid=<id> 属于 URI 路径段参数,必须紧跟在资源路径之后、查询字符串 ? 之前,且以分号 ; 而非问号或 & 分隔。

  2. 显式编码要求:不同于浏览器自动附加 Cookie,URL 重写需要开发者在输出 HTML 页面链接或执行重定向时,显式调用 response.encodeURL(String url) 或 response.encodeRedirectURL(String url) 对目标地址进行包装。

  3. 容器的智能试探逻辑:encodeURL 并不会无条件拼接 ;jsessionid=。当服务端刚刚创建新会话并生成第一次响应时,容器尚不确定客户端是否启用了 Cookie,因此会在下发 Set-Cookie 响应头的同时,将页面中经过 encodeURL 处理的链接全部追加 ;jsessionid=(双通道并行试探)。若客户端在第二次请求中通过 Cookie 请求头成功回传了 JSESSIONID(即 request.isRequestedSessionIdFromCookie() 为 true),容器便确认该客户端支持 Cookie,后续响应中调用 encodeURL 将直接原样返回原始 URL,不再执行重写。

  4. 会话固定(Session Fixation)安全隐患:将 JSESSIONID 暴露在 URL 地址栏中风险极高。攻击者可预先访问站点获取一个合法的 ;jsessionid=xxx 链接并诱导受害者点击登录,受害者认证成功后该会话即升级为已登录状态,攻击者凭已知 ID 即可直接劫持会话;此外,URL 中的会话 ID 极易通过浏览器历史记录、服务端 Access Log 日志以及外链跳转时的 Referer 请求头泄露。因此在不要求兼容禁用 Cookie 的现代生产系统中,强烈建议显式关闭 URL 追踪模式。

SSL ​

SSL 模式仅在全站 HTTPS 通信下可用。它直接复用 TLS/SSL 握手阶段在传输层协商生成的加密会话标识(SSL Session ID)作为上层 HttpSession 的唯一检索键,既不依赖 Cookie 也不修改 URL。但由于现代生产架构普遍在反向代理层(如 Nginx、云端 ALB)执行 SSL 卸载(SSL Termination),后端 Tomcat 接收到的往往是降级后的普通 HTTP 流量,且 TLS 会话票据(Session Ticket)刷新会导致标识变更,因此在工程中较少单独启用该模式。

示例: JSESSIONID 追踪配置与降级处理 ​

以下通过声明式配置、编程式监听器以及 Servlet 读写示例,完整演示 JSESSIONID 属性定制与 URL 重写降级的实现方式。

web.xml ​

xml
<session-config>
    <!-- 1. 配置服务端会话空闲超时时间为 30 分钟 -->
    <session-timeout>30</session-timeout>

    <!-- 2. 自定义 JSESSIONID Cookie 的安全属性与客户端存活周期 -->
    <cookie-config>
        <name>JSESSIONID</name>
        <http-only>true</http-only>
        <secure>false</secure>
        <max-age>86400</max-age>
    </cookie-config>

    <!-- 3. 显式指定仅使用 COOKIE 追踪模式,禁用 URL 重写 -->
    <tracking-mode>COOKIE</tracking-mode>
</session-config>

SessionConfigListener ​

java
package com.example.session;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.SessionCookieConfig;
import javax.servlet.SessionTrackingMode;
import javax.servlet.annotation.WebListener;
import java.util.EnumSet;

// 1. 在应用启动阶段编程式配置全局会话追踪策略与 JSESSIONID 属性
@WebListener
public class SessionConfigListener implements ServletContextListener {

  @Override
  public void contextInitialized(ServletContextEvent sce) {
    ServletContext context = sce.getServletContext();

    // 2. 强制仅启用 COOKIE 追踪模式,关闭 URL 重写以防范会话固定攻击
    context.setSessionTrackingModes(EnumSet.of(SessionTrackingMode.COOKIE));

    // 3. 获取 SessionCookieConfig 实例,开启 HttpOnly 并延长客户端凭证有效期
    SessionCookieConfig cookieConfig = context.getSessionCookieConfig();
    cookieConfig.setName("JSESSIONID");
    cookieConfig.setHttpOnly(true);
    cookieConfig.setMaxAge(60 * 60 * 24);
  }
}

UrlRewriteServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

// 1. 演示手动持久化 JSESSIONID Cookie 以及禁用 Cookie 时的 URL 重写降级
@WebServlet("/track")
public class UrlRewriteServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType("text/html;charset=UTF-8");
    HttpSession session = req.getSession();

    // 2. 覆盖默认会话级 Cookie,显式设置 MaxAge 使浏览器重启后仍能找回原会话
    Cookie jsessionCookie = new Cookie("JSESSIONID", session.getId());
    jsessionCookie.setPath(req.getContextPath().isEmpty() ? "/" : req.getContextPath());
    jsessionCookie.setHttpOnly(true);
    jsessionCookie.setMaxAge(60 * 30);
    resp.addCookie(jsessionCookie);

    // 3. 对页面跳转链接执行 URL 重写,容器仅在未确认 Cookie 可用时追加 ;jsessionid=
    String targetUrl = resp.encodeURL(req.getContextPath() + "/profile");

    // 4. 检测当前请求的 JSESSIONID 来源通道并输出重写后的链接
    PrintWriter out = resp.getWriter();
    out.println("<p>Session ID: " + session.getId() + "</p>");
    out.println("<p>来自 Cookie: " + req.isRequestedSessionIdFromCookie() + "</p>");
    out.println("<p>来自 URL: " + req.isRequestedSessionIdFromURL() + "</p>");
    out.println("<a href='" + targetUrl + "'>进入个人中心</a>");
  }
}

API: SessionCookieConfig【待补充】 ​

StandardSession 存储结构 ​

ManagerBase ​

在 Tomcat 容器架构中,HttpSession 实例并非游离在堆内存中,而是由从属于 Context(Web 应用上下文)的会话管理器统一托管。所有会话管理器均继承自抽象基类 org.apache.catalina.session.ManagerBase。

容器在内存中采用“应用级会话池 + 会话级属性表”的两级 ConcurrentHashMap 嵌套存储结构:

image-20261116141106873

  1. 第一级映射(JSESSIONID →\rightarrow Session 实例):ManagerBase 内部维护了一个并发哈希表 protected Map<String, Session> sessions = new ConcurrentHashMap<>()。当前 Web 应用下所有活跃的会话实例,均以其唯一的 JSESSIONID 字符串作为 Key 集中注册在该表中。

  2. 第二级映射(attributeName →\rightarrow 业务对象):每个 Session 实例(默认实现类为 StandardSession)内部又独立维护了一个并发哈希表 protected ConcurrentMap<String, Object> attributes = new ConcurrentHashMap<>(),用于存放当前客户端在会话域中绑定的业务键值对。

  3. StandardManager 与 PersistentManager 分工:ManagerBase 提供了两个核心子类实现:

    • StandardManager:Tomcat 默认使用的内存级会话管理器。运行期间所有会话常驻 JVM 堆内存;仅当 Tomcat 正常停机或应用重载时,才会将活跃会话整体序列化写入项目工作目录的 SESSIONS.ser 文件,并在下次启动时反序列化恢复。
    • PersistentManager:支持运行时动态换出(Swap Out)的持久化管理器。当内存中活跃会话数量超过阈值或单个会话空闲时间过长时,后台线程可将部分会话钝化(Passivation)转储至磁盘文件、数据库或外部存储,从而控制单机堆内存占用。

StandardSession ​

org.apache.catalina.session.StandardSession 是 Tomcat 对 HttpSession 的核心实现类。它同时实现了 Servlet 规范标准接口 javax.servlet.http.HttpSession、Tomcat 容器内部接口 org.apache.catalina.Session 以及 java.io.Serializable 序列化接口。

核心元数据与属性字段 ​

每个 StandardSession 实例除了持有存储业务数据的 attributes 容器外,还维护了支撑生命周期计算与并发控制的核心状态字段:

字段名称声明类型修饰符核心职责说明
idStringprotected当前会话的唯一标识符(即 JSESSIONID 的值)
attributesConcurrentMap<String, Object>protected存储当前会话域所有业务键值对的并发哈希表
creationTimelongprotected会话创建时的毫秒级时间戳
thisAccessedTimelongprotected volatile当前正在处理的请求到达时的毫秒级时间戳
lastAccessedTimelongprotected volatile上一次请求访问该会话的毫秒级时间戳,用于计算空闲时长
maxInactiveIntervalintprotected volatile最大允许空闲时间(单位:秒),负数表示永不超时
isNewbooleanprotected volatile标记会话是否在当前请求中刚刚创建且客户端尚未确认接管
isValidbooleanprotected volatile标记当前会话是否处于有效状态,销毁后置为 false
accessCountAtomicIntegerprotected transient记录当前正在并发访问该会话的活动请求线程数
managerManagerprotected transient指向所属 Context 容器的会话管理器引用(不参与序列化)
facadeStandardSessionFacadeprotected transient面向业务层 Servlet 暴露的外观封装对象(不参与序列化)

核心源码实现 ​

在 StandardSession 的属性读写源码中,容器对空值参数与会话有效性进行了严格的防御式校验:

java
package org.apache.catalina.session;

import java.io.Serializable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import javax.servlet.http.HttpSession;
import org.apache.catalina.Manager;
import org.apache.catalina.Session;

// 1. Tomcat 标准会话实现类,同时实现内部 Session 接口与标准 HttpSession 接口
public class StandardSession implements HttpSession, Session, Serializable {

  // 2. 存储当前会话绑定的业务属性键值对,底层采用 ConcurrentHashMap 保证单操作线程安全
  protected ConcurrentMap<String, Object> attributes = new ConcurrentHashMap<>();

  // 3. 会话核心元数据:唯一标识、创建时间、最后访问时间、最大空闲秒数与有效标志
  protected String id = null;
  protected long creationTime = 0L;
  protected volatile long lastAccessedTime = creationTime;
  protected volatile int maxInactiveInterval = -1;
  protected volatile boolean isNew = false;
  protected volatile boolean isValid = false;
  protected transient Manager manager = null;
  protected transient StandardSessionFacade facade = null;

  // 4. 延迟初始化并返回外观包装类,向下层 Servlet 屏蔽容器内部管理方法
  @Override
  public HttpSession getSession() {
    if (facade == null) {
      facade = new StandardSessionFacade(this);
    }
    return facade;
  }

  // 5. 读取会话属性,先校验会话有效性再从 ConcurrentHashMap 中按键检索
  @Override
  public Object getAttribute(String name) {
    if (!isValidInternal()) {
      throw new IllegalStateException("getAttribute: Session already invalidated");
    }
    if (name == null) {
      return null;
    }
    return attributes.get(name);
  }

  // 6. 写入会话属性,当传入 value 为 null 时自动转换为删除属性操作
  @Override
  public void setAttribute(String name, Object value) {
    if (name == null) {
      throw new IllegalArgumentException("Attribute name cannot be null");
    }
    if (value == null) {
      removeAttribute(name);
      return;
    }
    if (!isValidInternal()) {
      throw new IllegalStateException("setAttribute: Session already invalidated");
    }
    attributes.put(name, value);
  }
}

阅读上述源码需重点关注以下三个底层细节:

  1. setAttribute(name, null) 等价于删除:由于底层 ConcurrentHashMap 严格禁止存入 null 键与 null 值(否则会抛出 NullPointerException),Servlet 规范与 Tomcat 源码明确规定:当调用 setAttribute(name, null) 时,容器内部直接拦截并转为调用 removeAttribute(name),将该键从哈希表中移除并触发属性移除事件。

  2. 有效性前置检查(isValidInternal):每次调用 getAttribute、setAttribute、removeAttribute 或 getLastAccessedTime 时,容器都会首先检查 this.isValid 标志。若会话已被调用 invalidate() 显式销毁或已被后台线程判定超时回收,则会立即抛出 java.lang.IllegalStateException。

  3. transient 序列化隔离:manager、facade、accessCount 等容器运行期管理字段均使用 transient 关键字修饰。当会话发生磁盘钝化或跨节点网络传输时,仅序列化 id、时间戳元数据以及 attributes 中的业务对象,避免将整个 Tomcat 容器组件树连带序列化。

StandardSessionFacade ​

当开发者在 Servlet 中调用 request.getSession() 时,拿到的真实对象类型并非 StandardSession,而是 org.apache.catalina.session.StandardSessionFacade。

Tomcat 在此处引入外观模式(Facade Pattern)的核心目的是实现容器内部 API 的安全隔离:

  1. 防止向下转型越权调用:StandardSession 实现了 Tomcat 内部的 org.apache.catalina.Session 接口,该接口暴露了 getManager()、setId(String id)、access()、endAccess()、recycle() 等容器级管理方法。如果直接将 StandardSession 实例暴露给应用层 Servlet,恶意或编写不当的业务代码只需执行强制类型转换 ((org.apache.catalina.Session) session).getManager().findSessions(),即可遍历并篡改当前服务器上所有在线用户的会话数据。

  2. 最小权限委托:StandardSessionFacade 仅实现标准的 javax.servlet.http.HttpSession 接口,内部持有一个 private final HttpSession session 引用。它将所有标准 API 调用原样转发给底层的 StandardSession,同时在类继承体系上彻底切断了向 org.apache.catalina.Session 强转的可能。

java
package org.apache.catalina.session;

import java.util.Enumeration;
import javax.servlet.http.HttpSession;

// 1. 外观封装类仅实现标准 HttpSession 接口,不实现 Tomcat 内部 Session 接口
public class StandardSessionFacade implements HttpSession {

  // 2. 持有底层 StandardSession 实例的私有不可变引用,防止外部反射或强转越权
  private final HttpSession session;

  public StandardSessionFacade(HttpSession session) {
    this.session = session;
  }

  // 3. 将标准会话方法调用委托给内部真实的 StandardSession 实例执行
  @Override
  public String getId() {
    return session.getId();
  }

  // 4. 委托执行属性读取,隔离 expire、recycle 等容器级敏感管理方法
  @Override
  public Object getAttribute(String name) {
    return session.getAttribute(name);
  }

  @Override
  public void setAttribute(String name, Object value) {
    session.setAttribute(name, value);
  }

  @Override
  public Enumeration<String> getAttributeNames() {
    return session.getAttributeNames();
  }
}

示例: 会话域对象读写与遍历 ​

下面通过 SessionAttributeServlet 演示会话属性容器的写入、同名覆盖、传入 null 值自动删除以及运行时真实类型验证。

SessionAttributeServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Enumeration;

// 1. 演示 StandardSession 属性容器的写入、覆盖、空值删除与枚举遍历
@WebServlet("/session/attributes")
public class SessionAttributeServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType("text/plain;charset=UTF-8");
    HttpSession session = req.getSession();

    // 2. 向当前会话的 ConcurrentHashMap 容器写入多个业务属性与复杂对象
    session.setAttribute("role", "ADMINISTRATOR");
    session.setAttribute("loginIp", req.getRemoteAddr());
    session.setAttribute("tempToken", "TOKEN_XYZ");

    // 3. 传入同名键会覆盖旧值,传入 null 值在底层等价于调用 removeAttribute
    session.setAttribute("role", "SUPER_ADMIN");
    session.setAttribute("tempToken", null);

    // 4. 获取属性名枚举快照并遍历输出当前会话域中的所有键值对
    PrintWriter out = resp.getWriter();
    out.println("当前 Session 运行时类型: " + session.getClass().getName());
    Enumeration<String> names = session.getAttributeNames();
    while (names.hasMoreElements()) {
      String name = names.nextElement();
      Object value = session.getAttribute(name);
      out.println(name + " = " + value);
    }
  }
}

HttpSession 生命周期 ​

状态流转 ​

不同于 ServletContext 随 Web 应用启动而创建、随应用卸载而销毁的全局生命周期,HttpSession 的生命周期完全由客户端请求行为与空闲计时器共同驱动。

image-20261116141133843

一个标准 HttpSession 实例在服务端内存中的完整生命周期划分为以下四个阶段:

  1. 延迟创建(Lazy Creation):客户端首次发起 HTTP 请求访问服务器时,容器并不会自动为其创建 HttpSession。如果在整个请求链路中仅访问静态资源(如 HTML、CSS、图片),或在 Servlet 中仅调用 request.getParameter()、request.getSession(false),服务端不会分配任何会话内存。只有当业务代码显式执行 request.getSession() 或 request.getSession(true)(且当前请求未携带有效 JSESSIONID)时,容器才会真正实例化 StandardSession 对象,此时会话进入新建态(New),其内部 isNew 标志位为 true。

    • JSP 的隐式创建陷阱:根据 JSP 规范,.jsp 页面编译为 Servlet 源码时默认启用会话支持(即 <%@ page session="true" %>),会在 _jspService 方法开头自动插入 session = pageContext.getSession()。因此客户端只要访问任意未显式声明 session="false" 的 JSP 页面,就会立即触发会话创建。在无需状态的纯展示型 JSP 页面中,应当显式添加 <%@ page session="false" %> 以节省服务端内存。
  2. 状态确认与转正(New →\rightarrow Active):当会话在首次请求中被创建后,服务端通过 Set-Cookie 或 URL 重写将 JSESSIONID 下发给客户端。只要客户端尚未在后续请求中成功回传该 JSESSIONID,该会话的 session.isNew() 始终返回 true;一旦客户端发起第二次请求并携带该 JSESSIONID 经 Manager.findSession(id) 匹配命中,容器在调用 session.access() 时会将 this.isNew 置为 false,会话正式进入活跃态(Active)。

  3. 滑动窗口续期(Sliding Window Renewal):处于活跃态的会话采用滑动时间窗口而非固定绝对时间计算寿命。客户端每发起一次携带该 JSESSIONID 的有效请求,容器都会将 lastAccessedTime 更新为当前请求到达的时间戳,空闲计时器归零并重新开始倒计时。

  4. 失效与回收(Invalidated / Expired):当会话空闲时长达到最大允许阈值、业务代码主动调用 session.invalidate(),或 Web 应用被卸载销毁时,会话的 isValid 标志被置为 false。此时容器将其从 Manager 的并发哈希表中移除,解绑内部所有业务属性,并触发会话销毁监听事件,最终交由 JVM 垃圾收集器回收堆内存。

空闲超时配置 ​

服务端判定会话是否超时的核心依据是最大允许空闲时间(maxInactiveInterval),即两次连续请求之间的最大时间间隔。只要满足以下不等式,会话即被判定为超时失效:

CurrentTime−lastAccessedTime≥maxInactiveInterval×1000 ms\text{CurrentTime} - \text{lastAccessedTime} \ge \text{maxInactiveInterval} \times 1000\text{ ms}

在 Java Web 应用中,可以通过三个层级配置会话超时时间。它们按照“就近覆盖(粒度越细优先级越高)”的原则生效,且需要注意不同配置方式的时间单位差异:

优先级配置层级配置方式时间单位作用域范围负数或零值含义
1(最高)代码级动态设置session.setMaxInactiveInterval(int)秒(Seconds)仅对当前单个 HttpSession 实例生效≤0\le 0 表示当前会话永不因空闲而超时(慎用,易引发 OOM)
2(中等)应用级 web.xml<session-config><session-timeout>分钟(Minutes)当前 Web 应用创建的所有会话≤0\le 0 表示全站会话永不超时
3(最低)容器级全局默认Tomcat conf/web.xml分钟(Minutes)当前 Tomcat 实例下未自定义超时的所有应用默认配置为 30(即 30 分钟 = 1800 秒)

当 StandardSession 被创建时,容器首先读取应用级 web.xml(若未配置则继承 Tomcat 全局 conf/web.xml)中的分钟数,将其乘以 60 转换为秒数赋给 this.maxInactiveInterval;若后续业务代码针对特定用户(如高频交易员或后台大屏监控账号)调用了 session.setMaxInactiveInterval(seconds),则会直接覆盖该实例的字段值,不影响其他在线用户的超时策略。

过期销毁流程 ​

当一个会话在服务端达到空闲超时时间后,并非在超时的毫秒瞬间立即被清除,同时客户端关闭浏览器也不会主动通知服务端销毁会话。Tomcat 采用“后台线程定期轮询 + 请求访问惰性校验”的双重机制执行过期清理,并与业务层显式调用的 invalidate() 共享底层销毁逻辑 expire(boolean notify)。

  1. 后台定期轮询(backgroundProcess):Tomcat 的容器基类 ContainerBase 启动了一个名为 ContainerBackgroundProcessor 的后台守护线程(默认每隔 10 秒唤醒一次)。ManagerBase 默认每经过 6 次后台周期(即默认每 60 秒)执行一次 processExpires() 方法,遍历当前应用下所有活跃会话并逐一调用 session.isValid()。因此,一个空闲超时的会话在无请求访问时,最多可能在内存中多驻留约 60 秒才被后台线程回收。

  2. 请求惰性校验(Lazy Check):如果在后台线程尚未扫描到的 60 秒间隙内,客户端恰好携带已达超时阈值的 JSESSIONID 发起请求,Request.doGetSession 在调用 session.isValid() 时会立即计算出空闲时间超标,当场同步触发 expire(true) 将旧会话销毁,并视同未命中会话处理。

  3. 显式立即销毁(invalidate):当用户点击“退出登录”或修改密码需要强制下线时,业务代码调用 session.invalidate()。该方法不等待超时,直接调用底层 expire(true) 立即完成销毁。注意:**同一个请求线程在调用 invalidate() 之后,严禁再次对该 session 引用执行 getAttribute 或 setAttribute**,否则容器会因 isValid == false直接抛出IllegalStateException。

java
package org.apache.catalina.session;

import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.catalina.Manager;

// 1. StandardSession 中负责超时判定与会话销毁的核心生命周期源码
public class StandardSession {

  protected volatile boolean isValid = false;
  protected volatile int maxInactiveInterval = -1;
  protected volatile long lastAccessedTime = 0L;
  protected transient AtomicInteger accessCount = null;
  protected transient Manager manager = null;
  protected ConcurrentMap<String, Object> attributes = null;

  // 2. 校验会话是否有效,若空闲时长达到阈值则立即触发 expire 过期回收
  public boolean isValid() {
    if (!this.isValid) {
      return false;
    }
    if (this.accessCount.get() > 0) {
      return true;
    }
    if (maxInactiveInterval > 0) {
      int timeIdle = (int) ((System.currentTimeMillis() - lastAccessedTime) / 1000L);
      if (timeIdle >= maxInactiveInterval) {
        expire(true);
      }
    }
    return this.isValid;
  }

  // 3. 业务层显式销毁入口,校验有效性后直接委托给内部 expire 方法
  public void invalidate() {
    if (!isValidInternal()) {
      throw new IllegalStateException("invalidate: Session already invalidated");
    }
    expire(true);
  }

  // 4. 执行底层销毁:标记失效、从 Manager 移除并逐一解绑清空所有会话属性
  public void expire(boolean notify) {
    if (!this.isValid) {
      return;
    }
    synchronized (this) {
      if (!this.isValid) {
        return;
      }
      this.isValid = false;
      manager.remove(this, true);

      String keys[] = keys();
      for (int i = 0; i < keys.length; i++) {
        removeAttributeInternal(keys[i], notify);
      }
    }
  }
}

从上述 isValid() 源码第 22 行还可以看到一个关键保护逻辑:if (this.accessCount.get() > 0) return true;。如果某个长耗时请求(如大文件导出)正在执行且持有当前会话,即便执行时长超过了 maxInactiveInterval,后台清理线程在请求尚未结束(accessCount > 0)前也绝不会将其强制回收。

示例: 会话生命周期管理 ​

下面通过 SessionLifecycleServlet 与 LogoutServlet 两个组件,分别演示会话新旧状态检测、实例级超时阈值动态调整以及安全退出登录的标准实现。

SessionLifecycleServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.io.PrintWriter;

// 1. 演示 HttpSession 新旧状态判定、时间戳读取与动态超时阈值设置
@WebServlet("/session/lifecycle")
public class SessionLifecycleServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType("text/plain;charset=UTF-8");
    HttpSession session = req.getSession();

    // 2. 针对当前独立会话设置最大允许空闲时间为 15 分钟(900 秒)
    session.setMaxInactiveInterval(15 * 60);

    // 3. 判定当前会话是否为首次创建(客户端尚未回传确认 JSESSIONID)
    boolean isNewSession = session.isNew();
    long creationTime = session.getCreationTime();
    long lastAccessedTime = session.getLastAccessedTime();

    // 4. 输出会话生命周期核心时间戳与当前生效的超时配置
    PrintWriter out = resp.getWriter();
    out.println("Session ID: " + session.getId());
    out.println("是否为新建会话 (isNew): " + isNewSession);
    out.println("创建时间戳 (ms): " + creationTime);
    out.println("最后访问时间戳 (ms): " + lastAccessedTime);
    out.println("最大允许空闲秒数: " + session.getMaxInactiveInterval());
  }
}

LogoutServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

// 1. 处理用户安全注销请求,显式销毁服务端会话并清理客户端凭证
@WebServlet("/logout")
public class LogoutServlet extends HttpServlet {

  @Override
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    // 2. 传入 false 避免为未登录或已过期的客户端无故创建新会话
    HttpSession session = req.getSession(false);

    // 3. 立即将服务端会话标记为失效,从 Manager 移除并解绑所有业务属性
    if (session != null) {
      session.invalidate();
    }

    // 4. 下发同名且 MaxAge 为 0 的 Cookie,通知浏览器立即删除本地 JSESSIONID
    Cookie cookie = new Cookie("JSESSIONID", "");
    cookie.setPath(req.getContextPath().isEmpty() ? "/" : req.getContextPath());
    cookie.setHttpOnly(true);
    cookie.setMaxAge(0);
    resp.addCookie(cookie);

    resp.sendRedirect(req.getContextPath() + "/login.html");
  }
}

HttpSession 事件监听 ​

监听器分类对比 ​

Servlet 规范基于观察者模式(Observer Pattern)提供了一套完整的会话事件监听体系。当 HttpSession 实例的生命周期状态发生跃迁,或会话域(Session Scope)内的业务属性发生增删改及跨介质迁移时,Web 容器会自动构造对应的事件对象并同步回调监听接口。

按照监听器的挂载位置与注册方式,Servlet 规范中的会话监听器划分为两大类别:

  1. 全局容器级监听器(Container-Level Listeners):包括 HttpSessionListener、HttpSessionAttributeListener 与 Servlet 3.1 引入的 HttpSessionIdListener。这类监听器直接挂载在 ServletContext 应用上下文中,必须通过 @WebListener 注解或在 web.xml 中配置 <listener> 标签完成注册。容器在启动时为其创建全局单例,负责无差别拦截当前 Web 应用下所有 HttpSession 实例的生命周期或属性变更事件。

  2. 实体自感知监听器(Object-Aware Listeners):包括 HttpSessionBindingListener 与 HttpSessionActivationListener。这类监听器并非由容器全局管理,而是**由存入会话域的业务 JavaBean 实体类(如 User、ShoppingCart)直接实现,无需在 web.xml 中配置或标注 @WebListener**。容器在执行属性写入、移除或会话序列化时,通过 instanceof 动态检测目标属性对象是否实现了上述接口,进而直接调用该实体对象自身的回调方法。

image-20261116141155316

四类核心 HttpSession 监听接口的职责边界与工程特性对比如下表所示:

监听接口监听粒度注册方式接收事件参数触发时机说明典型业务场景
HttpSessionListener全局所有会话实例@WebListener 或 web.xmlHttpSessionEvent任一 HttpSession 实例被创建或失效销毁时统计全站实时活跃会话总数(含未登录访客)
HttpSessionAttributeListener全局所有会话属性@WebListener 或 web.xmlHttpSessionBindingEvent任一会话域中新增、移除或覆盖替换属性键值对时全站敏感会话属性变更审计、日志追踪
HttpSessionBindingListener单个业务实体对象实体类直接实现(免注册)HttpSessionBindingEvent当前实体对象被绑定存入会话域或从会话域解绑移除时统计已认证在线用户列表、单账号多端登录互踢
HttpSessionActivationListener单个业务实体对象实体类直接实现(免注册)HttpSessionEvent当前实体随所属会话钝化写入磁盘或从磁盘活化恢复时反序列化后重建 transient transient 资源或非序列化连接

HttpSessionListener ​

javax.servlet.http.HttpSessionListener 用于全局监控当前 Web 应用内所有 HttpSession 实例的创建与销毁过程。在工程实践中,使用该监听器统计在线人数或清理会话资源时,必须重点把控以下三个底层执行细节:

  1. 创建事件的精确触发点:容器并非在客户端发起请求时触发创建回调,而是在业务代码首次调用 request.getSession() / getSession(true)(或访问未关闭会话的 JSP 页面),由 Manager.createSession() 真正实例化 StandardSession 时同步触发。这意味着活跃会话数不等于已登录用户数——普通匿名访客只要触发了 getSession(),也会计入 HttpSessionListener 的创建统计中。

  2. 销毁事件的三种触发来源:当后台守护线程 backgroundProcess 扫描到会话空闲超时、客户端请求触发惰性超时检查,或业务代码显式调用 session.invalidate() 时,底层统一收敛至 StandardSession.expire(boolean notify) 方法触发销毁回调。

  3. 销毁回调中的属性可读性保证:在 Tomcat 的 StandardSession.expire() 源码实现中,容器遵循“先派发会话销毁通知,后清空内部属性表”的执行顺序。当 sessionDestroyed(HttpSessionEvent se) 正在执行时,attributes 哈希表中的键值对尚未被移除,开发者在该回调方法内部依然可以安全调用 se.getSession().getAttribute("...") 提取当前下线用户的身份标识以完成审计记录。

HttpSessionAttributeListener ​

javax.servlet.http.HttpSessionAttributeListener 用于全局拦截当前 Web 应用下任意 HttpSession 容器内的属性新增、移除与同名覆盖操作。

其回调传入的参数类型为 HttpSessionBindingEvent(继承自 HttpSessionEvent)。除了可通过 getSession() 获取触发事件的会话实例外,还可通过 getName() 与 getValue() 获取变更的属性名与属性值。在不同回调分支下,event.getValue() 的返回值语义存在关键差异:

  1. 新增属性回调:当调用 session.setAttribute(name, value) 且 name 在当前会话中尚不存在时触发。此时 event.getValue() 返回的是刚刚写入的新属性值。

  2. 覆盖替换回调(新旧值获取陷阱):当调用 session.setAttribute(name, newValue) 且 name 在当前会话中已有关联的旧值时触发。根据 Servlet 规范与 Tomcat 源码实现,此时调用 event.getValue() 返回的是被覆盖前的旧值(oldValue);若需要在监听器中获取覆盖后的新值(newValue),必须通过 event.getSession().getAttribute(event.getName()) 从会话容器中重新读取。

  3. 移除属性回调:当显式调用 session.removeAttribute(name)、调用 session.setAttribute(name, null),或因会话销毁(invalidate / 超时)导致容器自动清空所有属性时触发。此时 event.getValue() 返回的是刚刚被移除的旧属性值。

HttpSessionBindingListener ​

javax.servlet.http.HttpSessionBindingListener 是由业务领域对象(如 OnlineUser)自身实现的自感知接口。为什么它不需要 @WebListener 注解或 web.xml 注册就能被容器调用?答案直接体现在 Tomcat StandardSession.setAttribute() 的底层源码中:

java
package org.apache.catalina.session;

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

// 1. StandardSession 在写入属性时派发绑定事件与全局属性事件的源码逻辑
public class StandardSession {

  public void setAttribute(String name, Object value, boolean notify) {
    HttpSessionBindingEvent event = null;
    // 2. 若新存入的对象实现了 HttpSessionBindingListener,立即回调其绑定通知
    if (notify && value instanceof HttpSessionBindingListener) {
      Object oldValue = attributes.get(name);
      if (value != oldValue) {
        event = new HttpSessionBindingEvent(getSession(), name, value);
        ((HttpSessionBindingListener) value).valueBound(event);
      }
    }

    // 3. 将新值写入 ConcurrentHashMap,若存在被覆盖的旧值则回调其解绑通知
    Object unbound = attributes.put(name, value);
    if (notify && (unbound != null) && (unbound != value) &&
        (unbound instanceof HttpSessionBindingListener)) {
      ((HttpSessionBindingListener) unbound).valueUnbound(
          new HttpSessionBindingEvent(getSession(), name));
    }

    // 4. 遍历 Context 全局注册的 HttpSessionAttributeListener 派发替换或新增事件
    Object listeners[] = context.getApplicationEventListeners();
    for (int i = 0; i < listeners.length; i++) {
      if (!(listeners[i] instanceof HttpSessionAttributeListener)) {
        continue;
      }
      HttpSessionAttributeListener listener = (HttpSessionAttributeListener) listeners[i];
      if (unbound != null) {
        listener.attributeReplaced(new HttpSessionBindingEvent(getSession(), name, unbound));
      } else {
        listener.attributeAdded(new HttpSessionBindingEvent(getSession(), name, value));
      }
    }
  }
}

从上述源码可以提炼出 HttpSessionBindingListener 的三个核心执行机制:

  1. 基于 instanceof 的直接点对点回调:容器在向 attributes 哈希表写入或移除对象时,直接判断目标 value 是否为 HttpSessionBindingListener 的实例(value instanceof HttpSessionBindingListener)。若是,则直接强转该对象并调用其自身方法,无需检索 ServletContext 的全局监听器注册表。

  2. 先绑定后入表、先出表后解绑的时序:在写入新对象时,容器先调用新对象的 valueBound 方法,再执行 attributes.put(name, value);若该键原先已绑定了另一个实现了该接口的旧对象(unbound != null && unbound != value),容器会在 put 完成覆盖后立即调用旧对象的 valueUnbound 方法。

  3. 精准区分“访客会话”与“登录用户”:相比于 HttpSessionListener 只要创建空会话就会触发,HttpSessionBindingListener 只有在业务层完成身份认证并执行 session.setAttribute("loginUser", new OnlineUser("admin")) 时才会触发绑定;而在用户主动调用 removeAttribute("loginUser")、invalidate() 或会话超时销毁自动解绑全部属性时,均会可靠触发解绑。因此它是维护“已认证在线用户名单”最精准的技术方案。

示例: 在线人数统计与登录态绑定 ​

下面通过三个组件协同演示会话监听体系的实战应用:OnlineCountListener 负责统计全站活跃会话总数,SessionAuditAttributeListener 负责审计属性替换时的新旧值变化,OnlineUser 实体类通过实现 HttpSessionBindingListener 自动维护已登录用户名单。

OnlineCountListener ​

java
package com.example.session;

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

// 1. 注册全局会话生命周期监听器,统计当前应用活跃会话总数
@WebListener
public class OnlineCountListener implements HttpSessionListener {

  private final AtomicInteger sessionCount = new AtomicInteger(0);

  // 2. 当服务端新建 StandardSession 时触发,原子递增在线会话计数并同步至全局域
  @Override
  public void sessionCreated(HttpSessionEvent se) {
    ServletContext context = se.getSession().getServletContext();
    int current = sessionCount.incrementAndGet();
    context.setAttribute("totalSessions", current);
  }

  // 3. 当会话超时或调用 invalidate 销毁时触发,原子递减在线会话计数
  @Override
  public void sessionDestroyed(HttpSessionEvent se) {
    ServletContext context = se.getSession().getServletContext();
    int current = sessionCount.decrementAndGet();

    // 4. 销毁回调执行时尚未解绑属性,仍可安全读取当前会话中的用户信息
    Object user = se.getSession().getAttribute("loginUser");
    context.setAttribute("totalSessions", Math.max(current, 0));
  }
}

SessionAuditAttributeListener ​

java
package com.example.session;

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;

// 1. 监听全站所有 HttpSession 属性的新增、覆盖替换与移除操作
@WebListener
public class SessionAuditAttributeListener implements HttpSessionAttributeListener {

  // 2. 首次向会话写入新属性键时触发,event.getValue() 返回新写入的属性值
  @Override
  public void attributeAdded(HttpSessionBindingEvent event) {
    String name = event.getName();
    Object newValue = event.getValue();
    System.out.println("新增会话属性: " + name + " = " + newValue);
  }

  // 3. 覆盖已有属性键时触发,event.getValue() 返回被替换的旧值,需从 Session 重新读取新值
  @Override
  public void attributeReplaced(HttpSessionBindingEvent event) {
    String name = event.getName();
    Object oldValue = event.getValue();
    Object newValue = event.getSession().getAttribute(name);
    System.out.println("替换会话属性: " + name + ", 旧值=" + oldValue + ", 新值=" + newValue);
  }

  // 4. 调用 removeAttribute 或会话销毁解绑属性时触发,event.getValue() 返回被移除的值
  @Override
  public void attributeRemoved(HttpSessionBindingEvent event) {
    System.out.println("移除会话属性: " + event.getName() + ", 旧值=" + event.getValue());
  }
}

OnlineUser ​

java
package com.example.session;

import javax.servlet.ServletContext;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;
import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

// 1. 实体类直接实现 HttpSessionBindingListener,无需 @WebListener 注册即可感知会话绑定
public class OnlineUser implements HttpSessionBindingListener, Serializable {

  private final String username;

  public OnlineUser(String username) {
    this.username = username;
  }

  // 2. 当通过 setAttribute 将当前实体存入 Session 时自动触发,登记已登录用户名单
  @Override
  @SuppressWarnings("unchecked")
  public void valueBound(HttpSessionBindingEvent event) {
    ServletContext context = event.getSession().getServletContext();
    Set<String> activeUsers = (Set<String>) context.getAttribute("activeUsers");
    if (activeUsers == null) {
      activeUsers = ConcurrentHashMap.newKeySet();
      context.setAttribute("activeUsers", activeUsers);
    }
    activeUsers.add(this.username);
  }

  // 3. 当属性被移除、覆盖或所属 Session 销毁时自动触发,从已登录名单中移除该用户
  @Override
  @SuppressWarnings("unchecked")
  public void valueUnbound(HttpSessionBindingEvent event) {
    ServletContext context = event.getSession().getServletContext();
    Set<String> activeUsers = (Set<String>) context.getAttribute("activeUsers");
    if (activeUsers != null) {
      activeUsers.remove(this.username);
    }
  }

  public String getUsername() {
    return username;
  }
}

Session 钝化活化 ​

钝化与活化 ​

在默认情况下,HttpSession 实例驻留在服务端 JVM 堆内存中。但在容器重启维护、高并发内存水位控制以及分布式集群跨节点会话同步场景下,单靠纯内存存储会导致会话状态丢失或引发 OutOfMemoryError。为此,Servlet 规范与 Web 容器提供了基于 Java 对象序列化的跨介质迁移技术:

  1. 钝化(Passivation):当满足特定触发条件(如 Tomcat 正常停机或会话长时间空闲)时,会话管理器(Manager)将当前内存中活跃的 StandardSession 实例及其内部 attributes 属性表,通过 ObjectOutputStream 序列化为二进制字节流,转储至本地磁盘文件或外部数据库的过程。

  2. 活化(Activation):当 Tomcat 重新启动加载,或客户端再次携带已换出会话的 JSESSIONID 发起请求时,会话管理器通过 ObjectInputStream 从磁盘文件或数据库中读取字节流,将其反序列化恢复为堆内存中的 StandardSession 实例,并重新注册至 Manager 并发哈希表的过程。

image-20261116141214370

在一次完整的钝化与活化闭环中,容器内部按以下四个核心步骤流转,并对业务属性施加严格的序列化约束:

  1. 派发前置钝化通知:在将 StandardSession 写入输出流之前,容器首先调用 session.passivate(),遍历当前会话中的所有属性;若某个属性对象实现了 HttpSessionActivationListener 接口,则同步回调其钝化前通知方法,允许业务对象提前关闭或解绑非序列化资源。

  2. 筛选可序列化属性并写出(writeObjectData):容器依次将 creationTime、lastAccessedTime、maxInactiveInterval、isNew、isValid、thisAccessedTime、id 等基础元数据写入 ObjectOutputStream。随后遍历 attributes 并发哈希表:

    • **强制要求实现 java.io.Serializable**:容器通过 value instanceof Serializable检查每个业务属性对象(及其内部引用的所有非transient成员变量)。只有实现了Serializable 接口的对象才会被写入序列化字节流。
    • 未实现 Serializable 的丢弃行为:如果某个属性对象未实现 Serializable 接口,Tomcat 不会中断整个 Session 的钝化过程,而是直接在钝化前调用 removeAttributeInternal(name, true) 将该属性从会话中强制移除(同时触发解绑通知)并打印警告日志。这意味着未实现 Serializable 的属性在经历钝化与活化后会永久丢失。
  3. 字节流反序列化恢复(readObjectData):活化阶段,容器实例化一个空的 StandardSession 对象,按照与写出完全对称的顺序从 ObjectInputStream 中读取时间戳、会话 ID 及属性键值对,重新填充回 attributes 哈希表中,并重新初始化被 transient 关键字修饰的 accessCount、manager 等容器级运行期字段。

  4. 派发后置活化通知:反序列化读取完毕后,容器立即调用 session.activate(),再次遍历恢复后的 attributes 表并回调 HttpSessionActivationListener 的活化通知方法,使业务对象有机会重建 transient 属性。

StandardManager ​

org.apache.catalina.session.StandardManager 是 Tomcat 默认启用的会话管理器实现。它仅在 Web 容器正常停机(或应用重载)与再次启动两个生命周期节点执行全量钝化与活化,在应用正常运行期间不会将会话换出到磁盘:

  1. 停机全量钝化(stopInternal →\rightarrow unload):当执行 shutdown.sh(或发送 SIGTERM 信号)正常关闭 Tomcat,或触发应用热重载(Reload)时,StandardManager 会锁定当前会话池,将所有尚未超时的活跃 StandardSession 统一序列化写入当前应用工作目录下的单一文件:

    $CATALINA_BASE/work/Catalina/<Engine>/<Host>/<Context>/SESSIONS.ser

  2. 启动全量活化(startInternal →\rightarrow load):当 Tomcat 再次启动时,StandardManager 检测工作目录下是否存在 SESSIONS.ser 文件。若存在,则反序列化读取其中保存的所有会话并恢复至内存哈希表中(借此实现服务器重启不丢失用户登录态),随后立即将磁盘上的 SESSIONS.ser 文件删除。

  3. 非正常停机与禁用策略:如果通过 kill -9 强制杀死 JVM 进程或遭遇机器断电,容器停机生命周期钩子无法执行,内存中的会话将无法写入 SESSIONS.ser。此外,若生产环境不希望重启时保留历史会话,可在 context.xml 的 <Manager> 标签中配置 pathname=""(空字符串)显式关闭停机钝化功能。

PersistentManager ​

当单机在线人数极高、每个会话挂载了较大体积的业务对象时,StandardManager 将所有未超时会话常驻堆内存的策略极易耗尽老年代内存。为此,Tomcat 提供了支持运行期动态空闲换出(Swap Out)的 org.apache.catalina.session.PersistentManager。

StandardManager 与 PersistentManager 的架构特性对比如下:

对比维度StandardManager(默认)PersistentManager
钝化触发时机仅在 Tomcat 正常停机或 Context 重载时触发除停机外,支持在运行期由后台守护线程按空闲时长与数量阈值动态触发
运行期内存占用所有未超时会话 100% 常驻 JVM 堆内存仅高频活跃会话驻留堆内存,长时间空闲会话被换出至磁盘/数据库并从内存移除
活化触发时机仅在 Tomcat 启动阶段一次性全量加载客户端再次携带已换出会话的 JSESSIONID 请求时,按需懒加载(Lazy Swap In)回内存
存储介质与粒度所有会话合并写入单个 SESSIONS.ser 文件依赖可插拔的 Store 组件(如 FileStore 按单会话生成 <id>.session,或 JDBCStore 存入数据库表)

PersistentManager 通过后台线程定期扫描,依据以下三个核心阈值参数控制会话在内存与外部存储(Store)之间的流转:

  1. maxIdleSwap(最大空闲换出时间,单位:秒):当某个会话的空闲时间超过该值(但尚未达到 maxInactiveInterval 销毁阈值)时,管理器将其钝化写入 Store,并立即将其从 JVM 堆内存的 sessions 哈希表中移除以释放内存。当该用户稍后再次发起请求时,PersistentManager.findSession(id) 在内存中未命中,会自动调用 store.load(id) 将其活化恢复回内存。

  2. maxActiveSessions 与 minIdleSwap(容量上限驱逐):maxActiveSessions 限制内存中同时驻留的最大活跃会话数。一旦内存中会话总数突破该上限,后台线程会挑选空闲时间已达到 minIdleSwap 秒的会话提前换出至磁盘,直至内存会话数回落至安全水位。

  3. maxIdleBackup(最大空闲备份时间,单位:秒):当会话空闲时间达到该阈值时,管理器将其序列化写入 Store 进行增量持久化备份,但不将其从 JVM 堆内存中移除,仅用于防范服务器意外宕机导致数据丢失。

HttpSessionActivationListener ​

javax.servlet.http.HttpSessionActivationListener 是由存入会话域的业务 JavaBean 实体类直接实现的自感知接口(无需标注 @WebListener 或配置 web.xml)。

在工程中,当一个业务实体类已经实现了 Serializable 接口后,为什么往往还需要配合实现 HttpSessionActivationListener?核心原因在于 transient 成员变量的反序列化重建问题:

  1. 非序列化资源的隔离:业务实体内部可能持有了数据库连接、网络连接句柄、日志记录器(Logger)或本地缓存引用等不支持序列化的组件,必须使用 transient 关键字修饰以避免抛出 NotSerializableException。

  2. 反序列化不调用构造方法:当会话从磁盘活化反序列化回内存时,JVM 底层直接通过字节流分配内存并填充字段,不会调用实体类的构造方法。这会导致实体内所有被 transient 修饰的字段在活化后全部变为默认值 null。

  3. 生命周期钩子补偿:通过实现 HttpSessionActivationListener,实体类可以在 sessionWillPassivate 回调中优雅断开或清理外部资源,并在 sessionDidActivate 回调中重新初始化为 null 的 transient 字段,从而保证活化后的对象功能完整。

Tomcat StandardSession 底层执行钝化通知、活化通知以及序列化写出的核心源码如下:

java
package org.apache.catalina.session;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;

// 1. StandardSession 中负责触发钝化活化通知与序列化写出的核心源码
public class StandardSession implements Serializable {

  // 2. 钝化前遍历所有会话属性,若实现了 HttpSessionActivationListener 则触发前置回调
  public void passivate() {
    fireSessionEvent(Session.SESSION_PASSIVATED_EVENT, null);
    HttpSessionEvent event = null;
    String keys[] = keys();
    for (int i = 0; i < keys.length; i++) {
      Object attribute = attributes.get(keys[i]);
      if (attribute instanceof HttpSessionActivationListener) {
        if (event == null) {
          event = new HttpSessionEvent(getSession());
        }
        ((HttpSessionActivationListener) attribute).sessionWillPassivate(event);
      }
    }
  }

  // 3. 活化反序列化完成后遍历恢复的属性,触发后置回调以重建 transient 资源
  public void activate() {
    if (activityCheck) {
      accessCount = new AtomicInteger();
    }
    HttpSessionEvent event = null;
    String keys[] = keys();
    for (int i = 0; i < keys.length; i++) {
      Object attribute = attributes.get(keys[i]);
      if (attribute instanceof HttpSessionActivationListener) {
        if (event == null) {
          event = new HttpSessionEvent(getSession());
        }
        ((HttpSessionActivationListener) attribute).sessionDidActivate(event);
      }
    }
  }

  // 4. 将会话元数据及实现了 Serializable 接口的属性键值对写入对象输出流
  public void writeObjectData(ObjectOutputStream stream) throws IOException {
    stream.writeObject(Long.valueOf(creationTime));
    stream.writeObject(Long.valueOf(lastAccessedTime));
    stream.writeObject(Integer.valueOf(maxInactiveInterval));
    stream.writeObject(id);

    String keys[] = keys();
    for (int i = 0; i < keys.length; i++) {
      Object value = attributes.get(keys[i]);
      if (value instanceof Serializable) {
        stream.writeObject(keys[i]);
        stream.writeObject(value);
      }
    }
  }
}

示例: 会话钝化配置与活化资源重建 ​

下面通过三个文件完整演示运行期动态钝化与活化的配置与代码实现:在 META-INF/context.xml 中配置 PersistentManager 与 FileStore,编写同时实现 Serializable 与 HttpSessionActivationListener 的 UserSessionProfile 实体类,并通过 PassivationTestServlet 验证跨钝化周期的状态恢复。

META-INF/context.xml ​

xml
<Context>
    <!-- 1. 使用 PersistentManager 替代默认的 StandardManager 开启运行期动态换出 -->
    <Manager className="org.apache.catalina.session.PersistentManager"
             saveOnRestart="true"
             maxActiveSessions="500"
             minIdleSwap="30"
             maxIdleSwap="60"
             maxIdleBackup="20">

        <!-- 2. 配置 FileStore 将钝化的会话独立保存为 <JSESSIONID>.session 文件 -->
        <Store className="org.apache.catalina.session.FileStore"
               directory="session_swap" />
    </Manager>
</Context>

UserSessionProfile ​

java
package com.example.session;

import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;
import java.io.Serializable;
import java.util.logging.Logger;

// 1. 存入 Session 的实体类需同时实现 Serializable 与 HttpSessionActivationListener
public class UserSessionProfile implements Serializable, HttpSessionActivationListener {

  private static final long serialVersionUID = 1L;

  private final String username;

  // 2. 使用 transient 标记不支持序列化的运行期组件,钝化时自动忽略该字段
  private transient Logger auditLogger;

  public UserSessionProfile(String username) {
    this.username = username;
    this.auditLogger = Logger.getLogger(UserSessionProfile.class.getName());
  }

  // 3. 会话即将钝化写入磁盘前自动回调,释放或置空非序列化资源引用
  @Override
  public void sessionWillPassivate(HttpSessionEvent se) {
    System.out.println("Session [" + se.getSession().getId() + "] 即将钝化,用户: " + username);
    this.auditLogger = null;
  }

  // 4. 会话从磁盘反序列化活化回内存后自动回调,重新初始化 transient 字段
  @Override
  public void sessionDidActivate(HttpSessionEvent se) {
    this.auditLogger = Logger.getLogger(UserSessionProfile.class.getName());
    this.auditLogger.info("Session [" + se.getSession().getId() + "] 已完成活化恢复,用户: " + username);
  }

  public String getUsername() {
    return username;
  }
}

PassivationTestServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;

// 1. 验证会话属性在经历磁盘钝化与活化恢复后的状态完整性
@WebServlet("/session/passivation")
public class PassivationTestServlet extends HttpServlet {

  @Override
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    resp.setContentType("text/plain;charset=UTF-8");
    HttpSession session = req.getSession();

    // 2. 尝试从当前会话中获取已绑定的实体,若已发生钝化则容器在此前已完成自动活化
    UserSessionProfile profile = (UserSessionProfile) session.getAttribute("profile");

    // 3. 若首次访问尚未绑定,则实例化可序列化实体并存入 Session 域
    if (profile == null) {
      profile = new UserSessionProfile("architect_user");
      session.setAttribute("profile", profile);
      resp.getWriter().write("首次绑定 UserSessionProfile,SessionID: " + session.getId());
    } else {
      resp.getWriter().write("成功读取活化后的 UserSessionProfile: " + profile.getUsername());
    }
  }
}

HttpSession 并发安全问题 ​

作用域线程安全边界 ​

在 Java Web 应用开发中,组件与域对象的线程安全特性取决于其生命周期作用域与请求线程的对应关系。理解 HttpSession 为什么存在并发安全问题,首先需要对比 Servlet 三大核心域对象的线程访问模型:

域对象接口作用域范围实例与请求线程对应关系线程安全级别
HttpServletRequest单次请求域(Request Scope)每个请求由独立的容器工作线程处理(除异步 Servlet 外),属于线程栈封闭或单线程独占线程安全(单线程隔离)
HttpSession单客户端会话域(Session Scope)同一浏览器的多个并发请求共享同一个 JSESSIONID,由多个工作线程并发访问同一个会话实例非完全线程安全(存在复合操作与可变对象竞态)
ServletContext全局应用域(Application Scope)全站所有客户端的所有请求线程共享全局唯一的上下文实例非线程安全(高并发全局共享)

许多开发者误以为“一个 HttpSession 只对应一个用户,而一个用户同一时刻只会发起一次请求”,从而将 HttpSession 视为天然线程安全的容器。事实上,在现代 Web 应用中,**同一客户端在同一毫秒内触发多线程并发访问同一个 HttpSession** 是极为普遍的场景:

  1. 前端并发异步请求(AJAX / Fetch 并行加载):单页应用(SPA)或复杂仪表盘页面在初始化渲染时,往往会同时并发发起 5 至 10 个携带相同 Cookie: JSESSIONID=... 的异步请求(如同时请求用户资料、权限菜单、未读消息与购物车列表)。Tomcat 线程池会分配多个 http-nio-8080-exec-* 工作线程同时寻址并操作同一个 StandardSession 实例。

  2. 浏览器多标签页与多窗口共享:同一浏览器进程下的所有标签页(Tabs)和窗口默认共享内存中的 JSESSIONID。当用户同时打开多个标签页操作业务功能时,后台接收到的均是指向同一 HttpSession 的并发请求。

  3. 表单高频连击与网络超时重试:用户在弱网环境下快速重复点击“提交订单”或“扣减积分”按钮,或者前端 HTTP 客户端触发自动重试时,会在服务端产生针对同一会话的并发写竞争。

复合读写与可变对象竞态问题 ​

在前面第 3 章剖析 StandardSession 源码时可以看到,Tomcat 内部使用 ConcurrentHashMap<String, Object> 来存储会话属性(attributes)。然而,底层容器使用 ConcurrentHashMap 仅能保证单次 getAttribute、setAttribute 或 removeAttribute 方法调用自身的哈希桶读写不会损坏内部链表或红黑树结构,绝不意味着业务层对 HttpSession 的操作是线程安全的。

image-20261116141241435

在并发场景下,HttpSession 的线程安全隐患主要集中体现在以下三个层面:

检查后执行(Check-Then-Act)竞态 ​

当业务代码需要在会话中延迟初始化某个属性(如首次添加商品时创建购物车集合)时,通常会编写“先调用 getAttribute 判空,若为 null 则实例化并调用 setAttribute”的复合逻辑。

由于 getAttribute 与 setAttribute 是两次独立的原子操作,二者之间不存在事务或锁保护:

  1. 线程 A 与线程 B 同时携带相同的 JSESSIONID 到达服务端,并发执行 session.getAttribute("cart"),此时两者均读取到 null。

  2. 线程 A 实例化集合 List_A,将商品 Item_1 放入 List_A,并执行 session.setAttribute("cart", List_A)。

  3. 紧接着线程 B 实例化另一个集合 List_B,将商品 Item_2 放入 List_B,并执行 session.setAttribute("cart", List_B)。

  4. 线程 B 的写入直接覆盖了线程 A 刚刚绑定的 List_A,导致商品 Item_1 被静默丢失(Lost Update)。

读取-修改-写回(Read-Modify-Write)状态覆盖 ​

当会话中存储的是基本数据类型包装类(如计数器 Integer、账户余额 BigDecimal)或不可变对象时,每次更新都需要经历“读取旧值 →\rightarrow 计算新值 →\rightarrow 写回新值”三个步骤。若两个请求线程同时读取到计数器旧值为 10,各自在线程栈内加 1 后先后调用 setAttribute("count", 11),最终两次有效请求仅使计数器增加了 1,产生典型的并发丢失更新问题。

会话内可变业务对象(Mutable Object)的非线程安全操作 ​

这是生产环境中最容易引发线上故障的隐患。ConcurrentHashMap 只能保护“属性名到对象引用”这一层映射关系,无法保护存入会话域的业务对象内部状态。

例如,开发者将一个普通的 ArrayList 或 HashMap 实例存入 HttpSession 后,后续两个并发请求线程通过 session.getAttribute("cart") 拿到了同一个 ArrayList 对象的内存引用,并同时调用 cart.add(item):

  1. 由于 ArrayList 自身没有任何同步保护,多线程并发扩容(grow)与移动数组游标(elementData[size++] = e)会直接引发数组越界异常 ArrayIndexOutOfBoundsException 或内部元素被 null 覆盖。

  2. 若在另一个线程遍历该集合输出页面时发生并发修改,则会立即抛出 ConcurrentModificationException。

同步锁与显式写回策略 ​

为了彻底消除同会话并发访问引发的数据错乱与状态丢失,在工程实践中应当根据业务场景组合采用以下三种防护策略:

基于会话粒度的互斥同步锁 ​

对于包含“检查后执行”或“读取-修改-写回”的复合会话操作,必须使用 synchronized 关键字将整个复合操作包裹在同一个临界区内,且锁的粒度应当控制在当前单个会话级别(严禁锁住全局 ServletContext 或 Servlet 实例 this,否则会导致全站所有不同用户的请求串行阻塞):

  1. 单机 Tomcat 容器锁(synchronized (session)):在 Tomcat 的 StandardSession.getSession() 源码中,每个 StandardSession 实例内部通过 this.facade 字段缓存了唯一的一个 StandardSessionFacade 外观对象。因此,同一会话的多个并发请求线程调用 req.getSession() 获取到的是完全相同的对象引用,直接使用 synchronized (session) 即可安全锁定当前用户的并发请求。

  2. 跨容器兼容锁或专用互斥体(Session Mutex):由于 Servlet 规范并未强制要求所有厂商的容器都复用同一个 HttpSession 包装类引用(部分分布式会话包装器每次调用 getSession() 会生成新的代理对象),在需要严格保证跨容器兼容性的框架(如 Spring MVC 的 SessionMutexListener)中,通常在会话创建时向其内部存入一个私有的空对象 new Object() 作为专用锁句柄(Key 为 SESSION_MUTEX_ATTRIBUTE),业务层统一对该互斥体对象加锁。

优先存储不可变对象或并发安全容器 ​

在设计存入 HttpSession 的领域模型时,应尽可能从数据结构层面消除可变共享状态:

  1. 不可变值对象(Immutable Object):对于用户身份信息(如 UserPrincipal),将其所有字段声明为 private final,不提供任何 setter 修改方法。一旦构建存入会话后,多线程并发读取天然具备线程安全性。

  2. JUC 并发容器替代普通集合:若会话域中确实需要维护高频读写的集合或计数器,应直接使用 java.util.concurrent 包下的线程安全类(如使用 CopyOnWriteArrayList 替代 ArrayList,使用 ConcurrentHashMap 替代 HashMap,使用 AtomicInteger 替代 Integer)。

分布式会话与钝化场景下的显式写回 ​

在单机纯内存模式下,由于 session.getAttribute("cart") 返回的是堆内存中的同一个对象引用,直接调用 cart.add(item) 修改对象内部属性后,即便不重新调用 session.setAttribute("cart", cart),内存中的数据也已经生效。

但在生产环境的Tomcat 集群会话复制(DeltaManager / BackupManager)或基于 Redis 的分布式会话(如 Spring Session)架构下,这会导致严重的脏数据同步丢失问题:

  1. 脏状态感知的触发边界:分布式会话管理器通常只在拦截到业务代码显式调用 session.setAttribute(name, value) 或 removeAttribute(name) 时,才会将该属性标记为“脏数据(Dirty)”,并在当前请求结束时将其序列化同步至 Redis 或集群其他节点。

  2. 原地修改逃逸监听:如果业务代码仅执行 List<String> cart = (List<String>) session.getAttribute("cart"); cart.add(item); 而不调用 setAttribute,分布式会话框架根本无法感知 cart 对象内部集合元素发生了变化,从而不会向 Redis 发起写回操作。当用户的下一次请求被负载均衡器路由到另一台节点时,读取到的仍是修改前的旧状态。

  3. 强制工程规范:**凡是修改了从 HttpSession 中取出的可变对象内部状态,修改完成后必须显式补调一次 session.setAttribute(name, modifiedObject)**,以此确保单机监听器(HttpSessionAttributeListener)与分布式外部存储均能可靠感知状态变更。

示例: 会话复合读写同步控制 ​

下面通过 SafeCartServlet 演示在并发环境下安全执行购物车会话“读取-延迟初始化-修改-显式写回”的标准范式。

SafeCartServlet ​

java
package com.example.session;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

// 1. 处理同一客户端并发添加购物车请求,防范复合读写竞态与状态丢失
@WebServlet("/cart/add")
public class SafeCartServlet extends HttpServlet {

  @Override
  @SuppressWarnings("unchecked")
  protected void doPost(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {
    req.setCharacterEncoding("UTF-8");
    resp.setContentType("text/plain;charset=UTF-8");
    String item = req.getParameter("item");
    HttpSession session = req.getSession();

    // 2. 以当前 HttpSession 实例作为同步监视器锁,串行化同一会话的并发请求
    synchronized (session) {
      // 3. 在同步块内执行“读取-判空初始化-修改”复合操作,消除检查后执行竞态
      List<String> cart = (List<String>) session.getAttribute("cart");
      if (cart == null) {
        cart = new ArrayList<>();
      }
      cart.add(item);

      // 4. 修改可变集合后显式重新调用 setAttribute,触发分布式会话脏数据写回与监听通知
      session.setAttribute("cart", cart);
      resp.getWriter().write("当前购物车商品数量: " + cart.size());
    }
  }
}