Node js Socket.iO正在外部访问多个客户端的套接字

Question

我们如何在外部访问套接字对象以进行多个套接字连接。我全局创建了一个对象，并尝试执行此操作。但它始终适用于最后连接的套接字。

 'use strict';

const path = require('path')
const express = require('express');
const http = require('http');
const chalk = require('chalk');
const socketio = require('socket.io');
var connectionString = '';
const eventHubConsumerGroup = ""




const app = express()
const server = http.createServer(app ,() => {
    console.log(chalk.green('Server created'))
})
const io = socketio(server)

const port = process.env.port || 3000

const publicDirectoryPath  = path.join(__dirname , '../public')


var server_token = "1234567890";
app.use(express.static(publicDirectoryPath))

var localSocket;



io.on('connection',function(socket){
  localSocket = socket;
  console.log(socket.handshake.query.deviceID)
    console.log('on user connected '+socket.id);
    //report = new Report(socket);
    socket.auth = false;
    socket.on('authenticate',function(token){
        console.log('token recieved is '+token);
        if(server_token == token){
            socket.auth = true;
            console.log('connection is authenticated '+socket.id);
            socket.emit("authenticate",true);
        } else {
          console.log("Connection not established")
            socket.emit("authenticate",false);
        }
    })

    socket.on('sendSocketEvent' , message => {
        console.log(chalk.yellowBright(`Message recieved from ${socket.id} + ${message}`));
        io.to(socket.id).emit('recieveSocketEvent', `Hello test`);
    })

    socket.on('disconnect',function(){
        console.log('one user disconnected '+socket.id);
    })
    setTimeout(function(){
        if(!socket.auth){
            console.log('disconnecting the socket '+socket.id);
            socket.emit("timeOut");
            socket.disconnect();
        }
    },1000);

})







server.listen(port,() => {
    console.log(chalk.redBright(`Server is up on port ${port}`))
})



var printMessage = function (message) {
  console.log(JSON.stringify(message));
   console.log(message.DeviceId);
   if (localSocket != null){
    if (message.DeviceId == localSocket.handshake.query.deviceID) {
      localSocket.emit('recieveSocketEvent', message);
    }
   }
};



class EventHubReader {
  constructor(connectionString, consumerGroup) {
    this.connectionString = connectionString;
    this.consumerGroup = consumerGroup;
    this.eventHubClient = undefined;
    this.receiveHandlers = undefined;
  }

  async startReadMessage(startReadMessageCallback) {
    try {
      console.log(this.connectionString)
      const client = await EventHubClient.createFromIotHubConnectionString(this.connectionString);
      console.log('Successfully created the EventHub Client from IoT Hub connection string.');
      this.eventHubClient = client;

      const partitionIds = await this.eventHubClient.getPartitionIds();
      console.log('The partition ids are: ', partitionIds);

      const onError = (err) => {
        console.error(err.message || err);
      };

      const onMessage = (message) => {
        const deviceId = message.annotations['iothub-connection-device-id'];
        return startReadMessageCallback(message.body, message.enqueuedTimeUtc, deviceId);
      };

      this.receiveHandlers = partitionIds.map(id => this.eventHubClient.receive(id, onMessage, onError, {
        eventPosition: EventPosition.fromEnqueuedTime(Date.now()),
        consumerGroup: this.consumerGroup,
      }));
    } catch (ex) {
      console.error(ex.message || ex);
    }
  }

  // Close connection to Event Hub.
  async stopReadMessage() {
    const disposeHandlers = [];
    this.receiveHandlers.forEach((receiveHandler) => {
      disposeHandlers.push(receiveHandler.stop());
    });
    await Promise.all(disposeHandlers);

    this.eventHubClient.close();
  }
}




var { EventHubClient, EventPosition } = require('@azure/event-hubs');

const eventHubReader = new EventHubReader(connectionString, eventHubConsumerGroup);

(async () => {
  console.log("Step1")
  await eventHubReader.startReadMessage((message, date, deviceId) => {
    console.log("Here getting called");
    try {
      const payload = {
        IotData: message,
        MessageDate: date || Date.now().toISOString(),
        DeviceId: deviceId,
      };
      printMessage(payload);

    } catch (err) {
      console.error('Error broadcasting: [%s] from [%s].', err, message);
    }
  });
})().catch();

问题处于条件“ printMessage”中。这里我试图基于套接字deviceID限制发射，但是它仅适用于最后连接的套接字。

您能帮我吗？

Answer 1

var localSocket;
io.on('connection',function(socket){
  localSocket = socket;
})

您在每个新连接上都覆盖相同的变量，这意味着它将始终指向最后一个连接的套接字。

您到底想做什么？要将此消息发送到所有已连接的套接字？