WebSocket心跳机制

秒速五厘米 2024-04-08 11:29 124阅读 0赞

#### 目录 ####

*  1 WebSocket简介
 *  2 WebSocket事件与方法
 *   *  2.1 创建WebSocket实例
     *  2.2 WebSocket 事件
     *  2.3 WebSocket 方法
 *  3 WebSocket的心跳重连机制
 *   *  3.1 问题
     *  3.2 心跳重连机制
 *  4 实际使用

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

## 1 WebSocket简介 ##

> WebSocket是HTML5开始提供的一种浏览器与服务器进行全双工通讯的网络技术，属于应用层协议。  
> WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。

前后端通信请看以下内容：  
使用WebSocket实现服务端和客户端的通信:[https://blog.csdn.net/ZGL\_cyy/article/details/117845647][https_blog.csdn.net_ZGL_cyy_article_details_117845647]  
WebSocket网页聊天室:[https://blog.csdn.net/ZGL\_cyy/article/details/118438572][https_blog.csdn.net_ZGL_cyy_article_details_118438572]  
WebSocket区分不同客户端方法:[https://blog.csdn.net/ZGL\_cyy/article/details/122838063][https_blog.csdn.net_ZGL_cyy_article_details_122838063]

## 2 WebSocket事件与方法 ##

### 2.1 创建WebSocket实例 ###

var socketObj;
        if ("WebSocket" in window) {
        
          socketObj = new WebSocket(webSocketLink);
        } else if ("MozWebSocket" in window) {
        
          socketObj = new MozWebSocket(webSocketLink);
        }

### 2.2 WebSocket 事件 ###

![img][]

### 2.3 WebSocket 方法 ###

![img][img 1]

方法.png

## 3 WebSocket的心跳重连机制 ##

### 3.1 问题 ###

（1）websocket在连接后，如果长时间服务端和客户端不发消息，服务端会把websocket给断开。  
（2）存在网络忽然断开的情况，这时服务器端并没有触发onclose的事件。服务器会继续向客户端发送多余的信息，这些数据会丢失。

### 3.2 心跳重连机制 ###

> 为了解决上面的问题，就需要⼀种机制来检测客户端和服务端是否处于正常的连接状态。因此就有了websocket的心跳机制。

⼼跳机制是客户端每隔⼀段时间会向服务端发送⼀个数据包，告诉服务端自己还活着，同时客户端会根据服务端是否会回传⼀个数据包来确定服务端是否还活着。  
如果客户端没有收到回复，表示websocket断开连接或者网络出现问题，就需要重连。

## 4 实际使用 ##

详细代码如下：

<template>
      <div></div>
    </template>
    <script>
    export default {
          
      data() {
          
        return {
          
          // websocket相关
          socketObj: "", // websocket实例对象
          //心跳检测
          heartCheck: {
          
            vueThis: this, // vue实例
            timeout: 10000, // 超时时间
            timeoutObj: null, // 计时器对象——向后端发送心跳检测
            serverTimeoutObj: null, // 计时器对象——等待后端心跳检测的回复
            // 心跳检测重置
            reset: function () {
          
              clearTimeout(this.timeoutObj);
              clearTimeout(this.serverTimeoutObj);
              return this;
            },
            // 心跳检测启动
            start: function () {
          
              this.timeoutObj && clearTimeout(this.timeoutObj);
              this.serverTimeoutObj && clearTimeout(this.serverTimeoutObj);
              this.timeoutObj = setTimeout(() => {
          
                // 这里向后端发送一个心跳检测，后端收到后，会返回一个心跳回复
                this.vueThis.socketObj.send("HeartBeat");
                console.log("发送心跳检测");
                this.serverTimeoutObj = setTimeout(() => {
          
                  // 如果超过一定时间还没重置计时器，说明websocket与后端断开了
                  console.log("未收到心跳检测回复");
                  // 关闭WebSocket
                  this.vueThis.socketObj.close();
                }, this.timeout);
              }, this.timeout);
            },
          },
          socketReconnectTimer: null, // 计时器对象——重连
          socketReconnectLock: false, // WebSocket重连的锁
          socketLeaveFlag: false, // 离开标记（解决 退出登录再登录 时出现的 多次相同推送 问题，出现的本质是多次建立了WebSocket连接）
        };
      },
      created() {
          
        console.log("离开标记", this.socketLeaveFlag);
      },
      mounted() {
          
        // websocket启动
        this.createWebSocket();
      },
      destroyed() {
          
        // 离开标记
        this.socketLeaveFlag = true;
        // 关闭WebSocket
        this.socketObj.close();
      },
      methods: {
          
        // websocket启动
        createWebSocket() {
          
          let webSocketLink = "wss://uat.sssyin.cn/ws-reservation"; // webSocket地址
          // console.log(webSocketLink);
          try {
          
            if ("WebSocket" in window) {
          
              this.socketObj = new WebSocket(webSocketLink);
            } else if ("MozWebSocket" in window) {
          
              this.socketObj = new MozWebSocket(webSocketLink);
            }
            // websocket事件绑定
            this.socketEventBind();
          } catch (e) {
          
            console.log("catch" + e);
            // websocket重连
            this.socketReconnect();
          }
        },
        // websocket事件绑定
        socketEventBind() {
          
          // 连接成功建立的回调
          this.socketObj.onopen = this.onopenCallback;
          // 连接发生错误的回调
          this.socketObj.onerror = this.onerrorCallback;
          // 连接关闭的回调
          this.socketObj.onclose = this.oncloseCallback;
          // 向后端发送数据的回调
          this.socketObj.onsend = this.onsendCallback;
          // 接收到消息的回调
          this.socketObj.onmessage = this.getMessageCallback;
    
          //监听窗口关闭事件，当窗口关闭时，主动去关闭websocket连接，防止连接还没断开就关闭窗口，server端会抛异常。
          window.onbeforeunload = () => {
          
            this.socketObj.close();
          };
        },
        // websocket重连
        socketReconnect() {
          
          if (this.socketReconnectLock) {
          
            return;
          }
          this.socketReconnectLock = true;
          this.socketReconnectTimer && clearTimeout(this.socketReconnectTimer);
          this.socketReconnectTimer = setTimeout(() => {
          
            console.log("WebSocket:重连中...");
            this.socketReconnectLock = false;
            // websocket启动
            this.createWebSocket();
          }, 4000);
        },
        // 连接成功建立的回调
        onopenCallback: function (event) {
          
          console.log("WebSocket:已连接");
          // 心跳检测重置
          this.heartCheck.reset().start();
        },
        // 连接发生错误的回调
        onerrorCallback: function (event) {
          
          console.log("WebSocket:发生错误");
          // websocket重连
          this.socketReconnect();
        },
        // 连接关闭的回调
        oncloseCallback: function (event) {
          
          console.log("WebSocket:已关闭");
          // 心跳检测重置
          this.heartCheck.reset();
          if (!this.socketLeaveFlag) {
          
            // 没有离开——重连
            // websocket重连
            this.socketReconnect();
          }
        },
        // 向后端发送数据的回调
        onsendCallback: function () {
          
          console.log("WebSocket:发送信息给后端");
        },
        // 接收到消息的回调
        getMessageCallback: function (msg) {
          
          // console.log(msg);
          console.log(msg.data);
          if (msg.data.indexOf("HeartBeat") > -1) {
          
            // 心跳回复——心跳检测重置
            // 收到心跳检测回复就说明连接正常
            console.log("收到心跳检测回复");
            // 心跳检测重置
            this.heartCheck.reset().start();
          } else {
          
            // 普通推送——正常处理
            console.log("收到推送消息");
            let data = JSON.parse(msg.data);
            // 相关处理
            console.log(data);
          }
        },
      },
    };
    </script>

[https_blog.csdn.net_ZGL_cyy_article_details_117845647]: https://blog.csdn.net/ZGL_cyy/article/details/117845647
[https_blog.csdn.net_ZGL_cyy_article_details_118438572]: https://blog.csdn.net/ZGL_cyy/article/details/118438572
[https_blog.csdn.net_ZGL_cyy_article_details_122838063]: https://blog.csdn.net/ZGL_cyy/article/details/122838063
[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a21b472e5d7b43a3b6dacbc524978278.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5d983317b047451f978fc8c7cbcbe179.png