Servlet会话管理技巧详解从原理到实践解决Web应用状态保持难题

什么是Servlet会话管理及其重要性
在Web开发中，HTTP协议本身是无状态的，这意味着服务器无法区分两个连续的HTTP请求是否来自同一个用户。Servlet会话管理就是解决这一核心问题的关键技术。会话管理允许Web应用在多个请求之间”记住”用户的状态信息，例如用户登录状态、购物车内容、用户偏好设置等。
想象一个典型的电商网站场景：当用户浏览商品、将商品添加到购物车、最终完成购买，这整个过程涉及多个页面和请求。如果没有会话管理，服务器每次都会将用户视为全新的访问者，购物车会不断清空，用户需要反复登录，这显然无法提供良好的用户体验。
Servlet会话管理通过在服务器端存储用户特定的数据，为每个用户创建一个唯一的标识（会话ID），从而实现状态保持。这个会话ID通常通过Cookie或URL重写的方式在客户端和服务器之间传递，使得服务器能够识别后续请求属于哪个会话。
会话管理的核心原理
HTTP协议的无状态特性
HTTP协议设计为无状态协议，每个请求都是独立的，服务器不会自动记住之前的请求。这种设计有其优势（如简化服务器设计、提高可扩展性），但对于需要状态保持的应用来说是个挑战。
会话跟踪机制
Servlet容器（如Tomcat）提供了会话跟踪机制，主要通过以下方式实现：
会话ID生成
：当用户首次访问应用时，容器生成唯一的会话ID
会话数据存储
：在服务器端存储与会话ID关联的数据
会话ID传递
：通过Cookie或URL重写将会话ID传递给客户端
会话识别
：客户端后续请求携带会话ID，服务器据此识别会话
会话生命周期
会话有明确的生命周期：
创建
：首次调用
request.getSession()
或
request.getSession(true)
时创建
使用
：在多个请求中通过
HttpSession
对象存取数据
销毁
：会话超时、显式调用
invalidate()
或服务器重启时销毁
HttpSession API详解
获取和创建会话
// 获取会话，如果不存在则创建新的
HttpSession session = request.getSession(true);

// 获取会话，如果不存在则返回null
HttpSession session = request.getSession(false);

// 获取会话，如果不存在则创建（这是最常用的方式）
HttpSession session = request.getSession();
会话属性操作
// 设置属性
session.setAttribute(“username”, “john_doe”);
session.setAttribute(“cart”, shoppingCart);
session.setAttribute(“loginTime”, new Date());

// 获取属性
String username = (String) session.getAttribute(“username”);
ShoppingCart cart = (ShoppingCart) session.getAttribute(“cart”);

// 移除属性
session.removeAttribute(“cart”);

// 获取所有属性名
Enumeration attributeNames = session.getAttributeNames();
会话配置和管理
// 获取会话ID
String sessionId = session.getId();

// 获取会话创建时间
Date creationTime = new Date(session.getCreationTime());

// 获取会话最后访问时间
Date lastAccessedTime = new Date(session.getLastAccessedTime());

// 设置会话最大空闲时间（秒）
session.setMaxInactiveInterval(1800); // 30分钟

// 获取会话最大空闲时间
int maxInterval = session.getMaxInactiveInterval();

// 使会话失效
session.invalidate();

// 检查会话是否为新创建
boolean isNew = session.isNew();
会话配置选项
web.xml配置
在
web.xml
中可以配置会话参数：


30

JSESSIONID

example.com
/
true

true

URL

注解配置（Servlet 3.0+）
@WebServlet(urlPatterns = “/session/*”)
@ServletSecurity(
httpMethodConf = @HttpMethodConf(
method = “GET”,
rolesAllowed = {“USER”}
)
)
public class SessionServlet extends HttpServlet {
// Servlet实现
}
会话管理实践技巧
1. 会话数据的最佳实践
避免存储大量数据
：
// 不好的做法：存储整个商品目录
session.setAttribute(“productCatalog”, hugeProductList);

// 好的做法：只存储用户相关数据
session.setAttribute(“userPreferences”, userPrefs);
使用DTO/VO对象
：
// 创建专门的会话数据对象
public class UserSessionData implements Serializable {
private String userId;
private String username;
private String role;
private List permissions;
private Date loginTime;
private String ipAddress;

// 构造函数、getter/setter
}

// 在会话中使用
UserSessionData sessionData = new UserSessionData();
sessionData.setUserId(“U001”);
sessionData.setUsername(“admin”);
session.setAttribute(“userData”, sessionData);
2. 会话超时处理
// 在web.xml中设置默认超时

30

// 在代码中动态设置
session.setMaxInactiveInterval(1800); // 30分钟

// 检测会话是否过期
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {

HttpSession session = request.getSession(false);
if (session == null) {
// 会话不存在或已过期
response.sendRedirect(“login.jsp”);
return;
}

// 检查会话是否有效
try {
String username = (String) session.getAttribute(“username”);
if (username == null) {
response.sendRedirect(“login.jsp”);
return;
}
} catch (IllegalStateException e) {
// 会话已失效
response.sendRedirect(“login.jsp”);
return;
}

// 正常处理请求
request.getRequestDispatcher(“/dashboard.jsp”).forward(request, response);
}
3. 会话监听器
会话监听器可以监听会话的创建、销毁和属性变化：
// 会话创建/销毁监听器
@WebListener
public class SessionLifecycleListener implements HttpSessionListener {

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

@Override
public void sessionCreated(HttpSessionEvent se) {
HttpSession session = se.getSession();
System.out.println(“会话创建: ” + session.getId() +
“, 创建时间: ” + new Date(session.getCreationTime()));
activeSessions.incrementAndGet();
}

@Override
public void sessionDestroyed(HttpSessionEvent se) {
HttpSession session = se.getSession();
System.out.println(“会话销毁: ” + session.getId() +
“, 销毁时间: ” + new Date());
activeSessions.decrementAndGet();
}

public static int getActiveSessionCount() {
return activeSessions.get();
}
}

// 会话属性监听器
@WebListener
public class SessionAttributeListener implements HttpSessionAttributeListener {

@Override
public void attributeAdded(HttpSessionBindingEvent event) {
String name = event.getName();
Object value = event.getValue();
System.out.println(“会话属性添加: ” + name + ” = ” + value);
}

@Override
public void attributeRemoved(HttpSessionBindingEvent event) {
String name = event.getName();
Object value = event.getValue();
System.out.println(“会话属性移除: ” + name + ” = ” + value);
}

@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);
}
}

// 实现HttpSessionBindingValue接口的对象可以感知绑定/解绑
public class UserSessionData implements Serializable, HttpSessionBindingListener {

private String userId;
private String username;

// 构造函数、getter/setter

@Override
public void valueBound(HttpSessionBindingEvent event) {
System.out.println(“UserSessionData绑定到会话: ” + event.getSession().getId());
// 可以在这里执行初始化逻辑
}

@Override
public void valueUnbound(HttpSessionBindingEvent event) {
System.out.println(“UserSessionData从会话解绑: ” + event.getSession().getId());
// 可以在这里执行清理逻辑
}
}
4. 会话安全最佳实践
// 1. 会话固定攻击防护
public class LoginServlet extends HttpServlet {

protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

String username = request.getParameter(“username”);
String password = request.getParameter(“password”);

// 验证用户凭据
if (authenticate(username, password)) {
// 登录成功后创建新会话
HttpSession oldSession = request.getSession(false);
if (oldSession != null) {
oldSession.invalidate(); // 使旧会话失效
}

// 创建新会话
HttpSession newSession = request.getSession(true);
newSession.setAttribute(“username”, username);
newSession.setAttribute(“loginTime”, new Date());

// 设置会话超时时间
newSession.setMaxInactiveInterval(1800); // 30分钟

// 重定向到安全页面
response.sendRedirect(“dashboard.jsp”);
} else {
// 登录失败
request.setAttribute(“error”, “用户名或密码错误”);
request.getRequestDispatcher(“/login.jsp”).forward(request, response);
}
}

private boolean authenticate(String username, String password) {
// 实际的认证逻辑
return “admin”.equals(username) && “password123”.equals(password);
}
}

// 2. 会话劫持防护
public class SecurityFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;

HttpSession session = httpRequest.getSession(false);
if (session != null) {
// 检查用户代理是否改变
String currentUserAgent = httpRequest.getHeader(“User-Agent”);
String sessionUserAgent = (String) session.getAttribute(“userAgent”);

if (sessionUserAgent != null && !sessionUserAgent.equals(currentUserAgent)) {
// 用户代理改变，可能为会话劫持
session.invalidate();
httpResponse.sendRedirect(“login.jsp”);
return;
}

// 检查IP地址是否改变（可选，因为移动网络IP可能变化）
String currentIP = httpRequest.getRemoteAddr();
String sessionIP = (String) session.getAttribute(“ipAddress”);

if (sessionIP != null && !sessionIP.equals(currentIP)) {
// IP改变，可能为会话劫持
session.invalidate();
httpResponse.sendRedirect(“login.jsp”);
return;
}
}

chain.doFilter(request, response);
}

@Override
public void init(FilterConfig filterConfig) throws ServletException {}

@Override
public void destroy() {}
}

// 3. 会话超时自动跳转
public class SessionTimeoutFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;

HttpSession session = httpRequest.getSession(false);

// 检查会话是否存在且有效
if (session == null) {
// 会话不存在
String requestURI = httpRequest.getRequestURI();

// 排除登录页面和静态资源
if (!requestURI.endsWith(“login.jsp”) &&
!requestURI.contains(“/css/”) &&
!requestURI.contains(“/js/”)) {

// 重定向到登录页面，并添加原始URL参数
String redirectURL = “login.jsp?redirect=” +
URLEncoder.encode(requestURI, “UTF-8”);
httpResponse.sendRedirect(redirectURL);
return;
}
} else {
// 会话存在，检查是否过期
long lastAccessedTime = session.getLastAccessedTime();
long currentTime = System.currentTimeMillis();
long inactiveTime = (currentTime – lastAccessedTime) / 1000; // 秒

int maxInactiveInterval = session.getMaxInactiveInterval();

if (inactiveTime > maxInactiveInterval) {
// 会话已过期
session.invalidate();
String requestURI = httpRequest.getRequestURI();

if (!requestURI.endsWith(“login.jsp”)) {
String redirectURL = “login.jsp?redirect=” +
URLEncoder.encode(requestURI, “UTF-8”);
httpResponse.sendRedirect(redirectURL);
return;
}
}
}

chain.doFilter(request, response);
}

@Override
public void init(FilterConfig filterConfig) throws ServletException {}

@Override
public void destroy() {}
}
分布式环境下的会话管理
1. 会话复制（Session Replication）
在集群环境中，需要确保会话在多个节点间同步：
// 在Tomcat中配置会话复制（context.xml）

2. 基于数据库的会话存储
// 数据库会话存储实现
public class DatabaseSessionManager {

private DataSource dataSource;

public DatabaseSessionManager(DataSource dataSource) {
this.dataSource = dataSource;
}

// 保存会话
public void saveSession(HttpSession session) throws SQLException {
String sessionId = session.getId();
long creationTime = session.getCreationTime();
long lastAccessedTime = session.getLastAccessedTime();
int maxInactiveInterval = session.getMaxInactiveInterval();

// 序列化会话属性
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);

Enumeration attributeNames = session.getAttributeNames();
Map attributes = new HashMap<>();
while (attributeNames.hasMoreElements()) {
String name = attributeNames.nextElement();
attributes.put(name, session.getAttribute(name));
}

oos.writeObject(attributes);
byte[] sessionData = baos.toByteArray();

// 保存到数据库
try (Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(
“INSERT INTO sessions (session_id, creation_time, last_accessed_time, ” +
“max_inactive_interval, session_data) VALUES (?, ?, ?, ?, ?) ” +
“ON DUPLICATE KEY UPDATE ” +
“last_accessed_time = VALUES(last_accessed_time), ” +
“session_data = VALUES(session_data)”)) {

stmt.setString(1, sessionId);
stmt.setLong(2, creationTime);
stmt.setLong(3, lastAccessedTime);
stmt.setInt(4, maxInactiveInterval);
stmt.setBytes(5, sessionData);
stmt.executeUpdate();
}
}

// 加载会话
public HttpSession loadSession(String sessionId) throws SQLException, IOException, ClassNotFoundException {
try (Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(
“SELECT * FROM sessions WHERE session_id = ?”)) {

stmt.setString(1, sessionId);
ResultSet rs = stmt.executeQuery();

if (rs.next()) {
// 创建会话对象（需要自定义实现）
CustomHttpSession session = new CustomHttpSession(sessionId);

// 恢复属性
byte[] sessionData = rs.getBytes(“session_data”);
if (sessionData != null) {
ByteArrayInputStream bais = new ByteArrayInputStream(sessionData);
ObjectInputStream ois = new ObjectInputStream(bais);
@SuppressWarnings(“unchecked”)
Map attributes = (Map) ois.readObject();

for (Map.Entry entry : attributes.entrySet()) {
session.setAttribute(entry.getKey(), entry.getValue());
}
}

session.setCreationTime(rs.getLong(“creation_time”));
session.setLastAccessedTime(rs.getLong(“last_accessed_time”));
session.setMaxInactiveInterval(rs.getInt(“max_inactive_interval”));

return session;
}
}
return null;
}

// 清理过期会话
public void cleanupExpiredSessions() throws SQLException {
long currentTime = System.currentTimeMillis();
long expiredTime = currentTime – (30 * 60 * 1000); // 30分钟

try (Connection conn = dataSource.getConnection();
PreparedStatement stmt = conn.prepareStatement(
“DELETE FROM sessions WHERE last_accessed_time < ?")) { stmt.setLong(1, expiredTime); stmt.executeUpdate(); } } } // 创建数据库表 /* CREATE TABLE sessions ( session_id VARCHAR(100) PRIMARY KEY, creation_time BIGINT NOT NULL, last_accessed_time BIGINT NOT NULL, max_inactive_interval INT NOT NULL, session_data BLOB, INDEX idx_last_accessed (last_accessed_time) ); */ 3. 基于Redis的会话存储 // Redis会话管理器 public class RedisSessionManager { private JedisPool jedisPool; private static final String SESSION_PREFIX = "session:"; private static final int DEFAULT_EXPIRE_SECONDS = 1800; // 30分钟 public RedisSessionManager(String host, int port) { this.jedisPool = new JedisPool(host, port); } // 保存会话 public void saveSession(HttpSession session) { try (Jedis jedis = jedisPool.getResource()) { String key = SESSION_PREFIX + session.getId(); // 序列化会话数据 Map sessionData = new HashMap<>();
Enumeration attributeNames = session.getAttributeNames();

while (attributeNames.hasMoreElements()) {
String name = attributeNames.nextElement();
Object value = session.getAttribute(name);

try {
// 简单序列化（实际项目应使用JSON或更复杂的序列化）
sessionData.put(name, serialize(value));
} catch (Exception e) {
System.err.println(“序列化属性失败: ” + name);
}
}

// 存储到Redis
if (!sessionData.isEmpty()) {
jedis.hset(key, sessionData);
}

// 设置过期时间
int expireTime = session.getMaxInactiveInterval();
if (expireTime <= 0) { expireTime = DEFAULT_EXPIRE_SECONDS; } jedis.expire(key, expireTime); // 存储元数据 jedis.hset(key + ":meta", "creationTime", String.valueOf(session.getCreationTime())); jedis.hset(key + ":meta", "lastAccessedTime", String.valueOf(session.getLastAccessedTime())); } } // 加载会话 public HttpSession loadSession(String sessionId) { try (Jedis jedis = jedisPool.getResource()) { String key = SESSION_PREFIX + sessionId; // 检查键是否存在 if (!jedis.exists(key)) { return null; } // 创建会话对象 CustomHttpSession session = new CustomHttpSession(sessionId); // 加载属性 Map sessionData = jedis.hgetAll(key);
for (Map.Entry entry : sessionData.entrySet()) {
if (!entry.getKey().startsWith(“:”)) { // 排除元数据
Object value = deserialize(entry.getValue());
session.setAttribute(entry.getKey(), value);
}
}

// 加载元数据
Map meta = jedis.hgetAll(key + “:meta”);
if (meta.containsKey(“creationTime”)) {
session.setCreationTime(Long.parseLong(meta.get(“creationTime”)));
}
if (meta.containsKey(“lastAccessedTime”)) {
session.setLastAccessedTime(Long.parseLong(meta.get(“lastAccessedTime”)));
}

return session;
}
}

// 删除会话
public void deleteSession(String sessionId) {
try (Jedis jedis = jedisPool.getResource()) {
String key = SESSION_PREFIX + sessionId;
jedis.del(key);
jedis.del(key + “:meta”);
}
}

// 序列化（简化版，实际项目应使用JSON）
private String serialize(Object obj) {
if (obj == null) return “”;
return Base64.getEncoder().encodeToString(obj.toString().getBytes());
}

// 反序列化
private Object deserialize(String str) {
if (str == null || str.isEmpty()) return null;
try {
byte[] bytes = Base64.getDecoder().decode(str);
return new String(bytes);
} catch (Exception e) {
return str;
}
}
}
会话管理的高级技巧
1. 会话预取和缓存
// 会话数据缓存服务
public class SessionCacheService {

private static SessionCacheService instance;
private final Map localCache = new ConcurrentHashMap<>();
private final int MAX_CACHE_SIZE = 1000;

private SessionCacheService() {}

public static SessionCacheService getInstance() {
if (instance == null) {
synchronized (SessionCacheService.class) {
if (instance == null) {
instance = new SessionCacheService();
}
}
}
return instance;
}

// 预取会话数据
public void prefetchSessionData(String sessionId, String… attributeNames) {
HttpSession session = getSession(sessionId);
if (session != null) {
for (String attrName : attributeNames) {
Object value = session.getAttribute(attrName);
if (value != null) {
String cacheKey = sessionId + “:” + attrName;
localCache.put(cacheKey, value);
}
}
}
}

// 从缓存获取
public Object getCachedAttribute(String sessionId, String attributeName) {
String cacheKey = sessionId + “:” + attributeName;
return localCache.get(cacheKey);
}

// 清理缓存
public void clearCache(String sessionId) {
localCache.keySet().removeIf(key -> key.startsWith(sessionId + “:”));
}

private HttpSession getSession(String sessionId) {
// 这里应该通过实际的会话管理器获取
// 简化实现
return null;
}
}
2. 会话压缩
// 会话数据压缩工具
public class SessionCompressionUtil {

// 压缩会话数据
public static byte[] compressSessionData(Map attributes) throws IOException {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream gzipos = new GZIPOutputStream(baos);
ObjectOutputStream oos = new ObjectOutputStream(gzipos);

oos.writeObject(attributes);
oos.close();

return baos.toByteArray();
}

// 解压会话数据
@SuppressWarnings(“unchecked”)
public static Map decompressSessionData(byte[] compressedData)
throws IOException, ClassNotFoundException {

ByteArrayInputStream bais = new ByteArrayInputStream(compressedData);
GZIPInputStream gzipis = new GZIPInputStream(bais);
ObjectInputStream ois = new ObjectInputStream(gzipis);

Map attributes = (Map) ois.readObject();
ois.close();

return attributes;
}

// 使用示例
public static void main(String[] args) {
try {
// 准备数据
Map data = new HashMap<>();
data.put(“username”, “john_doe”);
data.put(“cart”, Arrays.asList(“item1”, “item2”, “item3”));
data.put(“preferences”, “dark_mode”);

// 压缩
byte[] compressed = compressSessionData(data);
System.out.println(“原始大小: ” + serializeSize(data) + ” bytes”);
System.out.println(“压缩后大小: ” + compressed.length + ” bytes”);

// 解压
Map restored = decompressSessionData(compressed);
System.out.println(“恢复数据: ” + restored);

} catch (Exception e) {
e.printStackTrace();
}
}

private static int serializeSize(Map data) {
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(data);
oos.close();
return baos.size();
} catch (IOException e) {
return -1;
}
}
}
3. 会话分页和大数据处理
// 处理大型会话数据
public class LargeSessionDataHandler {

// 分块存储大型数据
public void storeLargeData(HttpSession session, String key, Object data) {
try {
// 序列化
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(data);
byte[] serialized = baos.toByteArray();

// 如果数据超过1MB，分块存储
final int CHUNK_SIZE = 512 * 1024; // 512KB
if (serialized.length > CHUNK_SIZE) {
int chunks = (int) Math.ceil((double) serialized.length / CHUNK_SIZE);
session.setAttribute(key + “_chunks”, chunks);

for (int i = 0; i < chunks; i++) { int start = i * CHUNK_SIZE; int end = Math.min(start + CHUNK_SIZE, serialized.length); byte[] chunk = Arrays.copyOfRange(serialized, start, end); session.setAttribute(key + "_chunk_" + i, chunk); } // 标记为分块数据 session.setAttribute(key + "_isChunked", true); } else { // 小数据直接存储 session.setAttribute(key, serialized); session.removeAttribute(key + "_isChunked"); session.removeAttribute(key + "_chunks"); } } catch (IOException e) { throw new RuntimeException("Failed to store large session data", e); } } // 读取分块数据 @SuppressWarnings("unchecked") public T loadLargeData(HttpSession session, String key, Class type) {
try {
Boolean isChunked = (Boolean) session.getAttribute(key + “_isChunked”);

byte[] serialized;
if (Boolean.TRUE.equals(isChunked)) {
// 读取分块
Integer chunks = (Integer) session.getAttribute(key + “_chunks”);
if (chunks == null) return null;

ByteArrayOutputStream baos = new ByteArrayOutputStream();
for (int i = 0; i < chunks; i++) { byte[] chunk = (byte[]) session.getAttribute(key + "_chunk_" + i); if (chunk != null) { baos.write(chunk); } } serialized = baos.toByteArray(); } else { // 读取完整数据 serialized = (byte[]) session.getAttribute(key); } if (serialized == null) return null; // 反序列化 ByteArrayInputStream bais = new ByteArrayInputStream(serialized); ObjectInputStream ois = new ObjectInputStream(bais); Object data = ois.readObject(); return type.cast(data); } catch (Exception e) { throw new RuntimeException("Failed to load large session data", e); } } } 会话管理的常见问题和解决方案 1. 会话超时问题 问题 ：用户在填写长表单时会话超时，导致数据丢失。 解决方案 ： // 1. 前端定时器保持会话 // 在页面中添加JavaScript

// 2. 后端心跳Servlet
@WebServlet(“/keepAlive”)
public class KeepAliveServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {

HttpSession session = request.getSession(false);
if (session != null) {
// 更新最后访问时间
session.setAttribute(“lastHeartbeat”, System.currentTimeMillis());
response.setStatus(HttpServletResponse.SC_OK);
} else {
response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
}
}
}

// 3. 表单数据自动保存
public class AutoSaveFilter implements Filter {

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {

HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpSession session = httpRequest.getSession(false);

if (session != null && “POST”.equals(httpRequest.getMethod())) {
// 自动保存表单数据
String contentType = httpRequest.getContentType();
if (contentType != null && contentType.contains(“application/x-www-form-urlencoded”)) {

Map parameterMap = httpRequest.getParameterMap();
Map formData = new HashMap<>();

for (Map.Entry entry : parameterMap.entrySet()) {
if (entry.getValue().length > 0) {
formData.put(entry.getKey(), entry.getValue()[0]);
}
}

// 保存到会话
session.setAttribute(“autoSavedForm”, formData);
session.setAttribute(“autoSavedTime”, System.currentTimeMillis());
}
}

chain.doFilter(request, response);
}
}
2. 会话内存泄漏
问题
：会话中存储大量数据或未正确清理，导致内存泄漏。
解决方案
：
// 1. 使用弱引用存储大数据
public class MemorySafeSessionStorage {

private final Map> weakStorage = new ConcurrentHashMap<>();

public void setAttribute(HttpSession session, String name, Object value) {
if (isLargeData(value)) {
// 大数据使用弱引用
weakStorage.put(session.getId() + “:” + name, new WeakReference<>(value));
// 同时存储一个标记
session.setAttribute(name + “_weak”, true);
} else {
session.setAttribute(name, value);
}
}

public Object getAttribute(HttpSession session, String name) {
Boolean isWeak = (Boolean) session.getAttribute(name + “_weak”);
if (Boolean.TRUE.equals(isWeak)) {
WeakReference