精华内容
下载资源
问答
  • socket.onclose = function(e) { clearInterval(ping) console.log('websocket 断开: ' + e.code + ' ' + e.reason + ' ' + e.wasClean) reconnect(url) } socket.onerror = function() { clearInterval(ping) ...
    var ping;
    var dataCallBack = null;
    var socket_sessionid = null;
    var temporaryData = [];
    var socket;
    var url;
    var timeout
    
    function sendMessage(data) {
      // temporaryData = data //临时存下,防止丢失,断线重连时可以重发一次
      // try {
        // console.log(data)
        socket.send(data);
        // console.log("心跳成功", data)
      // } catch (e) {
      //   clearInterval(ping)
      //   reconnect(url)
      // }
    }
    
    function reconnect(url) {
      clearInterval(timeout)
      timeout = setTimeout(function() { //没连接上会一直重连,设置延迟避免请求过多
        console.log("重连开始")
        initSocket(dataCallBack, socket_sessionid);
      }, 1000);
    }
    
    
    function initSocket(callback, sessionid) {
      dataCallBack = callback;
      var url = requestIM() + '/ws?uid=' + sessionid;
      socket_sessionid = sessionid;
      console.log(url)
      socket = new WebSocket(url);
      socket.onopen = function() {
        console.log("websocket is connected");
        ping = setInterval(function() {
          sendMessage(socket, '{"type":"ping"}');
        }, 1000 * 10)
        clearInterval(timeout)
      };
      socket.onmessage = function(res) {
        let data = JSON.parse(res.data);
        // console.log("发送成功提示:", data)
        if ("message_history" in data && !data.system) {
          if (data.message_history != null) {
            if (data.message_history.length > 0) {
              dataCallBack(data.message_history, "old");
            }
          }
        } else if (!data.system) {
          dataCallBack(data);
        } else {
          // console.log("初始数据:", data)
          // console.log("初始数据2:", data.message_history.offline_count)
          if (data.message_history.offline_count > 0) {
            // console.log("离线信息")
            dataCallBack(data);
          }
          // for (let item in data.message_history.offline_message) {
          //   for (let it of data.message_history.offline_message[item]) {
          //     dataCallBack("test?",it);
          //   }
          // }
        }
      };
      socket.onclose = function(e) {
        clearInterval(ping)
        console.log('websocket 断开: ' + e.code + ' ' + e.reason + ' ' + e.wasClean)
        reconnect(url)
    
      }
      socket.onerror = function() {
        clearInterval(ping)
        reconnect(url)
        console.log("llws连接错误!");
    
      };
    }
    export {
      sendMessage,
      initSocket
    };
    
    

    发送信息:

          let data = {
            type: "chatMessage",
            data: {
              mine: {
                id: forstring(this.storeJson.merchant_id), //100010
                name: this.storeJson.shopname + "Chat Now",
                head: "https://app.maoxiaoqi.com/v2/static/images/serverer.png",
                time: getNowTime(),
                content: text
              },
              to: {
                id: this.activeID //0.100010xxxx
              }
            }
          };
          this.socketApi.sendMessage(forstring(data));
    

    接收websocket 的返回:
    注:写 定时 是为了保证initSocket 100%初始连接能成功!

        let timer = setInterval(function() {
          // console.log('1233', that.storeJson.merchant_id);
          // console.log('text2',headInfo)
          if (that.storeJson.merchant_id) {
            that.socketApi.initSocket(that.showSocket, that.storeJson.merchant_id);
            // console.log(that.showSocket, that.storeJson.merchant_id)
            clearInterval(timer);
            return false;
          }
          that.storeJson = that.$store.state.Store.storeJson;
          // that.IMkid = that.storeJson.merchant_id + that.$store.state.headInfo.YGBH;
          // if (that.acountList && that.storeJson.merchant_id != undefined) {
          //   for (var i = 0; i < that.acountList.length; i++) {
          //     // that.IMkid.push(that.$store.state.acountList[i])
          //     that.IMkid[i] = that.acountList[i];
          //     that.IMkid[i].YGBH=that.storeJson.merchant_id+that.IMkid[i].YGBH;
          //     that.IMkid[i].header =
          //       "https://app.maoxiaoqi.com/v2/static/images/serverer.png";
          //   }
          //   console.log(that.IMkid, that.storeJson.merchant_id);
          //   //CTH:这里加个接口。用来用来存IM子客服
          // }
        }, 2000);
    
    展开全文
  • vue项目中websocket封装方法的使用

    千次阅读 2020-12-29 04:23:43
    这套代码目前个人在项目中已使用,大家可以直接拿去使用,相关注意点已在代码中注释,方便大家阅读。 核心代码: //这里需要引入vuex import store ... } 以上就是关于在vue项目中封装websocket使用方法的全部代码。

    这套代码目前个人在项目中已使用,大家可以直接拿去使用,相关注意点已在代码中注释,方便大家阅读。

    核心代码:

    //这里需要引入vuex

    import store from './store';

    let wsConnection = {

    $ws: null,

    lockReturn: false,

    timeout: 60 * 1000 * 5,

    timeoutObj: null,

    timeoutNum: null,

    serverTimeoutObj: null,

    //初始化webSocket长连接

    initWebSocket: function () {

    let corpId = localStorage.getItem('corpId');

    let name = localStorage.getItem('username');

    this.$ws = new WebSocket(wsurl);//写入地址 这里的地址可以在initWebSocket方法加入参数

    this.$ws.onopen = this.wsOpen;

    this.$ws.onclose = this.wsClose;

    this.$ws.onmessage = this.wsMsg;

    this.$ws.onerror = this.wsError;

    },

    //打开websocket

    wsOpen: function (e) {

    //开始websocket心跳

    wsConnection.startWsHeartbeat();

    console.log('ws success')

    },

    wsClose: function (e) {

    console.log(e, 'ws close')

    },

    wsMsg: function (msg) {

    //每次接收到服务端消息后 重置websocket心跳

    wsConnection.resetHeartbeat();

    //服务端发送来的消息存到vuex

    store.commit('web_socket_msg', msg)

    },

    wsError: function (err) {

    console.log(err, 'ws error');

    wsConnection.reconnect()

    },

    //重启websocket

    reconnect: function () {

    let _this = this;

    if (_this.lockReturn) {

    return;

    }

    _this.lockReturn = true;

    _this.timeoutNum && clearTimeout(_this.timeoutNum);

    _this.timeoutNum = setTimeout(function () {

    _this.initWebSocket();

    _this.lockReturn = false;

    }, 3000);

    },

    startWsHeartbeat: function () {

    let _this = this;

    _this.timeoutObj && clearTimeout(_this.timeoutObj);

    _this.serverTimeoutObj && clearTimeout(_this.serverTimeoutObj);

    _this.timeoutObj = setInterval(function () {

    //判断websocket当前状态

    if (_this.$ws.readyState != 1) {

    _this.reconnect()

    }

    }, _this.timeout);

    },

    //重置websocket心跳

    resetHeartbeat: function () {

    let _this = this;

    clearTimeout(_this.timeoutObj);

    clearTimeout(_this.serverTimeoutObj);

    _this.startWsHeartbeat()

    }

    };

    //抛出websocket对象

    export default wsConnection

    websocket方法调用

    //在main.js引入

    import wsConnection from './vuex/wsStore'

    //挂载vue原型链

    Vue.prototype.$setWs = wsConnection;

    //在使用地方调用

    $this.$setWs.initWebSocket();

    //在需要使用服务端推送过来的消息时

    //在computed方法声明

    getWsMsg() {

    //在核心代码接收到的服务端信息存储到vuex的属性

    return this.$store.state.webSocketMsg

    }

    //在watch方法 监听 getWsMsg

    getWsMsg: function (data, val) {

    console.log(data);

    //.......

    }

    以上就是关于在vue项目中封装websocket使用方法的全部代码。

    展开全文
  • websocket的使用封装

    2019-11-27 09:15:45
    现在目录创建一个socket.js,代码如下 var websock = null var globalCallback = null // 初始化weosocket function initWebSocket () { ... var ws= 'wss://*********/webSocket'; websock = new Web...

    现在目录创建一个socket.js,代码如下

    var websock = null
    var globalCallback = null
    
     // 初始化weosocket
    function initWebSocket () {
      // ws地址 -->这里是你的请求路径
      var ws= 'wss://*********/webSocket';
      websock = new WebSocket(ws)
      websock.onmessage = function (e) {
        websocketonmessage(e)
      }
      websock.onclose = function (e) {
        websocketclose(e)
      }
      websock.onopen = function () {
        websocketOpen()
      }
    
      // 连接发生错误的回调方法
      websock.onerror = function () {
        console.log('WebSocket连接发生错误')
      }
    }
    
    // 实际调用的方法
    function sendSock (agentData, callback) {
      globalCallback = callback
      if (websock.readyState === websock.OPEN) {
        // 若是ws开启状态
        websocketsend(agentData)
      } else if (websock.readyState === websock.CONNECTING) {
        // 若是 正在开启状态,则等待1s后重新调用
        setTimeout(function () {
          sendSock(agentData, callback)
        }, 1000)
      } else {
        // 若未开启 ,则等待1s后重新调用
        setTimeout(function () {
          sendSock(agentData, callback)
        }, 1000)
      }
    }
    
    // 数据接收
    function websocketonmessage (e) {
      globalCallback(JSON.parse(e.data))
    }
    
    // 数据发送
    function websocketsend (agentData) {
      websock.send(JSON.stringify(agentData))
    }
    
    // 关闭
    function websocketclose (e) {
      console.log('connection closed (' + e.code + ')')
    }
    
    // 创建 websocket 连接
    function websocketOpen (e) {
      console.log('连接成功')
    }
    
    initWebSocket()
    
    // 将方法暴露出去
    export {
      sendSock
    }
    

    然后在main.js里面引入全局方法

    // WebSocket封装方法
    import * as socketApi from './until/socket'
    Vue.prototype.socketApi = socketApi

    用法特定地方特定使用

    methods: {
        getConfigResult(res) {
            // 接收回调函数返回数据的方法
            console.log(res)
            // var mp3 = "./music/order.mp3";
            // var mp3 = new Audio(mp3);
            // mp3.play(); //播放 mp3这个音频对象
          },
          websocketToLogin() {
            // 【agentData:发送的参数;this.getConfigResult:回调方法】
            this.socketApi.sendSock(getPlaceRevenue, this.getConfigResult)
          }
    }

    大功告成,拜拜!

    展开全文
  • websocket封装

    2021-03-01 11:26:37
    import Vue from 'vue' ...var webSocket = null; var isConnect = false; //连接状态 var globalCallback = function(e){ console.log(e) };//定义外部接收数据的回调函数 var reConnectNum = 0;//重连次数 var webso

    一、HTML5 WebSocket
    WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。

    1.1、创建WebSocket 实例

    var ws= new WebSocket(url,[protocol]);
    

    以上代码用于创建 WebSocket 对象,其中的第一个参数 url, 即为指定连接的 URL。第二个参数 protocol 是可选的,指定了可接受的子协议。一般来说,大多没有具体要求的,就只用写url即可。

    1.2websocket属性
    例如:var ws = new WebSocket(‘ws://1xx.xxx.xxx.xxx:8080/ws’); 打印出创建的socket对象,内容如下,这些也正是wensocket的属性。

    	binaryType: "blob"      //返回websocket连接所传输二进制数据的类型,如果传输的是Blob类型的数据,则为"blob",如果传输的是Arraybuffer类型的数据,则为"arraybuffer"
    	bufferedAmount: 0    //为只读属性,用于返回已经被send()方法放入队列中但还没有被发送到网络中的数据的字节数。
    	extensions: ""
    	onclose: ƒ ()      //连接关闭时触发
     	onerror: ƒ ()      //通信发生错误时触发
      onmessage: ƒ (e)      //客户端接收服务端数据时触发,e为接受的数据对象
      onopen: ƒ ()       //连接建立时触发
      protocol: ""       //用于返回服务器端选中的子协议的名字;这是一个在创建websocket对象时,在参数protocols中指定的字符串。
      readyState: 1      //返回值为当前websocket的链接状态
      url: "ws://1xx.xxx.xxx.xxx:8080/ws"    //返回值为当构造函数创建WebSocket实例对象时URL的绝对路径。
    

    1.3 websocket属性之readyState
    readyState返回当前websocket的链接状态,共有4种。可根据具体项目的需求来利用此状态,写对应的需求。

    CONNECTING:值为0,表示正在连接。
    OPEN:      值为1,表示连接成功,可以通信了。
    CLOSING:   值为2,表示连接正在关闭。
    CLOSED:    值为3,表示连接已经关闭,或者打开连接失败。
    

    1.4 websocket的方法
    ws.send()
    使用连接发送数据,可以发送你想要发送的各种类型数据,如Blob对象、ArrayBuffer 对象、基本或复杂的数据类型等;如:

    ws.send('消息');
    //发送对象需要格式转换,接受数据同理
    ws.send(JSON.stringify(data));
    

    ws.close() :
    关闭连接,用户可以主动调取此方法,来关闭连接。

    二、封装websocket
    可在项目中定义一个socket.js文件,在需要建立socket的页面引入此js文件

    import Vue from 'vue'
    import { Message } from 'element-ui'
    let v = new Vue()
    v.$message = Message;
    var webSocket = null;
    var isConnect = false; //连接状态
    var globalCallback = function(e){ console.log(e) };//定义外部接收数据的回调函数
    var reConnectNum = 0;//重连次数
    
    var websocketUrl =  process.env.VUE_APP_API_WEBSOCKET_URL;
    
    //心跳设置
    var heartCheck = {
        heartbeatData:{
            DevID:{
                value:Vue.ls.get('devid')
            },
            DevHeart:{
                value:"1"
            }   
        },//心跳包
        timeout: 60 * 1000, //每段时间发送一次心跳包 这里设置为60s
        heartbeat: null, //延时发送消息对象(启动心跳新建这个对象,收到消息后重置对象)
        start: function () {
            this.heartbeat = setInterval(()=>{
                if (isConnect){
                    webSocketSend(this.heartbeatData);
                }else{
                    this.clear();
                }
            }, this.timeout);
        },
        reset: function () {
            clearInterval(this.heartbeat);
            this.start();
        },
        clear:function(){
            clearInterval(this.heartbeat);
        }
    }
    
    //初始化websocket
    function initWebSocket(callback) {
        //此callback为在其他地方调用时定义的接收socket数据的函数
        if(callback){
            if(typeof callback == 'function'){
                globalCallback = callback     
            }else{
                throw new Error("callback is not a function")
            }
        }
        if ("WebSocket" in window) {
            webSocket = new WebSocket(websocketUrl);//创建socket对象
        } else {
            Message({
                message: '该浏览器不支持websocket!',
                type: 'warning'
            });
            return
        }
        //打开
        webSocket.onopen = function() {
            webSocketOpen();
        };
        //收信
        webSocket.onmessage = function(e) {
            webSocketOnMessage(e);
        };
        //关闭
        webSocket.onclose = function(e) {
            webSocketOnClose(e);
        };
        //连接发生错误的回调方法
        webSocket.onerror = function(e) {
            webSocketonError(e);
        };
    }
    
    //连接socket建立时触发
    function webSocketOpen() {
        console.log("WebSocket连接成功");
        //首次握手
        webSocketSend(heartCheck.heartbeatData);
        isConnect = true;
        heartCheck.start();
        reConnectNum = 0;
    }
    
    //客户端接收服务端数据时触发,e为接受的数据对象
    function webSocketOnMessage(e) {
        console.log("websocket信息:");
        console.log(e.data)
        const data = JSON.parse(e.data);//根据自己的需要对接收到的数据进行格式化
        globalCallback(data);//将data传给在外定义的接收数据的函数,至关重要。
    }
    
    //socket关闭时触发
    function webSocketOnClose(e){
        heartCheck.clear();
        isConnect = false; //断开后修改标识
        console.log(e)
        console.log('webSocket已经关闭 (code:' + e.code + ')')
        //被动断开,重新连接
        if(e.code == 1006){
            if(reConnectNum < 3){
                initWebSocket();
                ++reConnectNum;
            }else{
                v.$message({
                    message: 'websocket连接不上,请刷新页面或联系开发人员!',
                    type: 'warning'
                });
            }
        }
    }
    
    //连接发生错误的回调方法
    function webSocketonError(e){
        heartCheck.clear();
        isConnect = false; //断开后修改标识
        console.log("WebSocket连接发生错误:");
        console.log(e);
    }
    
    
    //发送数据
    function webSocketSend(data) {
        webSocket.send(JSON.stringify(data));//在这里根据自己的需要转换数据格式
    }
    //在其他需要socket地方主动关闭socket
    function closeWebSocket(e) {
        webSocket.close();
        heartCheck.clear();
        isConnect = false;
        reConnectNum = 0;
    }
    //在其他需要socket地方接受数据
    function getSock(callback) {
        globalCallback = callback
    }
    //在其他需要socket地方调用的函数,用来发送数据及接受数据
    function sendSock(agentData) {
        //下面的判断主要是考虑到socket连接可能中断或者其他的因素,可以重新发送此条消息。
        switch (webSocket.readyState) {
            //CONNECTING:值为0,表示正在连接。
            case webSocket.CONNECTING:
                setTimeout(function() {
                    sendSock(agentData, callback);
                }, 1000);
            break;
            //OPEN:值为1,表示连接成功,可以通信了。
            case webSocket.OPEN:
                webSocketSend(agentData);
            break;
            //CLOSING:值为2,表示连接正在关闭。
            case webSocket.CLOSING:
                setTimeout(function() {
                    sendSock(agentData, callback);
                }, 1000);
            break;
            //CLOSED:值为3,表示连接已经关闭,或者打开连接失败。
            case webSocket.CLOSED:
            // do something
            break;
            default:
            // this never happens
            break;
        }
    }
    
    export default {
      initWebSocket,
      closeWebSocket,
      sendSock,
      getSock
    };
    

    三、使用此socket.js文件(主要在vue项目中使用封装的socket)
    1、引入

    import Vue from 'vue'
    import socketApi from "./utils/socket";//找到封装的socket.js文件
    Vue.prototype.socketApi = socketApi;//将其挂在原型上,这样 $socketApi就在所有的 Vue 实例中可用了。
    

    2、在某一页面

    <template>
    </template>
    <script>
    export default {
    	mounted(){
    	   // 建立socket连接, 并设置socket信息返回接受函数   
    	   this.$socketApi.initWebSocket(this.getsocketResult);
    	},
    	beforeDestroy(){
    	   this.$socketApi.closeWebSocket();
    	},
    	methods:{
    	   // socket信息返回接受函数
    	   getsocketResult(data) {
    	     console.log(data);
    	   },
    	   //发送socket信息
    	   websocketSend(data) {
    	     this.$socketApi.sendSock(data);
    	   }
    	}
    }
    </script>
    <style>
    </style>
    
    展开全文
  • websocket在vue项目的封装和使用

    千次阅读 2020-12-19 14:16:36
    websocket通信协议于2011年被IETF定为标准RFC 6455,并由RFC 7936补充规范。webscoketAPI也被W3C定为标准。websocket使得客户端和服务器之间的数据交换变得更加简单,允许服务端主动向客户端推送数据。在...
  • websocket(一)封装使用

    万次阅读 热门讨论 2018-10-16 14:39:30
    WebSocket用于在Web浏览器和服务器之间进行任意的双向数据传输的一种技术。WebSocket协议基于TCP协议实现,包含初始的握手过程,以及后续的多次数据帧双向传输过程。其目的是在WebSocket应用和WebSocket服务器进行...
  • 大概思路: 首先用户登陆 获取用户信息存储到httpsession中,然后客户端链接服务端websocket,首先HandshakeInterceptor这个拦截器会拦截请求 调用beforeHandshake方法进行握手操作,然后吧httpsession 和 websocket...
  • Server代码: <?php class Ws { CONST HOST = "0.0.0.0"; CONST PORT = 9512; public $ws = null; public function __construct() { $this->ws = new swoole_websocket_server("0.0.0.0...
  • 封装websocket请求-----vue项目实战(完整版)

    千次阅读 多人点赞 2020-04-27 17:48:59
    如果项目中多个组件都使用到WebSocket请求,那么我们需要对WebSocket进行封装,方便我们使用。 下面我根据我的项目结构来创建文件和引入文件,大家注意一下自己项目结构。 一、在utils目录下创建websocket.js文件 ...
  • js WebSocket封装

    千次阅读 2020-07-14 15:48:51
    //浏览器WebSocket对象 var wsImpl = window.WebSocket || window.MozWebSocket; function SocketStart(options, cl) { this.url = options.url;//Socket地址 this.ws = new wsImpl(options.url);//初始化Socket...
  • 基于OKHttp的websocket封装使用

    千次阅读 2019-11-22 20:16:14
    源码解析2.1基础封装2.2使用3.相关知识点3.1 websocket协议3.1.1、客户端:申请协议升级3.1.2、服务端:响应协议升级3.1.3、数据帧3.2 返回数据 Demo源码请点击 1.背景 一般使用到websocket协议的应用场景都是持续...
  • websocket 封装

    2021-04-20 14:49:52
    使用单例模式创建websocket连接,暴露出手动开启/关闭/重连的函数,内部实现断线重连和心跳检测机制,通过onMessage状态钩子触发接收下行消息,发送该下行type对应的事件通知,由SocketEvent类实现调用对应的事件...
  • vue的websocket封装及组件使用

    千次阅读 2019-12-03 10:47:05
    第一次做前后端分离微信公众号项目,项目两个组件用到websocket,项目不用发送数据,只接受后端发过来的数据(而且数据只是一个字符串标志例如:refreash).我是先封装成socket.js,接收到的后端的字符串数据也在js里...
  • 前端基于WebSocket封装

    2020-09-16 14:39:17
    1.无心跳,短开连接之后重新连。 class webSocketClass { constructor(name) { this.lockReconnect = false; this.localUrl = "ws://XXXXXX"; this.wsUrl = "";... this.createWebSocket(name); } createW
  • uni-app WebSocket 封装使用例子 本文出自: uni-app WebSocket 封装使用例子源码链接
  • } } } catch (e) { console.log(e) } } close() { clearTimeout(this.time) this.socket.close(1000, '手动关闭') console.log("调用关闭") } reconnect() { this.j++ //1.开始重连 //2.如果连接不成功要继续重连 ...
  • vue封装websocket.zip

    2020-02-24 20:49:11
    vue 封装 webSocket调用 封装后的webSocket在组件中调用 压缩文件中包含socket.js和调用方法说明
  • C#创建ActiveX,Windows系统服务,C#WebSocket服务,C#调用ActiveX,实现多种浏览器调用ActiveX插件。 解决方案位于 WindowsServiceActiveX\\EL100WindowsService
  • webSocket封装,心跳检测+断线重连基于ES6 class

    千次阅读 热门讨论 2020-01-16 12:13:39
    ES6 class 封装websocket 使用 介绍 在《菜鸟教程中》这样介绍WebSocket WebSocket 是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。 WebSocket 使得客户端和服务器之间的数据交换变得更加简单,...
  • HTML5 WebSocket 封装

    千次阅读 2016-08-18 14:30:20
    可通过调用websocket对象中connect方法进行连接 如方法:connect(url,msgbak,openbak,errorbak,closebak) url表示连接地址,必须以ws://开头的连接,如:ws://localhost:8080/HTML5WebSocekt/websocket m
  • WebSocketClient client = new WebSocketClient(new URI(uri),new Draft_6455()) { /** * 建立连接调用 * @param serverHandshake */ @Override public void onOpen(ServerHandshake serverHandshake) { log...
  • 封装代码段: var ws = function (wsUrl, wsMsg) { var that = this; that.Open = function () { try { if (that.Cache && that.Cache != '') { that.Socket.send(that.Cache); } typeof wsMsg == ...
  • 封装websocket后的功能 1、提供接口myws_start(url),简单启动ws。 2、提供接口myws_send(data), 发送数据。 3、支持自动重连,重连间隔5000ms。 源码和环境准备 1、封装websocket保存为 myws.js, 源码见后文。 ...
  • js封装websocket

    2021-07-15 16:17:13
    websocket实例以及包含的额方法封装为ws.js,方便调用。无论是原生h5开发还是现代框架开发都可以使用。很多地方经常需要进行长连接进行异步任务,所以websocket是个十分不错的方式。(导入,导出,报警事件推送...
  • Websocket 封装

    2020-10-22 14:46:45
    // 函数节流标识符 } /** * @description: 初始化 连接websocket或重连webSocket调用 * @param {*} 可选值 要传的数据 */ connect(data) { // 新建 WebSocket 实例 this.ws = new WebSocket(this.url);...
  • data() { return { websock: null }; }, methods: { initWebSocket() { const url = 'ws://127.0.0.1:8080/home';... {} // 由于uni封装,必须加个回调才会返回一个SocketTask对象 }); this.websoc.
  • VUE中的websocket封装

    千次阅读 2019-09-09 11:14:24
    //断线重连后,延迟5秒重新创建WebSocket连接 rec用来存储延迟请求的代码 let isConnect = false; //连接标识 避免重复连接 let checkMsg = "heartbeat"; //心跳发送/返回的信息 服务器和客户端收到的信息内容如果...
  • websocket 封装(含心跳,重连机制,强制退出) /** * @param {JSON} json 连接建立立即发送,如果想不发送就传' ', * @param {String} url * @param {Function} callback 接收服务端数据时触发的回调 * @param {...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 19,378
精华内容 7,751
关键字:

websocket封装调用

友情链接: CLOCK.zip