websocket 心跳连接

最新推荐文章于 2024-08-27 21:10:10 发布
最新推荐文章于 2024-08-27 21:10:10 发布
阅读量652 收藏
点赞数
分类专栏： java
原文链接：https://blog.csdn.net/jiangyou4/article/details/53586305
版权

原文链接：https://blog.csdn.net/jiangyou4/article/details/53586305

websocket连接时，如果长时间没有进行数据的通讯就会自动断开连接。为了不让其断开就在要断开的时候自动发送数据进行通讯，就产生了心跳连接的效果。

具体的操作就是在客户端建立连接的时候开启发送心跳信息的线程，之后再每次收到信息之后就线程重启。服务端在处理数据的时候多处理一下心跳信息，将其发给连接的用户，从而实现心跳通讯。

服务端代码

@ServerEndpoint("/video")
public class AcgistVideo {
    //连接超时
    public static final long MAX_TIME_OUT = 2 * 60 * 1000;
    //房间和房间对应的用户列表
    public static Map<String, ArrayList<String>> room_user = Collections.synchronizedMap(new HashMap<String, ArrayList<String>>());
    //用户的sid和用户的session一一对应
    public static Map<String, Session> user_session = Collections.synchronizedMap(new HashMap<String, Session>());
    //用户的sid和房间一一对应
    public static Map<String, String> userInRoom = Collections.synchronizedMap(new HashMap<String, String>());
    public static Logger log = LoggerFactory.getLogger(AcgistVideo.class);
 
    /**
     * 打开websocket
     *
     * @param session websocket的session
     * @param uid     打开用户的UID
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("uid") String uid) throws IOException {
        log.info("--------------------onOpen--------------------");
        session.setMaxIdleTimeout(MAX_TIME_OUT);
    }
    /**
     * 收到消息
     *
     * @param message 消息内容
     * @param session 发送消息的session
     */
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("接收到来自客户端--" + session.getId() + "--的信息：" + message);
        JSONObject json = JSONObject.fromObject(message);
 
        if (json.get("type").equals("create")) {
            ArrayList arrayList = new ArrayList();
            arrayList.add(session.getId());
 
            String roomId = createRoom();
            room_user.put(roomId, arrayList);
            userInRoom.put(session.getId(), roomId);
            user_session.put(session.getId(), session);
 
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "create");
            jsonstr.put("room", roomId);
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(roomId));
            sendMessage(jsonstr.toString(), session);
 
        } else if (json.get("type").equals("apply")) {
            String roomId = "";
            if (json.has("room")) {
                roomId = json.getString("room");
            }
 
            if (!("".equals(roomId)) && null != room_user.get(roomId)) {
                ArrayList<String> arrayList = room_user.get(roomId);
                arrayList.add(session.getId());
                room_user.put(roomId, arrayList);
                userInRoom.put(session.getId(), roomId);
                user_session.put(session.getId(), session);
 
                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "apply");
                jsonstr.put("room", roomId);
                jsonstr.put("sid", session.getId());
                jsonstr.put("count", getUserNumberByRoom(roomId));
 
                sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
            } else {
                ArrayList arrayList = new ArrayList();
                arrayList.add(session.getId());
 
                roomId = createRoom();
                room_user.put(roomId, arrayList);
                userInRoom.put(session.getId(), roomId);
                user_session.put(session.getId(), session);
 
                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "create");
                jsonstr.put("room", roomId);
                jsonstr.put("sid", session.getId());
                jsonstr.put("count", getUserNumberByRoom(roomId));
                sendMessage(jsonstr.toString(), session);
            }
        } else if (json.get("type").equals("receipt")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "receipt");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("link")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "link");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("offer")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "offer");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("offer", json.get("offer"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("answer")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "answer");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("answer", json.get("answer"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("candidate")) {
            Session oession = user_session.get(json.get("sid"));
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "candidate");
            jsonstr.put("room", json.get("room"));
            jsonstr.put("sid", session.getId());
            jsonstr.put("count", getUserNumberByRoom(userInRoom.get(session.getId())));
            jsonstr.put("candidate", json.get("candidate"));
            sendMessage(jsonstr.toString(), oession);
        } else if (json.get("type").equals("bye")) {
            remove(session);
        } else if (json.get("type").equals("beat")) {
            JSONObject jsonstr = new JSONObject();
            jsonstr.put("type", "beat");
            jsonstr.put("msg", json.get("msg"));
            jsonstr.put("sid", session.getId());
            sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
        }
    }
    /**
     * websocket错误
     *
     * @param e
     * @param session
     */
    @OnError
    public void onError(Throwable e, Session session) {
        log.info("--------------------onError--------------------");
        log.info("session ID: --" + session.getId() + " --离开了");
        log.error("--", e);
        log.info("----------------------------------------");
    }
    /**
     * websocket关闭
     *
     * @param session 关闭的session
     */
    @OnClose
    public void onClose(Session session) {
        log.info("--------------------onClose--------------------");
        remove(session);
    }
    /**
     *    * 随机生成UUID
     *    * @return
     *    
     */
    public static synchronized String getUUID() {
        log.info("--------------------getUUID--------------------");
        UUID uuid = UUID.randomUUID();
        String str = uuid.toString();
        String uuidStr = str.replace("-", "");
        return uuidStr;
    }
    /**
     * 通过房间号获取房间中的用户数量
     *
     * @param roomId 房间号
     * @return 房间中的用户数量 如果只为-1则房间不存在
     */
    public int getUserNumberByRoom(String roomId) {
        log.info("--------------------getUserNumberByRoom--------------------");
        if (room_user.containsKey("roomId")) {
            ArrayList<String> userList = room_user.get(roomId);
            return userList.size();
        } else {
            return -1;
        }
    }
    /**
     * 发送信息
     *
     * @param message 发送内容
     * @param session 用户session
     */
    public void sendMessage(String message, Session session) {
        log.info("--------------------sendMessage--------------------");
        try {
            log.info("发送消息到客户端--" + session.getId() + "--信息为：" + message);
            synchronized (session) {
                if (session.isOpen()) {
                    session.getBasicRemote().sendText(message);
                }
            }
        } catch (Exception e) {
            log.error("send message exception", e);
        }
    }
    /**
     * 创建房间
     *
     * @return 房间ID
     */
    public String createRoom() {
        log.info("--------------------createRoom--------------------");
        String roomId = getUUID();
        return roomId;
    }
    /**
     * 移除聊天用户
     *
     * @param session 移除的session
     */
    private void remove(Session session) {
        log.info("--------------------remove--------------------");
 
        String roomId = userInRoom.get(session.getId());
        ArrayList<String> arrayList = room_user.get(roomId);
 
        if (arrayList.contains(session.getId())) {
            log.info("移除SID：" + session.getId());
            arrayList.remove(session.getId());
            if (arrayList.size() < 1) {
                log.info("移除房间：" + roomId);
                room_user.remove(roomId);
            } else {
                room_user.put(roomId, arrayList);
 
                //用户退出的时候给房间中的每一位用户发一条信息
                JSONObject jsonstr = new JSONObject();
                jsonstr.put("type", "bye");
                jsonstr.put("sid", session.getId());
                sendMessageToUserInSameRoom(session.getId(), jsonstr, false);
            }
            userInRoom.remove(session.getId());
            user_session.remove(session.getId());
        }
    }
    /**
     * 给用户所在房间中的每一位用户发一条信息
     *
     * @param selfId     用户Id
     * @param jsonstr    需要发的信息
     * @param isSendSelf 是否发给自己
     */
    private void sendMessageToUserInSameRoom(String selfId, JSONObject jsonstr, boolean isSendSelf) {
        String roomId = userInRoom.get(selfId);
        ArrayList<String> arrayList = room_user.get(roomId);
 
        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).equals(selfId)) {
                if (isSendSelf) {
                    sendMessage(jsonstr.toString(), user_session.get(arrayList.get(i)));
                }
            } else {
                sendMessage(jsonstr.toString(), user_session.get(arrayList.get(i)));
            }
        }
    }
}

 


客户端代码

var MyWebSocket = function (obj) {
    var _this = this;
    this.timeout = 30 * 1000;
    this.timeoutObj = null;
    this.socket = null;
    this.initSocket = function () {
        this.socket = new WebSocket(GLOBAL.getConstant("WEB_SOCKET_URL"));
 
        this.socket.onopen = function () {
            console.log("websocket-----> Opened");
            _this.start();
        };
 
        this.socket.onmessage = this.socketMessage;
 
        this.socket.onclose = function () {
            console.log("websocket-----> Closed");
            obj.closeWebSocket();
        };
 
        this.socket.onerror = function () {
            console.log("websocket-----> Error:" + JSON.stringify(event));
        };
 
        console.log("-------websocket初始化完成执行回调函数-------");
        obj.initWebRtc(obj.entitys);
    }
    //接收到服务器的回复
    this.socketMessage = function (message) {
        console.log("websocket-----> Message:" + message.data);
        _this.reset();
        obj.SocketCallBack(message.data);
    }
    //向服务器发送信息
    this.sendMessage = function (message, callback) {
        this.waitForConnection(function () {
            var msgJson = JSON.stringify(message);
            this.socket.send(msgJson);
            console.log("websocket-----> SendMessage:" + msgJson);
            if (typeof callback !== 'undefined') {
                callback();
            }
        }, 1000);
    };
    this.waitForConnection = function (callback, interval) {
        if (this.socket.readyState === 1) {
            callback();
        } else {
            var that = this;
            setTimeout(function () {
                that.waitForConnection(callback, interval);
            }, interval);
        }
    };
    this.onClose = function () {
        this.socket.close();
    }
    this.start = function () {
        _this.timeoutObj = setTimeout(function () {
            var heartbeat = {
                type: "beat",
                msg: "HeartBeat"
            };
            _this.socket.send(JSON.stringify(heartbeat));
        }, _this.timeout)
    };
    this.reset = function () {
        clearTimeout(this.timeoutObj);
        _this.start();
    };
 
    this.initSocket();
 
    return this;
}

Torch_Life
关注
专栏目录
c# websocket 心跳重连_初探和实现websocket心跳重连(npm: websocket-heartbeat-js)
weixin_39729784的博客
12-21 443
提示：文章最下方有仓库地址心跳重连缘由websocket是前后端交互的长连接，前后端也都可能因为一些情况导致连接失效并且相互之间没有反馈提醒。因此为了保证连接的可持续性和稳定性，websocket心跳重连就应运而生。在使用原生websocket的时候，如果设备网络断开，不会立刻触发websocket的任何事件，前端也就无法得知当前连接是否已经断开。这个时候如果调用websocket.send方法，...
python websocket 心跳_Python WebSocket长连接心跳与短连接
weixin_29204205的博客
12-23 675
python websocket安装pip install websocket-client先来看一下，长连接调用方式：ws = websocket.WebSocketApp("ws://echo.websocket.org/", on_message=on_message, on_error=on_error, on_close=on_close) ws.on_open=on_open ws.r...
小程序 websocket连接
旸君颜的博客
07-31 5099
 最近小程序用到了长连接事件，所以封装了一套基本的socket连接 其中有几点需要注意 1、必须要有心跳，如果没有会自动断开连接。 2‘、断开后必须取消setTimeout，不然会继续执行一次。 3、发送消息只有在onSocketOpen后才会发送，所以添加一个消息数组，等连接成功后再发送。 4、如果在还没连接成功时退出连接，会导致无法关闭，所以添加了socketClose来关闭sock...
解决 JS WebSocket 心跳检测 重连
最新发布
qq_34419312的博客
08-27 4899
解决 JS WebSocket 心跳检测 重连
websocket心跳
Chihirozy的博客
07-11 516
【代码】websocket心跳。
TCP长连接与短连接、心跳机制
热门推荐
pmt123456的博客
02-27 3万+
转自： 1. TCP连接 当网络通信时采用TCP协议时，在真正的读写操作之前，server与client之间必须建立一个连接，当读写操作完成后，双方不再需要这个连接时它们可以释放这个连接，连接的建立是需要三次握手的，而释放则需要4次握手，所以说每个连接的建立都是需要资源消耗和时间消耗的 经典的三次握手示意图： 经典的四次握手关闭图： 2. TCP短连接
web服务心跳连接
08-17
服务器短时间关闭，不用重启服务
详解微信小程序实现WebSocket心跳重连
10-18
总的来说，微信小程序中的WebSocket心跳重连机制是通过定期发送心跳包和监听连接状态来确保稳定的通信。当心跳包没有收到响应或者连接被异常关闭时，系统会自动尝试重新建立连接，从而提高了服务的可用性和用户体验...
Python WebSocket长连接心跳与短连接的示例
01-19
ws = websocket.WebSocketApp(ws://echo.websocket.org/, on_message = on_message, on_error = on_error, on_close = on_close) ws.on_open = on_open ws.run_forever()  长连接，参数介绍： （1）url: ...
LINUX C网络编程中的心跳机制
wdt3385的专栏
08-03 1666
在TCP网络通信中，经常会出现客户端和服务器之间的非正常断开，需要实时检测查询链接状态。常用的解决方法就是在程序中加入心跳机制。 从网络上找到，主要有以下方法实现TCP异常断开的检测： SO_KEEPALIVE,SIO_KEEPALIVE_VALS和Heart-Beat线程。 (1)SO_KEEPALIVE 机制        这是socket库提供的功能，设置接口是setsockopt
c#心跳连接
weixin_38157505的博客
12-12 1447
网上一个大佬说的，心跳连接是为了保活，大概思路是持续的向服务端发送心跳包，如果一段时间没收到回应则判定下线，但是实际测试过程中发现，这样的思路根本就不可靠，因为socket很多方法是阻塞式的，而且如果一旦连接断开，接收或者发送都会发生异常，有了异常捕捉就很容易判断是不是下线了，根本没必要那么复杂：（反正.net是这样） TIPS： 1，socket建立的连接，此时如果服务端意外断开，socket还在维护中，必须要用networkstream.read或者write一次才可以得到socket正确状态 2，
websocket连接及心跳检测
Kevin李宏飞的博客
02-09 3934
websocket连接及心跳检测
websocket实现自动链接、心跳
liangshufeng的博客
02-27 236
【代码】websocket实现自动链接、心跳。
WebSocket心跳机制/服务器端开连接（JS前端）
qq_17627195的博客
05-19 6710
代码参考了：https://blog.csdn.net/cai4561/article/details/106809244。后端收到以后需要给前端返回数据，否则还是无法保持连接。的时候，后端长时间没有推送数据，导致。连接经常断开，后端也会报错。让前端和后端始终保持连接。
websocket心跳链接代码_websocket实现心跳连接
weixin_39984578的博客
12-22 416
在使用websocket的时候，遇到了一个websocket在连接一段时间就异常断开连接了。第一想法就是重新去连接websocket(websock.onopen)，后来发现这种方式是错误的，查阅文档发现，要想重新建立连接，就需要一种心跳思想去处理(实时监听连接情况，断了就去重连)下面以Vue代码为准：let lockReconnect = false;//避免重复连接let wsUrl = '‘...
websocket心跳应用
anribras的专栏
02-02 681
websocket 稳定push设计方案 User story 1000台客户端同时在线, 突然发现bug, 导致大面积瘫痪, server使用websocket做更新推送. 版本紧急修复后,上线实现步骤: 修复版本 admin 登录portal 上传当前补丁信息, 设置发布条件: push时间, 车机id, 地理限制, 人数限制, push频率…等等. 设置完成后, 页面显示push目标人数...
websocket
xiaomomo19的博客
04-02 2065
之所以需要 Pong 响应机制，是因为在 WebSocket 连接客户端和服务端之间发送数据时，底层的网络传输有可能会发生数据包丢失或延迟的情况，这可能导致客户端发送的 Ping 数据包无法成功送达服务端。Pong 响应机制可以通过检查服务端返回的 Pong 数据包，判断服务端是否正常连接。如果客户端在指定时间内未接收到服务端返回的 Pong 数据包，则可以判断连接已断开，从而执行相应的重连操作，从而保证 WebSocket 连接的稳定性和可靠性，并防止因连接长时间闲置而被服务端断开的情况发生。
Swoole 实践篇之结合 WebSocket 实现心跳检测机制
A码农先森的专栏
04-22 884
这里实现的心跳检测机制是一个基础版的，心跳包的主要作用是用于检测用户端是否存活，有助于我们及时判断用户端是否存在断线的问题。在我之前开发过的项目中，有一个基于物联网在线直播抓娃娃的项目，其中就有需要实时监控设备在线状态的需求，该需求就是使用心跳包来实现的。实际上心跳检测技术，应用更广泛的是实时通信、或设备管理的场景偏多。
websocket 心跳
05-01
因此，为了保持WebSocket连接的稳定，需要实现WebSocket心跳机制。 WebSocket心跳是指定期向服务器发送心跳包以保持连接稳定的机制。客户端向服务器定期发送心跳消息，而服务器则通过接收和返回心跳包来判断客户端...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值