Estou trabalhando com socket.io e node.js e até agora parece muito bom, mas não sei como enviar uma mensagem do servidor para um cliente específico, algo como isto:

client.send(message, receiverSessionId)

Mas .send()nem os .broadcast()métodos nem parecem suprir minha necessidade.

O que eu descobri como uma solução possível é que o .broadcast()método aceita como segundo parâmetro uma matriz de SessionIds para a qual não envia a mensagem, para que eu pudesse passar uma matriz com todos os SessionIds conectados naquele momento ao servidor, exceto aquele Desejo enviar a mensagem, mas sinto que deve haver uma solução melhor.

Alguma ideia?

Bem, você tem que pegar o cliente para isso (surpresa), você pode seguir o caminho simples:

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

O que pode quebrar, duvido, mas é sempre uma possibilidade que io.clientspode ser alterada; portanto, use o acima com cautela

Ou você mesmo acompanha os clientes, portanto, você os adiciona ao seu próprio clientsobjeto no connectionouvinte e os remove no disconnectouvinte.

Eu usaria o último, já que, dependendo do seu aplicativo, você pode querer ter mais estado sobre os clientes de qualquer maneira, portanto, algo como clients[id] = {conn: clientConnect, data: {...}}pode fazer o trabalho.

A resposta de Ivo Wetzel não parece mais válida no Socket.io 0.9.

Em suma, agora você deve salvar socket.ide usar io.sockets.socket(savedSocketId).emit(...) para enviar mensagens a ele.

Foi assim que consegui isso funcionando no servidor Node.js. clusterizado:

Primeiro, você precisa definir o armazenamento Redis como o armazenamento para que as mensagens possam passar por processos:

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);


// In this example we have one master client socket 
// that receives messages from others.

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

  // Promote this socket as master
  socket.on("I'm the master", function() {

    // Save the socket id to Redis so that all processes can access it.
    client.set("mastersocket", socket.id, function(err) {
      if (err) throw err;
      console.log("Master socket is now" + socket.id);
    });
  });

  socket.on("message to master", function(msg) {

    // Fetch the socket id from Redis
    client.get("mastersocket", function(err, socketId) {
      if (err) throw err;
      io.sockets.socket(socketId).emit(msg);
    });
  });

});

Omiti o código de cluster aqui, porque isso fica mais confuso, mas é trivial adicionar. Basta adicionar tudo ao código do trabalhador. Mais documentos aqui http://nodejs.org/api/cluster.html

cada soquete se junta a uma sala com um ID de soquete para um nome, para que você possa apenas

io.to(socket#id).emit('hey')

docs: http://socket.io/docs/rooms-and-namespaces/#default-room

Felicidades

A solução mais simples e elegante

É tão fácil quanto:

client.emit("your message");

E é isso.

Mas como? Me dê um exemplo

O que todos nós precisamos é de fato um exemplo completo, e é isso que se segue. Isso é testado com a versão mais recente do socket.io (2.0.3) e também usa o Javascript moderno (que todos nós deveríamos estar usando agora).

O exemplo é composto de duas partes: um servidor e um cliente. Sempre que um cliente se conecta, ele começa a receber do servidor um número de sequência periódica. Uma nova sequência é iniciada para cada novo cliente, para que o servidor precise acompanhá-los individualmente. É aí que entra o jogo "Preciso enviar uma mensagem para um cliente em particular" . O código é muito simples de entender. Vamos ver isso.

Servidor

server.js

const
    io = require("socket.io"),
    server = io.listen(8000);

let
    sequenceNumberByClient = new Map();

// event fired every time a new client connects:
server.on("connection", (socket) => {
    console.info(`Client connected [id=${socket.id}]`);
    // initialize this client's sequence number
    sequenceNumberByClient.set(socket, 1);

    // when socket disconnects, remove it from the list:
    socket.on("disconnect", () => {
        sequenceNumberByClient.delete(socket);
        console.info(`Client gone [id=${socket.id}]`);
    });
});

// sends each client its current sequence number
setInterval(() => {
    for (const [client, sequenceNumber] of sequenceNumberByClient.entries()) {
        client.emit("seq-num", sequenceNumber);
        sequenceNumberByClient.set(client, sequenceNumber + 1);
    }
}, 1000);

O servidor começa a escutar na porta 8000 as conexões de entrada. Quando alguém chega, ele adiciona esse novo cliente a um mapa para poder acompanhar seu número de sequência. Ele também escuta o disconnectevento desse cliente , quando o remove do mapa.

A cada segundo, um timer é acionado. Quando isso acontece, o servidor percorre o mapa e envia uma mensagem para cada cliente com seu número de sequência atual. Em seguida, o incrementa e armazena o número de volta no mapa. É só isso. Mole-mole.

Cliente

A parte do cliente é ainda mais simples. Apenas se conecta ao servidor e escuta a seq-nummensagem, imprimindo-a no console toda vez que chega.

client.js

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

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

Executando o exemplo

Instale as bibliotecas necessárias:

npm install socket.io
npm install socket.io-client

Execute o servidor:

node server

Abra outras janelas de terminal e crie quantos clientes você desejar executando:

node client

Também preparei uma essência com o código completo aqui .

Você pode usar

// envia mensagem apenas para o remetente-cliente

socket.emit('message', 'check this');

// ou você pode enviar para todos os ouvintes, incluindo o remetente

io.emit('message', 'check this');

// envia para todos os ouvintes, exceto o remetente

socket.broadcast.emit('message', 'this is a message');

// ou você pode enviá-lo para uma sala

socket.broadcast.to('chatroom').emit('message', 'this is the message to all');

Na 1.0 você deve usar:

io.sockets.connected[socketid].emit();

Qualquer que seja a versão que estamos usando, se apenas console.log () o objeto "io" que usamos no código nodejs do servidor, [por exemplo, io.on ('conexão', função (soquete) {...});] , podemos ver que "io" é apenas um objeto json e há muitos objetos filhos nos quais o ID do soquete e os objetos do soquete são armazenados.

Estou usando o socket.io versão 1.3.5, btw.

Se olharmos no objeto io, ele contém,

 sockets:
  { name: '/',
    server: [Circular],
    sockets: [ [Object], [Object] ],
    connected:
     { B5AC9w0sYmOGWe4fAAAA: [Object],
       'hWzf97fmU-TIwwzWAAAB': [Object] },

aqui podemos ver os socketids "B5AC9w0sYmOGWe4fAAAA" etc. Então, podemos fazer,

io.sockets.connected[socketid].emit();

Novamente, em uma inspeção mais aprofundada, podemos ver segmentos como,

 eio:
  { clients:
     { B5AC9w0sYmOGWe4fAAAA: [Object],
       'hWzf97fmU-TIwwzWAAAB': [Object] },

Então, podemos recuperar um soquete daqui fazendo

io.eio.clients[socketid].emit();

Além disso, sob o motor, temos,

engine:
 { clients:
    { B5AC9w0sYmOGWe4fAAAA: [Object],
      'hWzf97fmU-TIwwzWAAAB': [Object] },

Então, também podemos escrever,

io.engine.clients[socketid].emit();

Acho que podemos alcançar nosso objetivo de qualquer uma das três maneiras listadas acima,

1. io.sockets.connected [socketid] .emit (); OU
2. io.eio.clients [socketid] .emit (); OU
3. io.engine.clients [socketid] .emit ();

Você consegue fazer isso

No servidor.

global.io=require("socket.io")(server);

io.on("connection",function(client){
    console.log("client is ",client.id);
    //This is handle by current connected client 
    client.emit('messages',{hello:'world'})
    //This is handle by every client
    io.sockets.emit("data",{data:"This is handle by every client"})
    app1.saveSession(client.id)

    client.on("disconnect",function(){
        app1.deleteSession(client.id)
        console.log("client disconnected",client.id);
    })

})

    //And this is handle by particular client 
    var socketId=req.query.id
    if(io.sockets.connected[socketId]!=null) {
        io.sockets.connected[socketId].emit('particular User', {data: "Event response by particular user "});
    }

E no cliente, é muito fácil de manusear.

var socket=io.connect("http://localhost:8080/")
    socket.on("messages",function(data){
        console.log("message is ",data);
        //alert(data)
    })
    socket.on("data",function(data){
        console.log("data is ",data);
        //alert(data)
    })

    socket.on("particular User",function(data){
        console.log("data from server ",data);
        //alert(data)
    })

A partir da versão 1.4.5, certifique-se de fornecer um socketId com o prefixo correto em io.to (). Eu estava usando o socketId, o cliente logado para depurar e não tinha prefixo, então acabei pesquisando para sempre até descobrir! Portanto, talvez você precise fazer isso assim se o ID que você possui não tiver o prefixo:

io.to('/#' + socketId).emit('myevent', {foo: 'bar'});

io.sockets.sockets [socket.id] .emit (...) funcionou para mim na v0.9

Além disso, você pode manter as referências de clientes. Mas isso deixa sua memória ocupada.

Crie um objeto vazio e defina seus clientes nele.

const myClientList = {};

  server.on("connection", (socket) => {
    console.info(`Client connected [id=${socket.id}]`);
     myClientList[socket.id] = socket;   
  });
  socket.on("disconnect", (socket) => {
    delete myClientList[socket.id];
  });

em seguida, chame seu cliente específico por id do objeto

myClientList[specificId].emit("blabla","somedata");

O Socket.IO permite "namespace" seus soquetes, o que significa essencialmente atribuir diferentes pontos de extremidade ou caminhos.

Isso pode ajudar: http://socket.io/docs/rooms-and-namespaces/