javascript - 无序的 websocket 消息(不要等待丢失数据包的重传)

Question

当服务器正在发送一个 websocket 消息并且数据包丢失时，客户端将看不到任何消息，直到服务器意识到数据包丢失，重新传输它等等并且它实际上到达客户端......可以想象，这会在实时应用程序中造成不必要的大滞后。

我知道这是设计使然，因为 TCP 确保数据包以正确的顺序传送。

但我想知道是否有任何类似 socket.io 的库可以解决该机制。从头开始写这样的东西似乎需要很多工作。

变通方法是指例如使用 UDP 而不是 TCP 使用新的 WebRTC 功能或更简单，只需创建多个 websocket 连接并确保通过不同的连接发送连续的消息。

我知道客户端可能会以这种方式收到过时的信息，但它可以通过忽略这些信息来轻松弥补。您只需为每条消息提供一个递增的 ID。

例如，socket.io 的包装器会很好。具有相同接口(interface)但在内部创建多个连接的东西。我试图开始为此编写一个包装器类，但我真的不确定如何在包装器和 socket.io 实例之间正确传递事件。

我的意思是，如果我只是将在套接字上触发的所有事件传递给包装类，并将在包装类上触发的所有事件传递给其中一个 socket.io 实例，那么每个事件都会永远循环。

const EventEmitter = require('events');
const Server = require('socket.io');

class ServerWrapper extends EventEmitter {
    constructor() {
        /* instanciation manual:
            new ServerWrapper(httpServer[, options][, connectionCount])
            new ServerWrapper(port[, options][, connectionCount])
            new ServerWrapper(options[, connectionCount])
            (connectionCount is the number of socket.io instances that will be used)
        */

        let port, srv, opts; // not really necessary
        let connCount = 5; //default
        let args = arguments;
        // The following if statements are used to maintain full compatibility with the original socket.io constructor (https://socket.io/docs/server-api/)
        if (arguments.length === 0)
            return;
        else if (arguments.length === 1)
            opts  = arguments[0];
        else if (arguments.length === 2) {
            if (typeof arguments[0] === 'object' && arguments[1] === 'object') {
                srv = arguments[0];
                opts = arguments[1];
            } else if (typeof arguments[0] === 'number' && arguments[1] === 'object') {
               port = arguments[0];
               opts = arguments[1];
            } else if (typeof arguments[0] === 'object' && arguments[1] === 'number') {
                opts = arguments[0];
                connCount = arguments[1];
                args = arguments.pop();
            }
        } else if (arguments.length === 3) {
            opts = arguments[1];
            connCount = arguments[2];
            if (typeof arguments[0] === 'number')
                port = arguments[0];
            else
                srv = arguments[0];
            args = arguments.pop();
        }

        // Create X socket.io instances and store them in this array
        this._io = [];
        for (let i=0; i<connCount; i++)
            this._io.push(new Server(args));

        // Pass all socket.io events to this wrapper class
        this._io.forEach(io=>{
            io.on("*",this.emit);
        });

        // Pass all events fired on this wrapper class to one of the socket.io instances:
        this.nextConn = 0;
        this.on("*", (event,data) => {
            this._io[this.nextConn].emit(...arguments);
            this.nextConn++;
            if (this.nextConn >= this.connCount)
                this.nextConn = 0;
        });

        let sioProps = ['sockets'];
        sioProps.forEach(prop=>{ // map all socket.io properties from the first instance to 'this[prop]'
            this[prop] = this._io[0][prop];
        });

        let sioMethods = ['seveClient','path','adapter','origins','attach','listen','bind','onconnection','of','close'];
        sioMethods.forEach(fName=>{ // redirect all socket.io function calls to all the socket.io instances
            this[fName] = () => {
                this._io.forEach(io=>{
                    this[fName] = io[fName](...arguments);
                });
            };
        });
    }
}
module.exports = ServerWrapper;

Answer 1

socket.io-p2p项目围绕出色的 simple-peer 提供了一个 socket.io 接口(interface)WebRTC 库。如果您的应用程序是实时的并且可以容忍消息乱序到达，那么您应该能够执行类似这样的操作来禁用顺序保证(以防止丢失/迟到的消息延迟以后的消息):

let peerOpts = {channelConfig: {ordered: false}}
let p2psocket = new P2P(socket, peerOpts)

为了帮助查找文档，请注意 peerOpts 值变为 opts param对于来自 simple-peer 的 SimplePeer 对象。