1. 介绍

websocket 是一种服务端和客户端双向通信的方式。传统的 HTTP 通信仅能由客户端向服务端发送请求而后服务端返回数据，如果想要服务端改变数据后客户端能够接收到这种改变，客户端需要使用到轮询，不过这种方式非常浪费资源，因此 websocket 的出现能够很好的解决这一缺陷。

2. 过程

2.1 建立通信

使用 WebSocket 接口，URL 用 ws 开头，构造好请求地址后，就可以在不同的回调函数中执行操作。

• webSocket.readyState

  • readyState 属性返回实例对象的当前状态，共有四种。
    • CONNECTING: 值为0，表示正在连接。
    • OPEN: 值为1，表示连接成功，可以通信了。
    • CLOSING: 值为2，表示连接正在关闭。
    • CLOSED: 值为3，表示连接已经关闭，或者打开连接失败。

• webSocket.onopen

  • 用于指定连接成功的回调函数。如果要指定多个回调函数，可以使用 addEventListener 方法。

• webSocket.onmessage

  • 用于指定收到服务器数据后的回调函数。服务器数据可能是文本，也可能是二进制数据（blob 对象或 Arraybuffer 对象），除了动态判断收到的数据类型，也可以使用 binaryType 属性，显示指定收到的二进制数据类型。

    ws.onmessage = function(event){
      if(typeof event.data === String) {
        console.log("Received data string");
      }
    
      if(event.data instanceof ArrayBuffer){
        var buffer = event.data;
        console.log("Received arraybuffer");
      }
    }
    
    // 收到的是 blob 数据
    ws.binaryType = "blob";
    ws.onmessage = function(e) {
      console.log(e.data.size);
    };
    
    // 收到的是 ArrayBuffer 数据
    ws.binaryType = "arraybuffer";
    ws.onmessage = function(e) {
      console.log(e.data.byteLength);
    };
    

• webSocket.onerror

  • 用于指定报错时的回调函数。

• webSocket.onclose

  • 用于指定连接关闭后的回调函数。

• webSocket.send

  • 用于向服务器发送数据。可以发送文本、Blob 对象以及 ArrayBuffer 对象。

    ws.send('your message')
    
    var file = document
      .querySelector('input[type="file"]')
      .files[0]
    ws.send(file)
    
    // Sending canvas ImageData as ArrayBuffer
    var img = canvas_context.getImageData(0, 0, 400, 320);
    var binary = new Uint8Array(img.data.length);
    for (var i = 0; i < img.data.length; i++) {
      binary[i] = img.data[i];
    }
    ws.send(binary.buffer);
    
    

• webSocket.bufferedAmount

  • 表示还有多少字节的二进制数据没有发送出去。它可以用来判断发送是否结束。

    var data = new ArrayBuffer(10000000);
    socket.send(data);
    
    if (socket.bufferedAmount === 0) {
      // 发送完毕
    } else {
      // 发送还没结束
    }
    

2.2 心跳机制

WebSocket 是前后端交互的长连接，前后端都有可能因为一些情况导致连接失效并且相互之间没有反应，因此为了保证连接的可持续性和稳定性，WebSocket 心跳机制应运而生。

为了解决上述问题，以前端作为主动方，定时发送 ping 消息，用于检测网络和前后端连接问题。一旦发现异常，前端持续执行重连逻辑，直到重连成功。

具体代码过程：

import store from '../store/index.js'
import router from '../router'
import { cacheToken } from '@utils/cache'

let socket = null
let pingTimer = null

const URL = store.getters.WS_URL

/**
 * 建立websocket连接
 */
export const createSocket = () => {
  const token = cacheToken.get()
  if (!token) {
    return
  }

  const wsUrl = `${URL}?` + token
  socket = new WebSocket(wsUrl)
  socket.onopen = onopenWS
  socket.onmessage = onmessageWS
  socket.onerror = onerrorWS
  socket.onclose = oncloseWS
}

/**
 * 断开webSocket链接
 */
export const logout = () => {
  closeSocket()
}

/**
 * 发送数据
 * @param {any} message 需要发送的数据
 */
export const sendMessage = message => {
  if (socket) {
    socket.send(JSON.stringify(message))
  }
}

const closeSocket = () => {
  closePingTimer()
  if (socket !== null) {
    socket.close()
  }
  socket = null
}

const onopenWS = () => {
  // ignore
}

// /**WS数据接收统一处理 */
const onmessageWS = e => {
  const result = JSON.parse(e.data)
  if (result.msgCode === 4) {
    // 消息统计
    // 保存数据
  } else if (result.msgCode === 1) {
    responseLoginMessage(result.cmdSign)
  }
}

const responseLoginMessage = cmdSign => {
  if (cmdSign === 1) {
    startPingTimer()
  } else {
    closeSocket()

    // 返回登录页面
    router.push('/login')
    cacheToken.remove()
  }
}
// /**链接错误 */
const onerrorWS = event => {
  // ignore
}

// /**关闭WS,重新连接 */
const oncloseWS = () => {
  closePingTimer()
}

/**
 * 发送心跳
 * @param {number} time 心跳间隔毫秒 默认 30s
 * @param {string} Ping 心跳名称 使用 new Ping()
 */
const startPingTimer = (time = 30 * 1000) => {
  closePingTimer()
  if (!pingTimer) {
    pingTimer = setInterval(() => {
      sendMessage(new Ping())
    }, time)
  }
}

const closePingTimer = () => {
  if (pingTimer !== null) {
    clearInterval(pingTimer)
    pingTimer = null
  }
}

class Ping {
  constructor() {
    this.id = -1
    this.msgCode = 3
    this.cmdSign = 2
  }
}