Session会话过期后页面自动跳转到登录界面

淡淡的烟草味﹌ 2023-02-26 11:25 2阅读 0赞

本需求使用Shiro权限管理框架加WebSocket协议实现

--------------------

首先导入WebSocket jar包(已导入Shiro相关jar包，完成Shiro的相关配置，这里不过多讲，主要使用WebSocket协议实现，需要的朋友自行搜索)

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-websocket</artifactId>
            </dependency>

创建WebSocket支持类，开启WebSocket支持

package com.xxx.common.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.web.socket.server.standard.ServerEndpointExporter;
    
    @Configuration
    public class WebSocketConfig {
    
        /**
         * 开启WebSocket支持
         * @return
         */
        @Bean
        public ServerEndpointExporter serverEndpointExporter() {
            return new ServerEndpointExporter();
        }
    }

创建WebSocketServer，WebSocket类似客户端服务端形式(采用ws协议)，所以相当于一个ws协议的Controller，里面可实现一些方法，如@OnOpen,@onClose,@onMessage等方法

package com.xxx.WebSocket;
    
    
    import java.io.IOException;
    import java.util.concurrent.ConcurrentHashMap;
    import javax.websocket.OnClose;
    import javax.websocket.OnError;
    import javax.websocket.OnMessage;
    import javax.websocket.OnOpen;
    import javax.websocket.Session;
    import javax.websocket.server.PathParam;
    import javax.websocket.server.ServerEndpoint;
    
    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONObject;
    
    import com.xxx.common.utils.StringUtils;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Component;
    
    
    @ServerEndpoint("/imserver/{userId}")
    @Component
    public class WebSocketServer {
    
        static Logger log = LoggerFactory.getLogger(WebSocketServer.class);
        /**
         * 静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。
         */
        private static int onlineCount = 0;
        /**
         * concurrent包的线程安全Set，用来存放每个客户端对应的MyWebSocket对象。
         */
        private static ConcurrentHashMap<String, WebSocketServer> webSocketMap = new ConcurrentHashMap<>();
        /**
         * 与某个客户端的连接会话，需要通过它来给客户端发送数据
         */
        private Session session;
        /**
         * 接收userId
         */
        private String userId = "";
    
        /**
         * 连接建立成功调用的方法
         */
        @OnOpen
        public void onOpen(Session session, @PathParam("userId") String userId) {
            this.session = session;
            this.userId = userId;
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.remove(userId);
                webSocketMap.put(userId, this);
                //加入set中
            } else {
                webSocketMap.put(userId, this);
                //加入set中
                addOnlineCount();
                //在线数加1
            }
    
            log.info("用户连接:" + userId + ",当前在线人数为:" + getOnlineCount());
    
           /* try {
                sendMessage("连接成功");
            } catch (IOException e) {
                log.error("用户:"+userId+",网络异常!!!!!!");
            }*/
        }
    
        /**
         * 连接关闭调用的方法
         */
        @OnClose
        public void onClose() {
            if (webSocketMap.containsKey(userId)) {
                webSocketMap.remove(userId);
                //从set中删除
                subOnlineCount();
            }
            log.info("用户退出:" + userId + ",当前在线人数为:" + getOnlineCount());
        }
    
        /**
         * 收到客户端消息后调用的方法
         *
         * @param message 客户端发送过来的消息
         */
        @OnMessage
        public void onMessage(String message, Session session) {
            log.info("用户消息:" + userId + ",报文:" + message);
            //可以群发消息
            //消息保存到数据库、redis
            if (StringUtils.isNotBlank(message)) {
                try {
                    //解析发送的报文
                    JSONObject jsonObject = JSON.parseObject(message);
                    //追加发送人(防止串改)
                    jsonObject.put("fromUserId", this.userId);
                    String toUserId = jsonObject.getString("toUserId");
                    //传送给对应toUserId用户的websocket
                    if (StringUtils.isNotBlank(toUserId) && webSocketMap.containsKey(toUserId)) {
                        webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                    } else {
                        log.error("请求的userId:" + toUserId + "不在该服务器上");
                        //否则不在这个服务器上，发送到mysql或者redis
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * @param session
         * @param error
         */
        @OnError
        public void onError(Session session, Throwable error) {
            log.error("用户错误:" + this.userId + ",原因:" + error.getMessage());
            error.printStackTrace();
        }
    
        /**
         * 实现服务器主动推送
         */
        public void sendMessage(String message) throws IOException {
            this.session.getBasicRemote().sendText(message);
        }
    
    
        /**
         * 发送自定义消息
         */
        public static void sendInfo(String message, @PathParam("userId") String userId) throws IOException {
            log.info("发送消息到:" + userId + "，报文:" + message);
            if (StringUtils.isNotBlank(userId) && webSocketMap.containsKey(userId)) {
                webSocketMap.get(userId).sendMessage(message);
            } else {
                log.error("用户" + userId + ",不在线！");
            }
        }
    
        public static synchronized int getOnlineCount() {
            return onlineCount;
        }
    
        public static synchronized void addOnlineCount() {
            WebSocketServer.onlineCount++;
        }
    
        public static synchronized void subOnlineCount() {
            WebSocketServer.onlineCount--;
        }
    }

创建配置session监听类，实现SessionListener接口

package com.xxx.shiro.web.session;
    
    
    import com.xxx.WebSocket.WebSocketServer;
    import com.xxx.shiro.web.filter.LogoutFilter;
    import org.apache.shiro.SecurityUtils;
    import org.apache.shiro.session.Session;
    import org.apache.shiro.session.SessionListener;
    import org.apache.shiro.subject.SimplePrincipalCollection;
    import org.apache.shiro.subject.Subject;
    import org.apache.shiro.subject.support.DefaultSubjectContext;
    
    import javax.servlet.http.HttpSession;
    import java.io.IOException;
    import java.io.Serializable;
    
    
    /**
     * 配置session监听
     */
    public class ShiroSessionListener implements SessionListener  {
    
        /**
         * 会话创建时触发
         *
         * @param session
         */
        @Override
        public void onStart(Session session) {
    
        }
    
        /**
         * 退出会话时触发
         *
         * @param session
         */
        @Override
        public void onStop(Session session) {
    
        }
    
        /**
         * 会话过期时触发
         *
         * @param session
         */
    
        @Override
        public void onExpiration(Session session) {
            try {
                WebSocketServer.sendInfo("您长时间没有操作，请重新登录！！！",session.getId().toString());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }

在ShiroConfig权限配置加载类中的sessionManager()方法中配置监听和监听间隔时间，并创建session监听方法

package com.xxx.shiro.web.session;
    
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Date;
    import java.util.List;
    
    import com.xxx.common.constant.ShiroConstants;
    import com.xxx.common.utils.StringUtils;
    import com.xxx.common.utils.bean.BeanUtils;
    import com.xxx.common.utils.spring.SpringUtils;
    import com.xxx.shiro.session.OnlineSession;
    import org.apache.commons.lang3.time.DateUtils;
    import org.apache.shiro.session.ExpiredSessionException;
    import org.apache.shiro.session.InvalidSessionException;
    import org.apache.shiro.session.Session;
    import org.apache.shiro.session.mgt.DefaultSessionKey;
    import org.apache.shiro.session.mgt.SessionKey;
    import org.apache.shiro.web.session.mgt.DefaultWebSessionManager;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    
    /**
     * 主要是在此如果会话的属性修改了 就标识下其修改了 然后方便 OnlineSessionDao同步
     *
     * @author ruoyi
     */
    public class OnlineWebSessionManager extends DefaultWebSessionManager
    {
        private static final Logger log = LoggerFactory.getLogger(OnlineWebSessionManager.class);
    
    
        @Override
        public void setAttribute(SessionKey sessionKey, Object attributeKey, Object value) throws InvalidSessionException
        {
            super.setAttribute(sessionKey, attributeKey, value);
            if (value != null && needMarkAttributeChanged(attributeKey))
            {
                OnlineSession session = getOnlineSession(sessionKey);
                session.markAttributeChanged();
            }
        }
    
        /**
         * 验证session是否有效 用于删除过期session
         */
        @Override
        public void validateSessions()
        {
    
            if (log.isInfoEnabled())
            {
                //把日志滚掉
                //log.info("invalidation sessions...");
            }
    
            int invalidCount = 0;
    
            // 获得所有有效的Session，从其他介质中获得（如Redis）
            Collection<Session> activeSessions = getActiveSessions();
    
            if (activeSessions != null && !activeSessions.isEmpty()) {
                for (Session s : activeSessions) {
                    try {
                        SessionKey key = new DefaultSessionKey(s.getId());
                        // 执行具体的校验任务
                        validate(s, key);
                    } catch (InvalidSessionException e) {
                        if (log.isDebugEnabled()) {
                            boolean expired = (e instanceof ExpiredSessionException);
                            String msg = "Invalidated session with id [" + s.getId() + "]" +
                                    (expired ? " (expired)" : " (stopped)");
                            log.debug(msg);
                        }
                        invalidCount++;
                    }
                }
            }
    
            if (log.isInfoEnabled())
            {
                String msg = "Finished invalidation session.";
                if (invalidCount > 0)
                {
                    msg += " [" + invalidCount + "] sessions were stopped.";
                }
                else
                {
                    msg += " No sessions were stopped.";
                }
                //把日志滚掉
               // log.info(msg);
            }
    
        }
    
        private boolean needMarkAttributeChanged(Object attributeKey)
        {
            if (attributeKey == null)
            {
                return false;
            }
            String attributeKeyStr = attributeKey.toString();
            // 优化 flash属性没必要持久化
            if (attributeKeyStr.startsWith("org.springframework"))
            {
                return false;
            }
            if (attributeKeyStr.startsWith("javax.servlet"))
            {
                return false;
            }
            if (attributeKeyStr.equals(ShiroConstants.CURRENT_USERNAME))
            {
                return false;
            }
            return true;
        }
    
        public OnlineSession getOnlineSession(SessionKey sessionKey)
        {
            OnlineSession session = null;
            Object obj = doGetSession(sessionKey);
            if (StringUtils.isNotNull(obj))
            {
                session = new OnlineSession();
                BeanUtils.copyBeanProp(session, obj);
            }
            return session;
        }
    
    
    }

/**
         * 会话管理器
         */
        @Bean
        public OnlineWebSessionManager sessionManager()
        {
            OnlineWebSessionManager manager = new OnlineWebSessionManager();
    
            //配置监听
            Collection<SessionListener> listeners = new ArrayList<SessionListener>();
            listeners.add(sessionListener());
            manager.setSessionListeners(listeners);
    
            manager.setSessionIdCookieEnabled(true);
            manager.setSessionIdCookie(sessionIdCookie());
            // 自定义SessionDao
            manager.setSessionDAO(sessionDAO());
            // 自定义sessionFactory
            manager.setSessionFactory(sessionFactory());
            // 设置全局session超时时间
            manager.setGlobalSessionTimeout(expireTime * 60 * 1000);
            manager.setDeleteInvalidSessions(true);
            manager.setSessionValidationSchedulerEnabled(true);
            manager.setSessionIdUrlRewritingEnabled(false);
    
            //一分钟监听一次
            manager.setSessionValidationInterval(60 * 1000);
            return manager;
        }
    
    /**
         * 配置session监听
         *
         * @return
         */
        @Bean("sessionListener")
        public ShiroSessionListener sessionListener() {
            ShiroSessionListener sessionListener = new ShiroSessionListener();
            return sessionListener;
        }

接下来配置页面，页面发起socket请求

--------------------

总的来说，先开启WebSocket支持，配置session超时时间，设置session监听及监听间隔时间，当session超时时，触发ShiroSessionListener监听类中的onExpiration(会话过期时触发)方法，调用WebSocketServer的sendInfo方法发送消息，同时向页面发送socket请求，页面配置的socket.onmessage方法获取消息后开始处理触发跳转登录逻辑，从而实现需求。