Shiro重构：整合token和cookie实现登陆及验证

待我称王封你为后i 2022-09-16 06:08 566阅读 0赞

# Shiro重构：整合token和cookie实现登陆及验证 #

认证服务开始只支持PC端的cookie认证方式，因业务需要，要对小程序、H5、App等移动端设备进行认证，这里复用认证服务。由于小程序不支持cookie认证方式，采用token认证方式，这里对认证服务进行重构。认证服务主要是有Shiro框架研发，我们简单熟悉下Cookie的认证流程。

Shiro的cookie认证流程我们简单说明下，

*  shiro是在其默认的会话管理器DefaultWebSessionManager中获取请求携带过来的cookie。主要的功能是添加、删除SessionId到Cookie、读取Cookie获得SessionId。

用户首先通过用户名口令或手机号+验证码方式，调用认证服务接口进行登陆操作。

Subject subject = SecurityUtils.getSubject();
    UsernamePasswordToken token = new UsernamePasswordToken(username,password);
    subject.login(token);//当调用subject的登入方法时，会跳转到认证的方法上
    User user = (User) subject.getPrincipal();//获取当前登陆对象
    //TODO: 做之后的事情

这里用户登陆成功后，会将通过DefaultWebSessionManager，生成SessionId，并将sid做为key保存在redis缓存中（通过redis做session共享）。并将sid保存到cookie中，返回浏览器。

*  浏览器发起请求，传递cookie，Shiro框架通过DefaultWebSessionManager中的getSessionId方法，获取cookie中的Sid.

public Serializable getSessionId(SessionKey key) {
            Serializable id = super.getSessionId(key);
            if (id == null && WebUtils.isWeb(key)) {
                ServletRequest request = WebUtils.getRequest(key);
                ServletResponse response = WebUtils.getResponse(key);
                id = this.getSessionId(request, response);
            }
            return id;
    }

获取到sid后，到redis中查询用户信息，如果能获取到则通过，否则进行拦截处理。

## 一、重写DefaultWebSessionManager方法 ##

用户请求到服务端后，首先判断该请求是否需要鉴权，如果不需要鉴权则直接放行。如果需要鉴权，则进入`DefaultWebSessionManager`中的`getSessionId`方法。这里我们重新定义个SessionManager，重写getSessionId方法。

我们定义个CustomerWebSessionManager继承DefaultWebSessionManager，重写getSessionId方法，我们首先从请求头中判断是否存在token,如果存在我们直接获取请求头中的token信息，并将token设置到请求头中`request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token)`。

public class CustomerWebSessionManager extends DefaultWebSessionManager {
        private static final String AUTH_TOKEN = "token";
        private static final String DEVICE = "device";
        private static final String MOBILE = "mobile";
    
        public CustomerWebSessionManager() {
            super();
        }
    
        /**
         * 重写父类获取sessionID的方法,若请求为APP或者H5则从请求头中取出token
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return id
         */
        @Override
        protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
            if (!(request instanceof HttpServletRequest)) {
                log.debug("Current request is not an HttpServletRequest - cannot get session ID.  Returning null.");
                return null;
            }
            HttpServletRequest httpRequest = WebUtils.toHttp(request);
            if (StringUtils.hasText(httpRequest.getHeader(AUTH_TOKEN))) {
                //从header中获取token
                String token = httpRequest.getHeader(AUTH_TOKEN);
                // 每次读取之后都把当前的token放入response中
                HttpServletResponse httpResponse = WebUtils.toHttp(response);
                if (StringUtils.hasText(token)) {
                    httpResponse.setHeader(AUTH_TOKEN, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
                }
                //sessionIdUrlRewritingEnabled的配置为false,不会在url的后面带上sessionID
                request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
                return token;
            }
            return getReferencedSessionId(request, response);
        }
    }

如果请求头中的token不存在，则走`getReferencedSessionId`方法，获取cookie中的信息。

/**
         * shiro默认从cookie中获取sessionId
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return
         */
        private Serializable getReferencedSessionId(ServletRequest request, ServletResponse response) {
            String id = getSessionIdCookieValue(request, response);
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                        ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
            } else {
                //not in a cookie, or cookie is disabled - try the request URI as a fallback (i.e. due to URL rewriting):
                //try the URI path segment parameters first:
                id = getUriPathSegmentParamValue(request, ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
                if (id == null) {
                    //not a URI path segment parameter, try the query parameters:
                    String name = getSessionIdName();
                    id = request.getParameter(name);
                    if (id == null) {
                        //try lowercase:
                        id = request.getParameter(name.toLowerCase());
                    }
                }
                if (id != null) {
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                            ShiroHttpServletRequest.URL_SESSION_ID_SOURCE);
                }
            }
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
                //automatically mark it valid here.  If it is invalid, the
                //onUnknownSession method below will be invoked and we'll remove the attribute at that time.
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            }
            // always set rewrite flag - SHIRO-361
            request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
            return id;
        }

这里验证请求头中的token方法重构完成。

/**
         * 重写父类获取sessionID的方法,若请求为APP或者H5则从请求头中取出token
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return id
         */
        @Override
        protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
            if (!(request instanceof HttpServletRequest)) {
                log.debug("Current request is not an HttpServletRequest - cannot get session ID.  Returning null.");
                return null;
            }
            HttpServletRequest httpRequest = WebUtils.toHttp(request);
            if (StringUtils.hasText(httpRequest.getHeader(AUTH_TOKEN))) {
                //从header中获取token
                String token = httpRequest.getHeader(AUTH_TOKEN);
                // 每次读取之后都把当前的token放入response中
                HttpServletResponse httpResponse = WebUtils.toHttp(response);
                if (StringUtils.hasText(token)) {
                    httpResponse.setHeader(AUTH_TOKEN, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
                }
                //sessionIdUrlRewritingEnabled的配置为false,不会在url的后面带上sessionID
                request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
                return token;
            }
            return getReferencedSessionId(request, response);
        }
    
        /**
         * shiro默认从cookie中获取sessionId
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return
         */
        private Serializable getReferencedSessionId(ServletRequest request, ServletResponse response) {
            String id = getSessionIdCookieValue(request, response);
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                        ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
            } else {
                //not in a cookie, or cookie is disabled - try the request URI as a fallback (i.e. due to URL rewriting):
                //try the URI path segment parameters first:
                id = getUriPathSegmentParamValue(request, ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
                if (id == null) {
                    //not a URI path segment parameter, try the query parameters:
                    String name = getSessionIdName();
                    id = request.getParameter(name);
                    if (id == null) {
                        //try lowercase:
                        id = request.getParameter(name.toLowerCase());
                    }
                }
                if (id != null) {
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                            ShiroHttpServletRequest.URL_SESSION_ID_SOURCE);
                }
            }
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
                //automatically mark it valid here.  If it is invalid, the
                //onUnknownSession method below will be invoked and we'll remove the attribute at that time.
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            }
            // always set rewrite flag - SHIRO-361
            request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
            return id;
        }
    
        /**
         * copy from DefaultWebSessionManager
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return
         */
        private String getSessionIdCookieValue(ServletRequest request, ServletResponse response) {
            if (!isSessionIdCookieEnabled()) {
                log.debug("Session ID cookie is disabled - session id will not be acquired from a request cookie.");
                return null;
            }
            if (!(request instanceof HttpServletRequest)) {
                log.debug("Current request is not an HttpServletRequest - cannot get session ID cookie.  Returning null.");
                return null;
            }
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            return getSessionIdCookie().readValue(httpRequest, WebUtils.toHttp(response));
        }
    
        private String getUriPathSegmentParamValue(ServletRequest servletRequest, String paramName) {
            if (!(servletRequest instanceof HttpServletRequest)) {
                return null;
            }
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            String uri = request.getRequestURI();
            if (uri == null) {
                return null;
            }
            int queryStartIndex = uri.indexOf('?');
            if (queryStartIndex >= 0) {
                uri = uri.substring(0, queryStartIndex);
            }
            int index = uri.indexOf(';');
            if (index < 0) {
                //no path segment params - return:
                return null;
            }
            //there are path segment params, let's get the last one that may exist:
            final String TOKEN = paramName + "=";
            uri = uri.substring(index + 1);
            //we only care about the last JSESSIONID param:
            index = uri.lastIndexOf(TOKEN);
            if (index < 0) {
                //no segment param:
                return null;
            }
            uri = uri.substring(index + TOKEN.length());
            index = uri.indexOf(';');
            if (index >= 0) {
                uri = uri.substring(0, index);
            }
            return uri;
        }
    
        private String getSessionIdName() {
            String name = this.getSessionIdCookie() != null ? this.getSessionIdCookie().getName() : null;
            if (name == null) {
                name = ShiroHttpSession.DEFAULT_SESSION_ID_NAME;
            }
            return name;
        }

## 二、登陆将token设置到响应头中 ##

我们编写用户登陆接口，在用户登陆时，cookie方式是将sid直接写入到浏览器cookie中，这样前端人员无法获取token值。需要我们将token返回给前端。这里我们将token放到响应头中。

我们登陆时无cookie和token,当shiro取不到sessionid时,会调用DelegatingSubject类中的getSession(true)方法创建一个新的session.

public Session getSession(boolean create) {
            if (log.isTraceEnabled()) {
                log.trace("attempting to get session; create = " + create +
                        "; session is null = " + (this.session == null) +
                        "; session has id = " + (this.session != null && session.getId() != null));
            }
    
            if (this.session == null && create) {
    
                //added in 1.2:
                if (!isSessionCreationEnabled()) {
                    String msg = "Session creation has been disabled for the current subject.  This exception indicates " +
                            "that there is either a programming error (using a session when it should never be " +
                            "used) or that Shiro's configuration needs to be adjusted to allow Sessions to be created " +
                            "for the current Subject.  See the " + DisabledSessionException.class.getName() + " JavaDoc " +
                            "for more.";
                    throw new DisabledSessionException(msg);
                }
    
                log.trace("Starting session for host {}", getHost());
                SessionContext sessionContext = createSessionContext();
                Session session = this.securityManager.start(sessionContext);
                this.session = decorate(session);
            }
            return this.session;
        }

会调用`Session session = this.securityManager.start(sessionContext);`方法，最终调用的是DefaultWebSessionManager中的onStart方法。所以我们要重写这个方法,将产生的sessionid放到response header中.另外当session失效或销毁时的相关方法也需重新实现,具体代码如下：

这里我们在存储sid增加了判断逻辑，如请求头中包含设备信息，则将sid存在到响应头中，否则存在到cookie中。

/**
         * 存储会话id到response header中
         *
         * @param currentId 会话ID
         * @param request   HttpServletRequest
         * @param response  HttpServletResponse
         */
        private void storeSessionId(Serializable currentId, HttpServletRequest request, HttpServletResponse response) {
            if (currentId == null) {
                String msg = "sessionId cannot be null when persisting for subsequent requests.";
                throw new IllegalArgumentException(msg);
            }
            String idString = currentId.toString();
            //增加判断，如果请求头中包含DEVICE=MOBILE，则将sessionId放在header中返回
            if (StringUtils.hasText(request.getHeader(DEVICE)) && MOBILE.equals(request.getHeader(DEVICE))) {
                response.setHeader(AUTH_TOKEN, idString);
            } else {
                Cookie template = getSessionIdCookie();
                Cookie cookie = new SimpleCookie(template);
                cookie.setValue(idString);
                cookie.saveTo(request, response);
            }
            log.trace("Set session ID cookie for session with id {}", idString);
        }
    
        /**
         * 设置deleteMe到response header中
         *
         * @param request  request
         * @param response HttpServletResponse
         */
        private void removeSessionIdCookie(HttpServletRequest request, HttpServletResponse response) {
            if (StringUtils.hasText(request.getHeader(AUTH_TOKEN))) {
                response.setHeader(AUTH_TOKEN, Cookie.DELETED_COOKIE_VALUE);
            } else {
                getSessionIdCookie().removeFrom(request, response);
            }
        }
    
        /**
         * 会话创建
         * Stores the Session's ID, usually as a Cookie, to associate with future requests.
         *
         * @param session the session that was just {@link #createSession created}.
         */
        @Override
        protected void onStart(Session session, SessionContext context) {
            super.onStart(session, context);
            if (!WebUtils.isHttp(context)) {
                log.debug("SessionContext argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. No session ID cookie will be set.");
                return;
            }
            HttpServletRequest request = WebUtils.getHttpRequest(context);
            HttpServletResponse response = WebUtils.getHttpResponse(context);
            if (isSessionIdCookieEnabled()) {
                Serializable sessionId = session.getId();
                storeSessionId(sessionId, request, response);
            } else {
                log.debug("Session ID cookie is disabled.  No cookie has been set for new session with id {}", session.getId());
            }
            request.removeAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_IS_NEW, Boolean.TRUE);
        }
    
        /**
         * 会话失效
         *
         * @param s   Session
         * @param ese ExpiredSessionException
         * @param key SessionKey
         */
        @Override
        protected void onExpiration(Session s, ExpiredSessionException ese, SessionKey key) {
            super.onExpiration(s, ese, key);
            onInvalidation(key);
        }
    
        @Override
        protected void onInvalidation(Session session, InvalidSessionException ise, SessionKey key) {
            super.onInvalidation(session, ise, key);
            onInvalidation(key);
        }
    
        private void onInvalidation(SessionKey key) {
            ServletRequest request = WebUtils.getRequest(key);
            if (request != null) {
                request.removeAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID);
            }
            if (WebUtils.isHttp(key)) {
                log.debug("Referenced session was invalid.  Removing session ID cookie.");
                removeSessionIdCookie(WebUtils.getHttpRequest(key), WebUtils.getHttpResponse(key));
            } else {
                log.debug("SessionKey argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. Session ID cookie will not be removed due to invalidated session.");
            }
        }
    
        /**
         * 会话销毁
         *
         * @param session Session
         * @param key     SessionKey
         */
        @Override
        protected void onStop(Session session, SessionKey key) {
            super.onStop(session, key);
            if (WebUtils.isHttp(key)) {
                HttpServletRequest request = WebUtils.getHttpRequest(key);
                HttpServletResponse response = WebUtils.getHttpResponse(key);
                log.debug("Session has been stopped (subject logout or explicit stop).  Removing session ID cookie.");
                removeSessionIdCookie(request, response);
            } else {
                log.debug("SessionKey argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. Session ID cookie will not be removed due to stopped session.");
            }
        }

最后再在springboot中做如下配置:

@Bean("sessionManager")
        public SessionManager sessionManager() {
            DefaultWebSessionManager sessionManager = new CustomerWebSessionManager();
            Collection<SessionListener> listeners = new ArrayList<SessionListener>();
            //配置监听
            listeners.add(sessionListener());
            sessionManager.setSessionListeners(listeners);
    
            Cookie sessionIdCookie = sessionManager.getSessionIdCookie();
            sessionIdCookie.setName("sid");
            sessionManager.setGlobalSessionTimeout(EXPIRE_SECOND * 1000); // 超时时间
            sessionManager.setDeleteInvalidSessions(true);
            sessionManager.setSessionIdCookie(sessionIdCookie);
            sessionManager.setSessionDAO(sessionDAO());
            sessionManager.setCacheManager(cacheManager());
    
            //全局会话超时时间（单位毫秒），默认30分钟  暂时设置为10秒钟 用来测试
            sessionManager.setGlobalSessionTimeout(EXPIRE_SECOND * 1000);
            //是否开启删除无效的session对象  默认为true
            sessionManager.setDeleteInvalidSessions(true);
            //是否开启定时调度器进行检测过期session 默认为true
            sessionManager.setSessionValidationSchedulerEnabled(true);
            //设置session失效的扫描时间, 清理用户直接关闭浏览器造成的孤立会话 默认为 1个小时
            //设置该属性 就不需要设置 ExecutorServiceSessionValidationScheduler 底层也是默认自动调用ExecutorServiceSessionValidationScheduler
            sessionManager.setSessionValidationInterval(600000);
            //取消url 后面的 JSESSIONID
            sessionManager.setSessionIdUrlRewritingEnabled(false);
            return sessionManager;
        }

我们使用PostMain测试下：

![WX20211016-171120@2x][WX20211016-171120_2x]

WX20211016-171120@2x

我们使用token测试下能否通过验证：

![WX20211016-171425@2x][WX20211016-171425_2x]

WX20211016-171425@2x

可以看到验证通过。使用错误的token验证下：

![WX20211016-171530@2x][WX20211016-171530_2x]

WX20211016-171530@2x

我们将token的最后一位2改成3后，验证失败。需要重新登陆。

自此我们改造完成。附上完整代码：

/**
     * 兼容 token 和 cookie
     *
     * @Author julyWhj
     * @Description $
     * @Date 2021/10/16 3:13 下午
     **/
    @Slf4j
    public class CustomerWebSessionManager extends DefaultWebSessionManager {
        private static final String AUTH_TOKEN = "token";
        private static final String DEVICE = "device";
        private static final String MOBILE = "mobile";
    
        public CustomerWebSessionManager() {
            super();
        }
    
        /**
         * 重写父类获取sessionID的方法,若请求为APP或者H5则从请求头中取出token
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return id
         */
        @Override
        protected Serializable getSessionId(ServletRequest request, ServletResponse response) {
            if (!(request instanceof HttpServletRequest)) {
                log.debug("Current request is not an HttpServletRequest - cannot get session ID.  Returning null.");
                return null;
            }
            HttpServletRequest httpRequest = WebUtils.toHttp(request);
            if (StringUtils.hasText(httpRequest.getHeader(AUTH_TOKEN))) {
                //从header中获取token
                String token = httpRequest.getHeader(AUTH_TOKEN);
                // 每次读取之后都把当前的token放入response中
                HttpServletResponse httpResponse = WebUtils.toHttp(response);
                if (StringUtils.hasText(token)) {
                    httpResponse.setHeader(AUTH_TOKEN, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE, "header");
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, token);
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
                }
                //sessionIdUrlRewritingEnabled的配置为false,不会在url的后面带上sessionID
                request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
                return token;
            }
            return getReferencedSessionId(request, response);
        }
    
        /**
         * shiro默认从cookie中获取sessionId
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return
         */
        private Serializable getReferencedSessionId(ServletRequest request, ServletResponse response) {
            String id = getSessionIdCookieValue(request, response);
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                        ShiroHttpServletRequest.COOKIE_SESSION_ID_SOURCE);
            } else {
                //not in a cookie, or cookie is disabled - try the request URI as a fallback (i.e. due to URL rewriting):
                //try the URI path segment parameters first:
                id = getUriPathSegmentParamValue(request, ShiroHttpSession.DEFAULT_SESSION_ID_NAME);
                if (id == null) {
                    //not a URI path segment parameter, try the query parameters:
                    String name = getSessionIdName();
                    id = request.getParameter(name);
                    if (id == null) {
                        //try lowercase:
                        id = request.getParameter(name.toLowerCase());
                    }
                }
                if (id != null) {
                    request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE,
                            ShiroHttpServletRequest.URL_SESSION_ID_SOURCE);
                }
            }
            if (id != null) {
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID, id);
                //automatically mark it valid here.  If it is invalid, the
                //onUnknownSession method below will be invoked and we'll remove the attribute at that time.
                request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID, Boolean.TRUE);
            }
            // always set rewrite flag - SHIRO-361
            request.setAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED, isSessionIdUrlRewritingEnabled());
            return id;
        }
    
        /**
         * copy from DefaultWebSessionManager
         *
         * @param request  请求参数
         * @param response 响应参数
         * @return
         */
        private String getSessionIdCookieValue(ServletRequest request, ServletResponse response) {
            if (!isSessionIdCookieEnabled()) {
                log.debug("Session ID cookie is disabled - session id will not be acquired from a request cookie.");
                return null;
            }
            if (!(request instanceof HttpServletRequest)) {
                log.debug("Current request is not an HttpServletRequest - cannot get session ID cookie.  Returning null.");
                return null;
            }
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            return getSessionIdCookie().readValue(httpRequest, WebUtils.toHttp(response));
        }
    
        private String getUriPathSegmentParamValue(ServletRequest servletRequest, String paramName) {
            if (!(servletRequest instanceof HttpServletRequest)) {
                return null;
            }
            HttpServletRequest request = (HttpServletRequest) servletRequest;
            String uri = request.getRequestURI();
            if (uri == null) {
                return null;
            }
            int queryStartIndex = uri.indexOf('?');
            if (queryStartIndex >= 0) {
                uri = uri.substring(0, queryStartIndex);
            }
            int index = uri.indexOf(';');
            if (index < 0) {
                //no path segment params - return:
                return null;
            }
            //there are path segment params, let's get the last one that may exist:
            final String TOKEN = paramName + "=";
            uri = uri.substring(index + 1);
            //we only care about the last JSESSIONID param:
            index = uri.lastIndexOf(TOKEN);
            if (index < 0) {
                //no segment param:
                return null;
            }
            uri = uri.substring(index + TOKEN.length());
            index = uri.indexOf(';');
            if (index >= 0) {
                uri = uri.substring(0, index);
            }
            return uri;
        }
    
        private String getSessionIdName() {
            String name = this.getSessionIdCookie() != null ? this.getSessionIdCookie().getName() : null;
            if (name == null) {
                name = ShiroHttpSession.DEFAULT_SESSION_ID_NAME;
            }
            return name;
        }
    
    
        /**
         * 存储会话id到response header中
         *
         * @param currentId 会话ID
         * @param request   HttpServletRequest
         * @param response  HttpServletResponse
         */
        private void storeSessionId(Serializable currentId, HttpServletRequest request, HttpServletResponse response) {
            if (currentId == null) {
                String msg = "sessionId cannot be null when persisting for subsequent requests.";
                throw new IllegalArgumentException(msg);
            }
            String idString = currentId.toString();
            //增加判断，如果请求头中包含DEVICE=MOBILE，则将sessionId放在header中返回
            if (StringUtils.hasText(request.getHeader(DEVICE)) && MOBILE.equals(request.getHeader(DEVICE))) {
                response.setHeader(AUTH_TOKEN, idString);
            } else {
                Cookie template = getSessionIdCookie();
                Cookie cookie = new SimpleCookie(template);
                cookie.setValue(idString);
                cookie.saveTo(request, response);
            }
            log.trace("Set session ID cookie for session with id {}", idString);
        }
    
        /**
         * 设置deleteMe到response header中
         *
         * @param request  request
         * @param response HttpServletResponse
         */
        private void removeSessionIdCookie(HttpServletRequest request, HttpServletResponse response) {
            if (StringUtils.hasText(request.getHeader(AUTH_TOKEN))) {
                response.setHeader(AUTH_TOKEN, Cookie.DELETED_COOKIE_VALUE);
            } else {
                getSessionIdCookie().removeFrom(request, response);
            }
        }
    
        /**
         * 会话创建
         * Stores the Session's ID, usually as a Cookie, to associate with future requests.
         *
         * @param session the session that was just {@link #createSession created}.
         */
        @Override
        protected void onStart(Session session, SessionContext context) {
            super.onStart(session, context);
            if (!WebUtils.isHttp(context)) {
                log.debug("SessionContext argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. No session ID cookie will be set.");
                return;
            }
            HttpServletRequest request = WebUtils.getHttpRequest(context);
            HttpServletResponse response = WebUtils.getHttpResponse(context);
            if (isSessionIdCookieEnabled()) {
                Serializable sessionId = session.getId();
                storeSessionId(sessionId, request, response);
            } else {
                log.debug("Session ID cookie is disabled.  No cookie has been set for new session with id {}", session.getId());
            }
            request.removeAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_SOURCE);
            request.setAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_IS_NEW, Boolean.TRUE);
        }
    
        /**
         * 会话失效
         *
         * @param s   Session
         * @param ese ExpiredSessionException
         * @param key SessionKey
         */
        @Override
        protected void onExpiration(Session s, ExpiredSessionException ese, SessionKey key) {
            super.onExpiration(s, ese, key);
            onInvalidation(key);
        }
    
        @Override
        protected void onInvalidation(Session session, InvalidSessionException ise, SessionKey key) {
            super.onInvalidation(session, ise, key);
            onInvalidation(key);
        }
    
        private void onInvalidation(SessionKey key) {
            ServletRequest request = WebUtils.getRequest(key);
            if (request != null) {
                request.removeAttribute(ShiroHttpServletRequest.REFERENCED_SESSION_ID_IS_VALID);
            }
            if (WebUtils.isHttp(key)) {
                log.debug("Referenced session was invalid.  Removing session ID cookie.");
                removeSessionIdCookie(WebUtils.getHttpRequest(key), WebUtils.getHttpResponse(key));
            } else {
                log.debug("SessionKey argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. Session ID cookie will not be removed due to invalidated session.");
            }
        }
    
        /**
         * 会话销毁
         *
         * @param session Session
         * @param key     SessionKey
         */
        @Override
        protected void onStop(Session session, SessionKey key) {
            super.onStop(session, key);
            if (WebUtils.isHttp(key)) {
                HttpServletRequest request = WebUtils.getHttpRequest(key);
                HttpServletResponse response = WebUtils.getHttpResponse(key);
                log.debug("Session has been stopped (subject logout or explicit stop).  Removing session ID cookie.");
                removeSessionIdCookie(request, response);
            } else {
                log.debug("SessionKey argument is not HTTP compatible or does not have an HTTP request/response " +
                        "pair. Session ID cookie will not be removed due to stopped session.");
            }
        }
    }

[WX20211016-171120_2x]: /images/20220828/2553c28b7cc94231bf4e3cbb6ec332d8.png
[WX20211016-171425_2x]: /images/20220828/da6012fa42cd4b11b1137456272a5ca6.png
[WX20211016-171530_2x]: /images/20220828/892c790cd484439087180f5f436fea09.png