如何在不延长HttpSession的情况下查询其剩余过期时间？

要解决Tomcat中查询会话剩余过期时间但不触发会话活动的问题，有几个可行的方案，核心都是绕过默认的会话活动标记机制：

方案1：直接调用Tomcat内部API（最精准） #

Tomcat的StandardSession提供了重载的会话获取方法，可以控制是否标记会话为活动。你可以通过请求拿到会话ID，再从Tomcat的会话管理器中获取会话实例，同时跳过活动标记：

import org.apache.catalina.Manager;
import org.apache.catalina.Session;
import org.apache.catalina.connector.Request;
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 java.io.IOException;
import java.io.PrintWriter;

@WebServlet("/session-expiry")
public class SessionExpiryServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("application/json");
        PrintWriter out = response.getWriter();

        // 获取Tomcat原生Request对象
        Request tomcatRequest = (Request) request.getAttribute("org.apache.catalina.core.ApplicationFilterChain.request");
        if (tomcatRequest == null) {
            out.write("{\"error\": \"无法获取Tomcat请求实例\"}");
            return;
        }

        String sessionId = tomcatRequest.getRequestedSessionId();
        if (sessionId == null) {
            out.write("{\"remainingSeconds\": 0}");
            return;
        }

        Manager manager = tomcatRequest.getContext().getManager();
        try {
            // 第二个参数false表示不标记会话为活动
            Session session = manager.getSession(sessionId, false);
            if (session == null) {
                out.write("{\"remainingSeconds\": 0}");
                return;
            }

            long lastAccessed = session.getLastAccessedTime();
            long maxInactiveMs = session.getMaxInactiveInterval() * 1000L;
            long currentTime = System.currentTimeMillis();
            long remaining = (lastAccessed + maxInactiveMs) - currentTime;

            out.write("{\"remainingSeconds\": " + Math.max(0, remaining / 1000) + "}");
        } catch (Exception e) {
            out.write("{\"error\": \"查询会话状态失败\"}");
        }
    }
}

注意：这个方案依赖Tomcat的catalina.jar，WAR包部署时Tomcat会自动提供该依赖；如果用嵌入式Tomcat，需要在构建文件中添加依赖。若不想强依赖Tomcat API，可以用反射调用getSession(String, boolean)方法避免编译时依赖。

方案2：自定义会话监听器缓存状态（跨容器通用） #

如果你的应用可能部署到其他Servlet容器（如Jetty），可以通过会话监听器维护一个状态缓存，完全不依赖容器内部API：

第一步：创建会话监听器 #

import javax.servlet.annotation.WebListener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@WebListener
public class SessionStatusListener implements HttpSessionListener {
    // 缓存会话ID -> 最后访问时间（毫秒）
    private static final Map<String, Long> sessionLastAccessed = new ConcurrentHashMap<>();
    // 缓存会话ID -> 最大 inactive 间隔（秒）
    private static final Map<String, Integer> sessionMaxInactive = new ConcurrentHashMap<>();

    @Override
    public void sessionCreated(HttpSessionEvent se) {
        String sessionId = se.getSession().getId();
        sessionLastAccessed.put(sessionId, se.getSession().getLastAccessedTime());
        sessionMaxInactive.put(sessionId, se.getSession().getMaxInactiveInterval());
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        String sessionId = se.getSession().getId();
        sessionLastAccessed.remove(sessionId);
        sessionMaxInactive.remove(sessionId);
    }

    // 更新缓存的最后访问时间
    public static void updateLastAccessed(String sessionId) {
        sessionLastAccessed.put(sessionId, System.currentTimeMillis());
    }

    // 查询剩余过期时间
    public static long getRemainingSeconds(String sessionId) {
        Long lastAccessed = sessionLastAccessed.get(sessionId);
        Integer maxInactive = sessionMaxInactive.get(sessionId);
        if (lastAccessed == null || maxInactive == null) {
            return 0;
        }
        long maxInactiveMs = maxInactive * 1000L;
        long currentTime = System.currentTimeMillis();
        long remaining = (lastAccessed + maxInactiveMs) - currentTime;
        return Math.max(0, remaining / 1000);
    }
}

第二步：添加过滤器更新缓存 #

创建过滤器，在所有触发会话活动的请求中更新缓存的最后访问时间：

import javax.servlet.annotation.WebFilter;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@WebFilter("/*")
public class SessionActivityFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String sessionId = httpRequest.getRequestedSessionId();
        if (sessionId != null && httpRequest.isRequestedSessionIdValid()) {
            SessionStatusListener.updateLastAccessed(sessionId);
        }
        chain.doFilter(request, response);
    }
}

第三步：编写查询Servlet #

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

@WebServlet("/session-expiry")
public class SessionExpiryServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("application/json");
        PrintWriter out = response.getWriter();

        String sessionId = request.getRequestedSessionId();
        if (sessionId == null || !request.isRequestedSessionIdValid()) {
            out.write("{\"remainingSeconds\": 0}");
            return;
        }

        long remaining = SessionStatusListener.getRemainingSeconds(sessionId);
        out.write("{\"remainingSeconds\": " + remaining + "}");
    }
}

这个方案的优势是跨容器通用，但需要确保过滤器覆盖所有会触发会话活动的请求，否则缓存的时间会不准确。

方案3：利用Tomcat JMX查询（适合内部监控） #

Tomcat会将会话信息注册到JMX，你可以通过JMX API查询会话的lastAccessedTime和maxInactiveInterval。不过该方案需要后端做代理（JMX不适合直接暴露给前端），且需要配置JMX权限，一般用于运维监控场景，不太适合前端预警接口。

内容的提问来源于stack exchange，提问作者Mumonkan