Question

我正在使用socket.io制作聊天应用，我想使用自定义客户端ID，而不是默认客户端ID（8411473621394412707，1120516437992682114）。在连接或仅使用某些内容跟踪每个ID的自定义名称时，是否有任何方法可以发送自定义标识符？谢谢！

Answer 1

您可以在服务器上创建一个数组，并在其上存储自定义对象。例如，您可以将Socket.io创建的ID和每个客户端发送的自定义ID存储到服务器：

var util = require("util"),
    io = require('/socket.io').listen(8080),
    fs = require('fs'),
    os = require('os'),
    url = require('url');

    var clients =[];

    io.sockets.on('connection', function (socket) {

        socket.on('storeClientInfo', function (data) {

            var clientInfo = new Object();
            clientInfo.customId         = data.customId;
            clientInfo.clientId     = socket.id;
            clients.push(clientInfo);
        });

        socket.on('disconnect', function (data) {

            for( var i=0, len=clients.length; i<len; ++i ){
                var c = clients[i];

                if(c.clientId == socket.id){
                    clients.splice(i,1);
                    break;
                }
            }

        });
    });

在此示例中，您需要从每个客户端调用 storeClientInfo 。

<script>
    var socket = io.connect('http://localhost', {port: 8080});

    socket.on('connect', function (data) {
        socket.emit('storeClientInfo', { customId:"000CustomIdHere0000" });
    });
</script>

希望这有帮助。

Answer 2

要设置自定义套接字ID，必须覆盖generateId函数。 eio 服务器对象的engine和Socket.io道具都可用于管理此操作。

一个简单的例子：

var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);

io.engine.generateId = function (req) {
    // generate a new custom id here
    return 1
}

io.on('connection', function (socket) {
    console.log(socket.id); // writes 1 on the console
})

似乎已经处理好了。

必须记住，套接字ID必须是不可预测的，并且考虑到安全性和应用操作的唯一价值！

额外：由于您socket.id方法的流程过于紧张，undefined被generateId返回，async/await组合可用于在node.js版本7.6.0及更高版本上克服了此问题。 handshake文件的node_modules/engine.io/lib/server.js方法应更改如下：

当前

// engine.io/lib/server.js Server.prototype.generateId = function (req) { return base64id.generateId(); }; Server.prototype.handshake = function (transportName, req) { var id = this.generateId(req); ... }

新：

// function assignment io.engine.generateId = function (req) { return new Promise(function (resolve, reject) { let id; // some intense id generation processes // ... resolve(id); }); }; // engine.io/lib/server.js Server.prototype.handshake = async function (transportName, req) { var id = await this.generateId(req); ... }

注意：在Engine.io v4.0，generateId方法会接受回调。因此，不需要更改handshake方法。只有generateId方法替换才足够。例如：

io.engine.generateId = function (req, callback) { // some intense id generation processes // ... callback(id); };

Answer 3

在最新的socket.io（版本1.x）中，您可以执行类似这样的操作

socket  = io.connect('http://localhost');

socket.on('connect', function() {
    console.log(socket.io.engine.id);     // old ID
    socket.io.engine.id = 'new ID';
    console.log(socket.io.engine.id);     // new ID
});

Answer 4

我会使用一个对象作为哈希查找 - 这将节省你通过数组循环

var clients = {};
clients[customId] = clientId;

var lookup = clients[customId];

Answer 5

或者您可以覆盖套接字ID，如下所示：

io.on('connection', function(socket){

      socket.id = "YOUR_CUSTOM_ID";
});

你可以在数组下看到：

<强> io.sockets.sockets

Answer 6

不要将套接字ID更改为您自己选择的套接字ID，它会完全破坏Socket.io会议室系统。它将无声地失败，你将不知道为什么你的客户没有收到消息。

Answer 7

为什么没有一个更简单的解决方案，不需要维护一组连接的客户端并且不覆盖内部套接字ID？

io.on("connection", (socket) => {
    socket.on('storeClientInfo', (data) => {
        console.log("connected custom id:", data.customId);
        socket.customId = data.customId;
    });

    socket.on("disconnect", () => {
        console.log("disconnected custom id:", socket.customId);
    })
});

客户端

let customId = "your_custom_device_id";
socket.on("connect", () => {
    socket.emit('storeClientInfo', { customId: customId });
});

Answer 8

这将适用于 2.2.0和更高版本的Socket.IO

要设置自定义套接字ID，必须generateId函数被覆盖。

一个简单的例子：

服务器端

var app = require('express')();
var http = require('http').Server(app);
var io = require('socket.io')(http);

io.use((socket, next) => {
  io.engine.generateId = () => {
    // USE ONE OF THESE
    socket.handshake.query.CustomId; // this work for me
    // return socket.handshake.query.CustomId;
  }
  next(null, true);
});

io.on('connection', function (socket) {
    console.log(socket.id);
})

斜边

io.connect(URL, { query: "CustomId = CUSTOM ID IS HERE" })

注意： *必须记住，套接字ID必须是唯一值。

Answer 9

如果您尝试使用自定义ID以便与特定客户端进行通信，那么您可以执行此操作

io.on('connection', function(socket){
    socket.id = "someId"
    io.sockets.connected["someId"] = io.sockets.connected[socket.id];

    // them emit to it by id like this
    io.sockets.connected["someId"].emit("some message", "message content")
});

Answer 10

可以以对象格式而不是for循环存储customId（示例userId），这将提高连接期间的性能，断开连接并检索socketId以便发布

`

 var userId_SocketId_KeyPair = {};
 var socketId_UserId_KeyPair = {};

_io.on('connection', (socket) => {
    console.log('Client connected');
    //On socket disconnect
    socket.on('disconnect', () => {
        // Removing sockets
        let socketId = socket.id;
        let userId = socketId_UserId_KeyPair[socketId];
        delete socketId_UserId_KeyPair[socketId];
        if (userId != undefined) {
            delete userId_SocketId_KeyPair[userId];
        }
        console.log("onDisconnect deleted socket with userId :" + "\nUserId,socketId :" + userId + "," + socketId);
    });

    //Store client info
    socket.on('storeClientInfo', function (data) {
        let jsonObject = JSON.parse(data);
        let userId = jsonObject.userId;
        let socketId = socket.id;
        userId_SocketId_KeyPair[userId] = socketId;
        socketId_UserId_KeyPair[socketId] = userId;
        console.log("storeClientInfo called with :" + data + "\nUserId,socketId :" + userId + "," + socketId);
    });
`

Answer 11

使用"socket.io": "^2.2.0"

io.use((socket, next) => { io.engine.generateId = () => socket.handshake.query.token; next(null, true); });

Socket.io自定义客户端ID

11 个答案: