• 一场技术破案的经过

    源起：

    一天，我的同事阿勇问我：你说如果tomcat session过期了，websocket还会继续往页面推送数据吗？

    听到该问题后，尽管当时我的表面冷静沉着，但内心做着飞快的如下盘算。

    首先我们常用的session是http请求通过cookie所存的sessionId在内存中寻找的，所以cookie/session机制是基于http协议的。

    然后websocket只有在初始握手时期才使用http协议，之后就升级为ws协议了。

    而ws协议和http协议同属在tcp协议之上的应用层协议，并没有隶属关系。

    所以websocket应该是无法知道tomcat session过期的。

    那么答案就很明显了：还会推送！

    就在我即将脱口而出的时候，一个理智的声音在脑海中提醒我，等等！

    如果session都失效了，websocket还可以推送消息，这不是bug吗？tomcat会允许这样的极不合理的现象存在吗？

    理智告诉我，久经沙场的tomcat应该不会有这么明显的问题。

    此时，我想到了一个叫狄仁杰的胖老头的口头禅：其中必有蹊跷。

    于是，我缓缓对阿勇说，这个我研究一下，回头告诉你。

    来都来了，先看下tomcat session的实现机制吧

    首先要说的是tomcat从8.5版本之后就抛弃了BIO线程模型，默认采用NIO线程模型。

    所以前期的流程是：Selector 线程将socket传递给Worker线程， 在Worker线程中，会完成从socket中读取http request，解析成HttpServletRequest对象，分派到相应的servlet并完成逻辑，然后将response通过socket发回client。

    故事就发生在Request对象这里。

    1. package org.apache.catalina.connector;
    2.  
    3. public class Request implements HttpServletRequest {
    4.  
    5. protected Session session = null;
    6.  
    7. protected String requestedSessionId = null;
    8.  
    9. protected Cookie[] cookies = null;
    10.  
    11. 。。。。。。
    12.  
    13. }

    request对象持有Session,Cookies,RequestSessionId等多个对象。

    那么session是什么时候生成的呢？

    在 Session在用户第一次访问服务器Servlet，jsp等动态资源就会被自动创建。创建流程如下：

    首先会Request.getSession()方法会被调用。

    1. Request.java
    2.  
    3. public HttpSession getSession() {
    4.  
    5.     //不存在session时会创建
    6.  
    7.     Session session = doGetSession(true);
    8.  
    9.     if (session == null) {
    10.  
    11.         return null;
    12.  
    13.     }
    14.  
    15.  
    16.  
    17.  
    18.  
    19.     return session.getSession();
    20.  
    21. }
    22.  
    23. //重点分析部分，session的创建过程
    24.  
    25. protected Session doGetSession(boolean create) {
    26.  
    27.     //省略部分代码
    28.  
    29.     ......
    30.  
    31.     //如果session 已经存在，判断是否过期。
    32.  
    33.     if ((session != null) && !session.isValid()) {
    34.  
    35.     //如果已经过期，则置为null
    36.  
    37.         session = null;
    38.  
    39.     }
    40.  
    41.    //存在且没有过期，直接返回
    42.  
    43.     if (session != null) {
    44.  
    45.         return session;
    46.  
    47.     }
    48.  
    49.     //省略部分代码
    50.  
    51.     ......
    52.  
    53.     //判断request中的sessionId是否存在，该值是从request请求里的cookie或者url中解析出来
    54.  
    55.     if (requestedSessionId != null) {
    56.  
    57.         try {
    58.  
    59.             //根据requestSessionId 查找session
    60.  
    61.             session = manager.findSession(requestedSessionId);
    62.  
    63.         } catch (IOException e) {
    64.  
    65.             if (log.isDebugEnabled()) {
    66.  
    67.                 log.debug(sm.getString("request.session.failed", requestedSessionId, e.getMessage()), e);
    68.  
    69.             } else {
    70.  
    71.                 log.info(sm.getString("request.session.failed", requestedSessionId, e.getMessage()));
    72.  
    73.             }
    74.  
    75.             session = null;
    76.  
    77.         }
    78.  
    79.         //判断session是否过期
    80.  
    81.         if ((session != null) && !session.isValid()) {
    82.  
    83.             session = null;
    84.  
    85.         }
    86.  
    87.         if (session != null) {
    88.  
    89.             session.access();
    90.  
    91.             return session;
    92.  
    93.         }
    94.  
    95.     }
    96.  
    97.     //省略部分代码
    98.  
    99.     ......
    100.  
    101.     //根据sessionId创建session，如sessionId不存在，则在内部自动生成sessionId。
    102.  
    103.     session = manager.createSession(sessionId);
    104.  
    105.  
    106.  
    107.    
    108.  
    109.     if (session != null && trackModesIncludesCookie) {
    110.  
    111.         Cookie cookie = ApplicationSessionCookieConfig.createSessionCookie(
    112.  
    113.                 context, session.getIdInternal(), isSecure());
    114.  
    115.         //session成功创建，将session对应sessionId 写入cookie
    116.  
    117.         response.addSessionCookieInternal(cookie);
    118.  
    119.     }
    120.  
    121.     return session;
    122.  
    123. }

    session是什么时候过期的呢？

    在上面代码中我们看到有session.isValid()方法多次被调用，我们进去看看。

    1. StandardSession.java
    2.  
    3. public boolean isValid() {
    4.  
    5.     //根据标识位快速判断
    6.  
    7.     if (!this.isValid) {
    8.  
    9.         return false;
    10.  
    11.     }
    12.  
    13.     //根据标识位快速判断
    14.  
    15.     if (this.expiring) {
    16.  
    17.         return true;
    18.  
    19.     }
    20.  
    21.     //根据标识位和使用次数快速判断
    22.  
    23.     if (ACTIVITY_CHECK && accessCount.get() > 0) {
    24.  
    25.         return true;
    26.  
    27.     }
    28.  
    29.     //配置中的session过期时间
    30.  
    31.     if (maxInactiveInterval > 0) {
    32.  
    33.         //计算从最后一次session被请求到现在的时间，为闲置时间
    34.  
    35.         int timeIdle = (int) (getIdleTimeInternal() / 1000L);
    36.  
    37.         //如果限制时间大于配置的session过期时间
    38.  
    39.         if (timeIdle >= maxInactiveInterval) {
    40.  
    41.             //进行过期操作。
    42.  
    43.             expire(true);
    44.  
    45.         }
    46.  
    47.     }
    48.  
    49.     return this.isValid;
    50.  
    51. }

    我们再看下session过期操作的内容

    1. StandardSession.java
    2.  
    3. public void expire(boolean notify) {
    4.  
    5.     //双检锁
    6.  
    7.     if (!isValid) {
    8.  
    9.         return;
    10.  
    11.     }
    12.  
    13.     synchronized (this) {
    14.  
    15.         if (expiring || !isValid) {
    16.  
    17.             return;
    18.  
    19.         }
    20.  
    21.         if (manager == null) {
    22.  
    23.             return;
    24.  
    25.         }
    26.  
    27.         expiring = true;
    28.  
    29.         Context context = manager.getContext();
    30.  
    31.         //这里对session观察者进行通知session失效事件的通知
    32.  
    33.         if (notify) {
    34.  
    35.             ClassLoader oldContextClassLoader = null;
    36.  
    37.             try {
    38.  
    39.                 oldContextClassLoader = context.bind(Globals.IS_SECURITY_ENABLED, null);
    40.  
    41.                 Object listeners[] = context.getApplicationLifecycleListeners();
    42.  
    43.                 if (listeners != null && listeners.length > 0) {
    44.  
    45.                     HttpSessionEvent event =
    46.  
    47.                         new HttpSessionEvent(getSession());
    48.  
    49.                     for (int i = 0; i < listeners.length; i++) {
    50.  
    51.                         int j = (listeners.length - 1) - i;
    52.  
    53.                         if (!(listeners[j] instanceof HttpSessionListener)) {
    54.  
    55.                             continue;
    56.  
    57.                         }
    58.  
    59.                         HttpSessionListener listener =
    60.  
    61.                             (HttpSessionListener) listeners[j];
    62.  
    63.                         try {
    64.  
    65.                             context.fireContainerEvent("beforeSessionDestroyed",
    66.  
    67.                                     listener);
    68.  
    69.                             listener.sessionDestroyed(event);
    70.  
    71.                             context.fireContainerEvent("afterSessionDestroyed",
    72.  
    73.                                     listener);
    74.  
    75.                         } catch (Throwable t) {
    76.  
    77.                             ExceptionUtils.handleThrowable(t);
    78.  
    79.                             try {
    80.  
    81.                                 context.fireContainerEvent(
    82.  
    83.                                         "afterSessionDestroyed", listener);
    84.  
    85.                             } catch (Exception e) {
    86.  
    87.                                 // Ignore
    88.  
    89.                             }
    90.  
    91.                             manager.getContext().getLogger().error
    92.  
    93.                                 (sm.getString("standardSession.sessionEvent"), t);
    94.  
    95.                         }
    96.  
    97.                     }
    98.  
    99.                 }
    100.  
    101.             } finally {
    102.  
    103.                 context.unbind(Globals.IS_SECURITY_ENABLED, oldContextClassLoader);
    104.  
    105.             }
    106.  
    107.         }
    108.  
    109.         if (ACTIVITY_CHECK) {
    110.  
    111.             accessCount.set(0);
    112.  
    113.         }
    114.  
    115.                 //从manager中移出该session
    116.  
    117.         manager.remove(this, true);
    118.  
    119.  
    120.  
    121.         if (notify) {
    122.  
    123.             fireSessionEvent(Session.SESSION_DESTROYED_EVENT, null);
    124.  
    125.         }
    126.  
    127.                 //设置标识位
    128.  
    129.         setValid(false);
    130.  
    131.         expiring = false;
    132.  
    133.  
    134.  
    135.         // 解除相关绑定
    136.  
    137.         String keys[] = keys();
    138.  
    139.         ClassLoader oldContextClassLoader = null;
    140.  
    141.         try {
    142.  
    143.             oldContextClassLoader = context.bind(Globals.IS_SECURITY_ENABLED, null);
    144.  
    145.             for (String key : keys) {
    146.  
    147.                 removeAttributeInternal(key, notify);
    148.  
    149.             }
    150.  
    151.         } finally {
    152.  
    153.             context.unbind(Globals.IS_SECURITY_ENABLED, oldContextClassLoader);
    154.  
    155.         }
    156.  
    157.     }
    158.  
    159. }

    总的来说，做了三件事，一是通知观察者session失效事件，二是从manager中移出失效session,三是解除该session的相关关联关系。

    还有个疑问，这次session过期操作是通过http请求触发的，那如果该session过期用户再也不请求，session不就没有办法从内存中移出了嘛，这不就内存泄漏了吗？

    所以此处肯定另有机关。

    果不其然。

    在tomcat启动时会启动一个background线程，对过期session进行清理。

    1. ManagerBase.java
    2.  
    3. public void backgroundProcess() {
    4.  
    5.     count = (count + 1) % processExpiresFrequency;
    6.  
    7.     if (count == 0) {
    8.  
    9.         processExpires();
    10.  
    11.     }
    12.  
    13. }
    14.  
    15. public void processExpires() {
    16.  
    17.     long timeNow = System.currentTimeMillis();
    18.  
    19.     Session sessions[] = findSessions();
    20.  
    21.     int expireHere = 0 ;
    22.  
    23.     for (Session session : sessions) {
    24.  
    25.         if (session != null && !session.isValid()) {
    26.  
    27.             expireHere++;
    28.  
    29.         }
    30.  
    31.     }
    32.  
    33.         //省略部分代码
    34.  
    35.     ......
    36.  
    37. }

    这就说的通了，当请求触发时会判断session是否过期，如果过期则删除。另外还另起一个线程，对过期session进行以10秒一次的定期删除。

    session搞清楚了，下面有请我们的今天的主角websocket登场。

    websocket的会话保持用的也是session,不过这个session是WsSession,跟httpSession的关系呢，就是WsSession持有了HttpSession的Id。

    代码如下：

    1. WsSession.java
    2.  
    3. //父类Session并不是前文的org.apache.catalina.Session，而是javax.websocket.Session。两者没有关系
    4.  
    5. public class WsSession implements Session {
    6.  
    7.     //省略部分代码
    8.  
    9.     ......
    10.  
    11.     private final WsWebSocketContainer webSocketContainer;
    12.  
    13.     private final URI requestUri;
    14.  
    15.     private final Map> requestParameterMap;
    16.  
    17.     private final String queryString;
    18.  
    19.     private final Principal userPrincipal;
    20.  
    21.     private final Map pathParameters;
    22.  
    23.     //持有httpSessionId
    24.  
    25.     private final String httpSessionId;
    26.  
    27.     //session状态标识位
    28.  
    29.     private volatile State state = State.OPEN;
    30.  
    31.     //校验session状态表示位
    32.  
    33.     private void checkState() {
    34.  
    35.         if (state == State.CLOSED) {
    36.  
    37.         /*
    39.          * As per RFC 6455, a WebSocket connection is considered to be
    41.          * closed once a peer has sent and received a WebSocket close frame.
    43.          */
    44.  
    45.         throw new IllegalStateException(sm.getString("wsSession.closed", id));
    46.  
    47.         }
    48.  
    49.     }

    在websocket client和server端交互的过程中，会多次调用checkState方法，而checkState方法是判断state属性。

    那么我们看下state属性什么时候会发现变化，最终我们可以找到一个WsSessionListener。

    1. //实现了HttpSessionListener接口
    2.  
    3. public class WsSessionListener implements HttpSessionListener{
    4.  
    5.     private final WsServerContainer wsServerContainer;
    6.  
    7.     public WsSessionListener(WsServerContainer wsServerContainer) {
    8.  
    9.         this.wsServerContainer = wsServerContainer;
    10.  
    11.     }
    12.  
    13.     @Override
    14.  
    15.     public void sessionDestroyed(HttpSessionEvent se) {
    16.  
    17.         wsServerContainer.closeAuthenticatedSession(se.getSession().getId());
    18.  
    19.     }
    20.  
    21. }
    22.  
    23.  
    24.  
    25. WsServerContainer.java
    26.  
    27. ...省略其他方法
    28.  
    29. //
    30.  
    31. public void closeAuthenticatedSession(String httpSessionId) {
    32.  
    33.     Set wsSessions = authenticatedSessions.remove(httpSessionId);
    34.  
    35.  
    36.  
    37.  
    38.  
    39.     if (wsSessions != null && !wsSessions.isEmpty()) {
    40.  
    41.         for (WsSession wsSession : wsSessions) {
    42.  
    43.             try {
    44.  
    45.                                 //wsSession关闭
    46.  
    47.                 wsSession.close(AUTHENTICATED_HTTP_SESSION_CLOSED);
    48.  
    49.             } catch (IOException e) {
    50.  
    51.                 // Any IOExceptions during close will have been caught and the
    52.  
    53.                 // onError method called.
    54.  
    55.             }
    56.  
    57.         }
    58.  
    59.     }
    60.  
    61. }
    62.  
    63. WsSession.java
    64.  
    65. public void close(CloseReason closeReason) throws IOException {
    66.  
    67.     doClose(closeReason, closeReason);
    68.  
    69. }
    70.  
    71. public void doClose(CloseReason closeReasonMessage, CloseReason closeReasonLocal) {
    72.  
    73.     doClose(closeReasonMessage, closeReasonLocal, false);
    74.  
    75. }
    76.  
    77. public void doClose(CloseReason closeReasonMessage, CloseReason closeReasonLocal,
    78.  
    79.         boolean closeSocket) {
    80.  
    81.     //双检锁
    82.  
    83.     if (state != State.OPEN) {
    84.  
    85.         return;
    86.  
    87.     }
    88.  
    89.     synchronized (stateLock) {
    90.  
    91.      //已关闭，直接返回
    92.  
    93.         if (state != State.OPEN) {
    94.  
    95.             return;
    96.  
    97.         }
    98.  
    99.         if (log.isDebugEnabled()) {
    100.  
    101.             log.debug(sm.getString("wsSession.doClose", id));
    102.  
    103.         }
    104.  
    105.  
    106.  
    107.  
    108.  
    109.         //清理该WsSession绑定的相关的信息
    110.  
    111.         try {
    112.  
    113.             wsRemoteEndpoint.setBatchingAllowed(false);
    114.  
    115.         } catch (IOException e) {
    116.  
    117.             log.warn(sm.getString("wsSession.flushFailOnClose"), e);
    118.  
    119.             fireEndpointOnError(e);
    120.  
    121.         }
    122.  
    123.  
    124.  
    125.         //将state属性值为关闭
    126.  
    127.         if (state != State.OUTPUT_CLOSED) {
    128.  
    129.             state = State.OUTPUT_CLOSED;
    130.  
    131.             sendCloseMessage(closeReasonMessage);
    132.  
    133.             if (closeSocket) {
    134.  
    135.                 wsRemoteEndpoint.close();
    136.  
    137.             }
    138.  
    139.             fireEndpointOnClose(closeReasonLocal);
    140.  
    141.         }
    142.  
    143.     }
    144.  
    145.         。。。
    146.  
    147. }

    那么我们看到state属性在WsSessionListener中进行了关闭，那么WsSessionListener又是什么时候触发的呢？

    前面代码中我们看到WsSessionListener实现了HttpSessionListener接口。

    等等，这个HttpSessionListener很眼熟嘛，听口音像是老乡，有点印象。

    果然，往前一翻，就发现了在之前的StandardSession.java的分析中，就有过一面之缘。

    让我们还原一下当时初次见面时的的情景。

    1. StandardSession.java
    2.  
    3. public void expire(boolean notify) {
    4.  
    5.     //双检锁
    6.  
    7.     if (!isValid) {
    8.  
    9.         return;
    10.  
    11.     }
    12.  
    13.     synchronized (this) {
    14.  
    15.         if (expiring || !isValid) {
    16.  
    17.             return;
    18.  
    19.         }
    20.  
    21.         if (manager == null) {
    22.  
    23.             return;
    24.  
    25.         }
    26.  
    27.         expiring = true;
    28.  
    29.         Context context = manager.getContext();
    30.  
    31.         //这里对session观察者进行通知session失效事件的通知
    32.  
    33.         if (notify) {
    34.  
    35.             ClassLoader oldContextClassLoader = null;
    36.  
    37.             try {
    38.  
    39.                 oldContextClassLoader = context.bind(Globals.IS_SECURITY_ENABLED, null);
    40.  
    41.                 Object listeners[] = context.getApplicationLifecycleListeners();
    42.  
    43.                 if (listeners != null && listeners.length > 0) {
    44.  
    45.                     HttpSessionEvent event =
    46.  
    47.                         new HttpSessionEvent(getSession());
    48.  
    49.                     for (int i = 0; i < listeners.length; i++) {
    50.  
    51.                         int j = (listeners.length - 1) - i;
    52.  
    53.                         if (!(listeners[j] instanceof HttpSessionListener)) {
    54.  
    55.                             continue;
    56.  
    57.                         }
    58.  
    59.                  //就是这里，在http Session过期时，对HttpSessionListener进行了通知
    60.  
    61.                         HttpSessionListener listener =
    62.  
    63.                             (HttpSessionListener) listeners[j];
    64.  
    65.                         try {
    66.  
    67.                             context.fireContainerEvent("beforeSessionDestroyed",
    68.  
    69.                                     listener);
    70.  
    71.                             listener.sessionDestroyed(event);
    72.  
    73.                             context.fireContainerEvent("afterSessionDestroyed",
    74.  
    75.                                     listener);
    76.  
    77.                         } catch (Throwable t) {
    78.  
    79.                             ExceptionUtils.handleThrowable(t);
    80.  
    81.                             try {
    82.  
    83.                                 context.fireContainerEvent(
    84.  
    85.                                         "afterSessionDestroyed", listener);
    86.  
    87.                             } catch (Exception e) {
    88.  
    89.                                 // Ignore
    90.  
    91.                             }
    92.  
    93.                             manager.getContext().getLogger().error
    94.  
    95.                                 (sm.getString("standardSession.sessionEvent"), t);
    96.  
    97.                         }
    98.  
    99.                     }
    100.  
    101.                 }
    102.  
    103.             } finally {
    104.  
    105.                 context.unbind(Globals.IS_SECURITY_ENABLED, oldContextClassLoader);
    106.  
    107.             }
    108.  
    109.         }
    110.  
    111.        。。。
    112.  
    113. }

    这样情况就明了了，http Session 失效时会通过观察者模式通知 WsSessionListener对对应httpSessionId的WsSession进行过期处理，这样WsSession也就跟随着HttpSession一同失效了。

    所以开始的问题的答案也就浮出了水面：一旦http Session 过期了，webService就会停止信息的推送。

    镜头转回来，我缓缓对阿勇说：事情的来龙去脉就是这样。

  • 相关阅读:
    生成式AI：未来的发展方向是什么？
    make编译相关教程（经验版）
    Spring Security根据角色在登录后重定向用户
    C++中悬垂指针（delete后指针）仍然可以访问所指内存的问题
    RocketMQ生产者原理及最佳实践
    Win10安装Anaconda和VSCode
    gRPC之metadata
    栈实现综合计算器(思路分析) [数据结构][Java]
    【PyTorch】深度学习实践之反向传播 Back Propagation
    Linux 安装 mongodb
  • 原文地址：https://blog.csdn.net/zhangzhen02/article/details/126171948