Envoyer un message à un client spécifique avec socket.io et node.js

Question

Je travaille avec socket.io et node.js et jusqu'à présent, ça semble assez bien, mais je ne sais pas comment envoyer un message du serveur à un client spécifique, quelque chose comme ceci :

client.send(message, receiverSessionId)

Mais ni les méthodes .send() ni .broadcast() ne semblent répondre à mon besoin.

Ce que j'ai trouvé comme solution possible, c'est que la méthode .broadcast() accepte en deuxième paramètre un tableau de SessionIds auxquels ne pas envoyer le message, donc je pourrais passer un tableau avec tous les SessionIds connectés au serveur à ce moment-là, sauf celui à qui je souhaite envoyer le message, mais je sens qu'il doit y avoir une meilleure solution.

Des idées ?

Answer 1

La réponse de Ivo Wetzel ne semble plus être valable dans Socket.io 0.9.

En bref, vous devez maintenant sauvegarder le socket.id et utiliser io.sockets.socket(savedSocketId).emit(...) pour envoyer des messages.

Voici comment j'ai fait fonctionner ceci dans un serveur Node.js en grappe :

Tout d'abord, vous devez définir Redis comme magasin afin que les messages puissent passer entre les processus :

var express = require("express");
var redis = require("redis");
var sio = require("socket.io");

var client = redis.createClient()
var app = express.createServer();
var io = sio.listen(app);

io.set("store", new sio.RedisStore);

// Dans cet exemple, nous avons un socket client maître qui reçoit des messages des autres.

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

  // Promouvoir ce socket en tant que maître
  socket.on("Je suis le maître", function() {

    // Sauvegarder l'identifiant du socket dans Redis pour que tous les processus puissent y accéder.
    client.set("mastersocket", socket.id, function(err) {
      if (err) throw err;
      console.log("Le socket maître est maintenant" + socket.id);
    });
  });

  socket.on("message au maître", function(msg) {

    // Récupérer l'identifiant du socket depuis Redis
    client.get("mastersocket", function(err, socketId) {
      if (err) throw err;
      io.sockets.socket(socketId).emit(msg);
    });
  });

});

J'ai omis le code de regroupement ici, car cela rendrait les choses plus encombrées, mais c'est trivial à ajouter. Il suffit d'ajouter tout au code du travailleur. Plus de documents ici http://nodejs.org/api/cluster.html

Answer 2

Pour votre commodité, chaque socket rejoint automatiquement une salle identifiée par son identifiant (voir Socket#id). Cela facilite la diffusion de messages à d'autres sockets :

io.on("connection", (socket) => {
  socket.on("say to someone", (id, msg) => {
    // envoyer un message privé au socket avec l'identifiant donné
    socket.to(id).emit("my message", msg);
  });
});

docs: https://socket.io/docs/v4/server-api/#socketjoinroom

Answer 3

La manière la plus simple et la plus élégante

vérifié fonctionnant avec socket.io v3.1.1

C'est aussi simple que :

client.emit("votre message");

Et c'est tout. D'accord, mais comment ça fonctionne?

Exemple minimal de fonctionnement

Voici un exemple d'interaction client-serveur simple où chaque client reçoit régulièrement un message contenant un numéro de séquence. Il y a un numéro de séquence unique pour chaque client et c'est là que le "J'ai besoin d'envoyer un message à un client particulier" entre en jeu.

Serveur

server.js

const
    {Server} = require("socket.io"),
    server = new Server(8000);

let
    sequenceNumberByClient = new Map();

// événement déclenché chaque fois qu'un nouveau client se connecte :
server.on("connection", (socket) => {
    console.info(`Client connecté [id=${socket.id}]`);
    // initialise le numéro de séquence de ce client
    sequenceNumberByClient.set(socket, 1);

    // lorsque le socket se déconnecte, le supprimer de la liste :
    socket.on("disconnect", () => {
        sequenceNumberByClient.delete(socket);
        console.info(`Client parti [id=${socket.id}]`);
    });
});

// envoie à chaque client son numéro de séquence actuel
setInterval(() => {
    for (const [client, sequenceNumber] of sequenceNumberByClient.entries()) {
        client.emit("seq-num", sequenceNumber);
        sequenceNumberByClient.set(client, sequenceNumber + 1);
    }
}, 1000);

Le serveur commence à écouter sur le port 8000 pour les connexions entrantes. Dès qu'une nouvelle connexion est établie, ce client est ajouté à une carte qui suit son numéro de séquence. Le serveur écoute également l'événement déconnexion pour supprimer le client de la carte lorsqu'il part.

Chaque seconde, une minuterie est déclenchée. Lorsqu'elle est déclenchée, le serveur parcourt la carte et envoie un message à chaque client avec son numéro de séquence actuel, en l'incrémentant juste après. C'est tout. Facile comme bonjour.

Client

La partie client est encore plus simple. Il se connecte simplement au serveur et écoute le message seq-num, l'imprimant dans la console à chaque fois qu'il arrive.

client.js

const
    io = require("socket.io-client"),
    ioClient = io.connect("http://localhost:8000");

ioClient.on("seq-num", (msg) => console.info(msg));

Exécution de l'exemple

Installez les bibliothèques requises :

npm install socket.io@3.1.1 socket.io-client@3.1.1

Exécutez le serveur :

node server

Ouvrez d'autres fenêtres de terminal et lancez autant de clients que vous le souhaitez en exécutant :

node client

J'ai également préparé un gist avec le code complet ici.

Answer 4

Vous devez attraper le client pour cela (surprise), vous pouvez aller de manière simple:

var io = io.listen(server);
io.clients[sessionID].send()

Il se peut que cela change, donc utilisez l'option ci-dessus avec prudence

Ou vous pouvez suivre les clients vous-même, en les ajoutant à votre propre objet clients dans l'auditeur connection et en les supprimant dans l'auditeur disconnect.

Je choisirais le dernier, car selon votre application, vous souhaiterez peut-être avoir plus d'état sur les clients de toute façon, donc quelque chose comme clients[id] = {conn: clientConnect, data: {...}} pourrait faire l'affaire.

Answer 5

Vous pouvez utiliser

//envoyer un message uniquement au client expéditeur

socket.emit('message', 'vérifiez ceci');

//ou vous pouvez envoyer à tous les auditeurs, y compris l'expéditeur

io.emit('message', 'vérifiez ceci');

//envoyer à tous les auditeurs sauf l'expéditeur

socket.broadcast.emit('message', 'c'est un message');

//ou vous pouvez l'envoyer à une salle

socket.broadcast.to('salle de discussion').emit('message', 'c'est le message pour tous');