Question

我从socket.io + node.js开始，我知道如何在本地发送消息并广播socket.broadcast.emit()功能： - 所有连接的客户端都收到相同的消息。

现在，我想知道如何向特定客户端发送私人消息，我的意思是一个套接字用于2人之间的私人聊天（客户端到客户端流）。感谢。

Answer 1

您可以使用socket.io房间。从客户端发出一个事件（在这种情况下为“join”，可以是任何东西），带有任何唯一标识符（email，id）。

客户端：

var socket = io.connect('http://localhost');
socket.emit('join', {email: user1@example.com});

现在，从服务器端使用该信息为该用户创建一个独特的空间

服务器端：

var io = require('socket.io').listen(80);

io.sockets.on('connection', function (socket) {
  socket.on('join', function (data) {
    socket.join(data.email); // We are using room of socket io
  });
});

所以，现在每个用户都加入了以用户电子邮件命名的房间。因此，如果您想向特定用户发送一条消息，您只需要

服务器端：

io.sockets.in('user1@example.com').emit('new_msg', {msg: 'hello'});

客户端最后要做的就是收听“new_msg”事件。

客户端：

socket.on("new_msg", function(data) {
    alert(data.msg);
}

我希望你明白这一点。

Answer 2

当用户连接时，它应该使用必须唯一的用户名（例如电子邮件）向服务器发送消息。

一对用户名和套接字应该存储在这样的对象中：

var users = {
    'userA@example.com': [socket object],
    'userB@example.com': [socket object],
    'userC@example.com': [socket object]
}

在客户端上，使用以下数据向服务器发出一个对象：

{
    to:[the other receiver's username as a string],
    from:[the person who sent the message as string],
    message:[the message to be sent as string]
}

在服务器上，侦听消息。收到消息后，将数据发送给接收方。

users[data.to].emit('receivedMessage', data)

在客户端上，侦听来自名为“receivedMessage”的服务器的发出，并通过读取数据来处理它来自何处以及发送的消息。

Answer 3

<强> SURE：简单地说，

这就是你需要的：

io.to(socket.id).emit("event", data);

每当用户加入服务器时，将生成包括ID的套接字详细信息。这个ID确实有助于向特定的人发送消息。

首先我们需要将所有socket.id存储在数组中，

var people={};

people[name] =  socket.id;

此处name是接收者名称。例如：

people["ccccc"]=2387423cjhgfwerwer23;

所以，现在我们可以在发送消息的时候用接收者名称获取socket.id：

为此我们需要知道receivername。您需要向服务器发出接收者名称。

最后一件事是：

 socket.on('chat message', function(data){
io.to(people[data.receiver]).emit('chat message', data.msg);
});

希望这对你有用。

祝你好运!!

Answer 4

您可以参考socket.io rooms。当你握手套接字时 - 你可以将他加入到命名的房间，例如“user。＃{userid}”。

之后，您可以通过方便的名称向任何客户端发送私人消息，例如：

io.sockets.in（'user.125'）。emit（'new_message'，{text：“Hello world”}）

在上面的操作中，我们将“new_message”发送给用户“125”。

感谢。

Answer 5

在我们公司的项目中，我们使用“房间”方法，它的名称是对话中所有用户的用户ID组合作为唯一标识符（我们的实现更像是facebook messenger），例如：

| id |名称 | 1 |斯科特 | 2 |苏珊

“room”名称将为“1-2”（ids是按顺序排列的）。并且在断开连接时socket.io会自动清理房间

通过这种方式，您只能向该房间发送消息，并且仅向在线（已连接）用户发送消息（在整个服务器中发送的包较少）。

Answer 6

让我通过socket.io房间使其更简单。请求具有唯一标识符的服务器加入服务器。在这里，我们使用电子邮件作为唯一标识符。

Client Socket.io

socket.on('connect', function () {
  socket.emit('join', {email: user@example.com});
});

用户加入服务器后，为该用户创建一个房间

Server Socket.io

io.on('connection', function (socket) {
   socket.on('join', function (data) {    
    socket.join(data.email);
  });
});

现在我们都准备加入了。让我们从服务器to的房间发射东西，以便用户可以收听。

Server Socket.io

io.to('user@example.com').emit('message', {msg: 'hello world.'});

让我们通过侦听客户端的message事件来最终确定主题

socket.on("message", function(data) {
  alert(data.msg);
});

来自Socket.io rooms

的参考

Answer 7

这是 Android 客户端 + Socket IO 服务器的完整解决方案（代码很多，但有效）。谈到 socket io 时，似乎缺乏对 Android 和 IOS 的支持，这是一种悲剧。

基本上通过加入来自 mysql 或 mongo 的用户唯一 id 然后对其进行排序来创建房间名称（在 Android 客户端中完成并发送到服务器）。所以每对房间都有一个独特但共同的房间名称。然后就在那个房间里聊天。

有关如何在 Android 中创建空间的快速参考

 // Build The Chat Room
        if (Integer.parseInt(mySqlUserId) < Integer.parseInt(toMySqlUserId)) {
            room = "ic" + mySqlUserId + toMySqlUserId;
        } else {
            room = "ic" + toMySqlUserId + mySqlUserId;
        }

完整作品

包 Json

"dependencies": {
    "express": "^4.17.1",
    "socket.io": "^2.3.0"
  },
  "devDependencies": {
    "nodemon": "^2.0.6"
  }

套接字 IO 服务器

app = require('express')()
http = require('http').createServer(app)
io = require('socket.io')(http)

app.get('/', (req, res) => {

    res.send('Chat server is running on port 5000')
})

io.on('connection', (socket) => {

    // console.log('one user connected ' + socket.id);

    // Join Chat Room
    socket.on('join', function(data) {

        console.log('======Joined Room========== ');
        console.log(data);

        // Json Parse String To Access Child Elements
        var messageJson = JSON.parse(data);
        const room = messageJson.room;
        console.log(room);

        socket.join(room);

    });

    // On Receiving Individual Chat Message (ic_message)
    socket.on('ic_message', function(data) {
        console.log('======IC Message========== ');
        console.log(data);

        // Json Parse String To Access Child Elements
        var messageJson = JSON.parse(data);
        const room = messageJson.room;
        const message = messageJson.message;

        console.log(room);
        console.log(message);

        // Sending to all clients in room except sender
        socket.broadcast.to(room).emit('new_msg', {
            msg: message
        });

    });

    socket.on('disconnect', function() {
        console.log('one user disconnected ' + socket.id);
    });

});

http.listen(5000, () => {

    console.log('Node app is running on port 5000')
})

Android Socket IO 类

public class SocketIOClient {

    public Socket mSocket;

    {
        try {
            mSocket = IO.socket("http://192.168.1.5:5000");
        } catch (URISyntaxException e) {
            throw new RuntimeException(e);
        }
    }

    public Socket getSocket() {
        return mSocket;
    }
}

Android 活动

public class IndividualChatSocketIOActivity extends AppCompatActivity {

    // Activity Number For Bottom Navigation Menu
    private final Context mContext = IndividualChatSocketIOActivity.this;

    // Strings
    private String mySqlUserId;
    private String toMySqlUserId;

    // Widgets
    private EditText etTextMessage;
    private ImageView ivSendMessage;

    // Socket IO
    SocketIOClient socketIOClient = new SocketIOClient();
    private String room;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_chat);

        // Widgets
        etTextMessage = findViewById(R.id.a_chat_et_text_message);
        ivSendMessage = findViewById(R.id.a_chat_iv_send_message);

        // Get The MySql UserId from Shared Preference
        mySqlUserId = StartupMethods.getFromSharedPreferences("shared",
                                                              "id",
                                                              mContext);

        // Variables From Individual List Adapter
        Intent intent = getIntent();

        if (intent.hasExtra("to_id")) {

            toMySqlUserId = Objects.requireNonNull(Objects.requireNonNull(getIntent().getExtras())
                                                          .get("to_id"))
                                   .toString();
        }

        // Build The Chat Room
        if (Integer.parseInt(mySqlUserId) < Integer.parseInt(toMySqlUserId)) {
            room = "ic" + mySqlUserId + toMySqlUserId;
        } else {
            room = "ic" + toMySqlUserId + mySqlUserId;
        }

        connectToSocketIO();

        joinChat();

        leaveChat();

        getChatMessages();

        sendChatMessages();

    }

    @Override
    protected void onPause() {
        super.onPause();

    }

    private void connectToSocketIO() {

        socketIOClient.mSocket = socketIOClient.getSocket();
        socketIOClient.mSocket.on(Socket.EVENT_CONNECT_ERROR,
                                  onConnectError);
        socketIOClient.mSocket.on(Socket.EVENT_CONNECT_TIMEOUT,
                                  onConnectError);
        socketIOClient.mSocket.on(Socket.EVENT_CONNECT,
                                  onConnect);
        socketIOClient.mSocket.on(Socket.EVENT_DISCONNECT,
                                  onDisconnect);
        socketIOClient.mSocket.connect();
    }

    private void joinChat() {

        // Prepare To Send Data Through WebSockets
        JSONObject jsonObject = new JSONObject();

        // Header Fields
        try {

            jsonObject.put("room",
                           room);

            socketIOClient.mSocket.emit("join",
                                        String.valueOf(jsonObject));

        } catch (JSONException e) {
            e.printStackTrace();
        }

    }

    private void leaveChat() {
    }

    private void getChatMessages() {

        socketIOClient.mSocket.on("new_msg",
                                  new Emitter.Listener() {
                                      @Override
                                      public void call(Object... args) {
                                          try {
                                              JSONObject messageJson = new JSONObject(args[0].toString());
                                              String message = String.valueOf(messageJson);

                                              runOnUiThread(new Runnable() {
                                                  @Override
                                                  public void run() {
                                                      Toast.makeText(IndividualChatSocketIOActivity.this,
                                                                     message,
                                                                     Toast.LENGTH_SHORT)
                                                           .show();
                                                  }
                                              });
                                          } catch (JSONException e) {
                                              e.printStackTrace();
                                          }
                                      }
                                  });
    }

    private void sendChatMessages() {

        ivSendMessage.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {

                String message = etTextMessage.getText()
                                              .toString()
                                              .trim();

                // Prepare To Send Data Thru WebSockets
                JSONObject jsonObject = new JSONObject();

                // Header Fields
                try {
                    jsonObject.put("room",
                                   room);

                    jsonObject.put("message",
                                   message);

                    socketIOClient.mSocket.emit("ic_message",
                                                String.valueOf(jsonObject));

                } catch (JSONException e) {
                    e.printStackTrace();
                }

            }
        });
    }

    public Emitter.Listener onConnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(IndividualChatSocketIOActivity.this,
                                   "Connected To Socket Server",
                                   Toast.LENGTH_SHORT)
                         .show();

                }
            });

            Log.d("TAG",
                  "Socket Connected!");
        }
    };

    private Emitter.Listener onConnectError = new Emitter.Listener() {
        @Override
        public void call(Object... args) {

            runOnUiThread(new Runnable() {
                @Override
                public void run() {

                }
            });
        }
    };
    private Emitter.Listener onDisconnect = new Emitter.Listener() {
        @Override
        public void call(Object... args) {

            runOnUiThread(new Runnable() {
                @Override
                public void run() {

                }
            });
        }
    };

}

Android Gradle

// SocketIO
implementation ('io.socket:socket.io-client:1.0.0') {
    // excluding org.json which is provided by Android
    exclude group: 'org.json', module: 'json'
}

如何使用socket.io向特定客户端发送消息

7 个答案: