Nodejs的net模块与flash封装的客户端通讯时，如何实现向多个客户端广播？

songsunli 1楼

Node.js 的 net 模块与 Flash 封装的客户端通讯时，如何实现向多个客户端广播？

在使用 Node.js 的 net 模块创建服务器并与 Flash 封装的客户端进行通信时，我们经常需要向多个客户端广播消息。本文将介绍如何实现这一功能，并提供示例代码。

实现思路

创建服务器：使用 Node.js 的 net 模块创建一个 TCP 服务器。
存储客户端连接：创建一个数组或集合来存储所有已连接的客户端。
广播消息：当有新的客户端连接或者收到消息时，将消息广播给所有已连接的客户端。

示例代码

const net = require('net');

// 存储所有客户端连接
const clients = [];

// 创建服务器
const server = net.createServer((socket) => {
    console.log('New client connected');
    
    // 将新连接的客户端添加到客户端列表中
    clients.push(socket);

    // 处理客户端发送的消息
    socket.on('data', (data) => {
        console.log(`Received message: ${data.toString()}`);
        
        // 广播消息给所有客户端
        broadcast(data, socket);
    });

    // 当客户端断开连接时，从客户端列表中移除
    socket.on('end', () => {
        console.log('Client disconnected');
        clients.splice(clients.indexOf(socket), 1);
    });
});

// 广播函数
function broadcast(message, senderSocket) {
    clients.forEach((client) => {
        if (client !== senderSocket && client.writable) {
            client.write(message);
        }
    });
}

server.listen(8080, () => {
    console.log('Server listening on port 8080');
});

解释

创建服务器：
- 使用 net.createServer 创建一个新的 TCP 服务器，并设置回调函数处理客户端连接。
存储客户端连接：
- 在客户端连接时，将客户端对象（socket）添加到 clients 数组中。
- 当客户端断开连接时，从 clients 数组中移除该客户端对象。
广播消息：
- 在 socket.on('data') 回调函数中，每当接收到客户端的数据时，调用 broadcast 函数。
- broadcast 函数遍历 clients 数组，并将消息发送给所有其他客户端（不包括发送消息的客户端）。

通过这种方式，我们可以轻松地实现 Node.js 服务器与 Flash 客户端之间的多对多消息广播。

wuwangju 2楼

这自己实现很容易吧，保存好已连接的socket，然后想怎么群发就怎么群发。

yuanlaile 3楼

刚研究net模块，能有简单的实例吗，多谢大神

sinazl 4楼

这个是我用socket.io写的一个小项目的一段代码，和net中的socket是一样道理的，希望对你有帮助

var socketConns = {};//保存连接实例
    soceketIO.setMaxListeners(0);//不限制监听最大数
soceketIO.sockets.on("connection",function(socket)
{
    socket.setMaxListeners(0);//不限制监听最大数
    socket.volatile.emit("who",{msg:""});
    var clientSocket=new Object();
    socket.on("verify",function(data)
      {

        clientSocket.soct=socket;
        clientSocket.nickname=data.nickname;
        clientSocket.uid=data.uid;
        clientSocket.username=data.username;
          //var socID=socket.id;
        socketConns[socket.id]=clientSocket;
        for(var socId in socketConns)     //广播效果
          {
              if(socId===socket.id)
              { var userlist="[";
                for(var socId in socketConns)
                {
                  var oneuser="{nickname:"+"\""+socketConns[socId].nickname+"\""+",username:"+"\""+socketConns[socId].username+"\""+",uid:"+"\""+socketConns[socId].uid+"\""+"},";
                  userlist=userlist+oneuser;
                }
                 userlist=userlist.substr(0,userlist.length-1);
                 userlist=userlist+"]";
                socketConns[socId].soct.volatile.emit("userlist",{userlist:userlist});//发送聊天室列表
              }
              else
                {
                  socketConns[socId].soct.volatile.emit("new user",{msg:data.nickname+"加入聊天室!",nickname:socketConns[socket.id].nickname,uid:socketConns[socket.id].uid,username:socketConns[socket.id].username});  //volatile指可丢弃的数据
                }
          }

         hand_mysql.updateUserOnline(data.username,1);//设置数据库用户在线
      });

 socket.on("disconnect", function () {
                var leaveName=socketConns[socket.id].nickname;
                var leaveNameUid=socketConns[socket.id].uid;
                var leaveUsername=socketConns[socket.id].username;
                delete socketConns[socket.id];  
                for(var socId in socketConns) {  
                    socketConns[socId].soct.volatile.emit("userdisconnect", {msg:leaveName+"已经离开聊天室！",uid:leaveNameUid});  
                } 
               hand_mysql.updateUserOnline(leaveUsername,0); 
            });

	socket.on("msg",function(data)
	{
		console.log("Get a msg from client...");
    for(var socId in socketConns)     //广播效果
     {
       if(socId!=socket.id)
          socketConns[socId].soct.volatile.emit("user message",data);
     }
		//socket.broadcast.emit("user message",data);  //
	});


});</code></pre>



          
        
  
    
      

    
      sinazl
      5楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    但是，net模块没有类似
socket.broadcast.emit("user message",data);
这些广播用的方法，原来socket.io我也用过，但是浏览器不兼容，改成flash了，我知道存数组的方法，但是就是不知道广播的方法
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      nodeper
      6楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    net模块直接用
socket.write('aaaaa');
只能当前连接的接收到，别的没法接收
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      caililin
      7楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    var XML =
‘<cross-domain-policy>’ +
’<allow-access-from domain="" to-ports="" />’ +
’</cross-domain-policy>\0’

var net = require(‘net’),
	http = require(“http”),
	fs = require(“fs”),
	path = require(“path”),
	url = require(“url”),
	ctrl = require("./ctrl");
var server = net.createServer(function(socket){ 	
	socket.on(‘data’, function(data) {
		if(data.toString()==’<policy-file-request/>\0’){
			socket.end(XML);
			console.log(‘客户端flash已与服务器建立连接，可以正常传输数据了！’);
		}else{
			console.log(data.toString());
			socket.write(data.toString());
		}
	});
socket.on('error',function(){
	console.log('程序出现异常！');
});
});
server.listen(3944, ‘192.168.1.122’);
console.log(‘服务端已开启…’);
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      htzhanglong
      8楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    没有必要用broadcast，自己保存连接实例然后想给哪些连接发就给哪些发
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      htzhanglong
      9楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    socket.io的broadcast只是一个快捷方式，底层就是在所有在线的客户端socket上write。
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      itying888
      10楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    哦了，把他们添加到数组，多谢
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      vueper
      11楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    你说得对，多谢
   
    

   
    
      
    

     
    

   

   
 
  
  
    
      
    
  


          
        
  
    
      

    
      bupafengyu
      12楼
         
        
      
    
    
      
        
        
          
        
      
      
      
        
      
    
  
  

       
      


    要实现Node.js的net模块与Flash封装的客户端通讯时向多个客户端广播消息，可以采用以下步骤：

创建一个服务器实例。
存储所有已连接的客户端。
发送消息给所有客户端。

下面是示例代码，解释将简洁明了：
const net = require('net');

// 创建一个数组来存储所有的客户端连接
const clients = [];

// 创建TCP服务器
const server = net.createServer((socket) => {
    console.log('New client connected');

    // 将新的客户端添加到客户端列表中
    clients.push(socket);

    socket.on('data', (data) => {
        console.log(`Received data: ${data}`);
        // 广播数据给所有连接的客户端
        broadcast(data);
    });

    socket.on('end', () => {
        console.log('Client disconnected');
        // 从客户端列表中移除断开连接的客户端
        const index = clients.indexOf(socket);
        if (index > -1) {
            clients.splice(index, 1);
        }
    });

    socket.on('error', (err) => {
        console.error(`Socket error: ${err.message}`);
    });
});

function broadcast(message) {
    // 遍历客户端数组并发送消息
    clients.forEach((client) => {
        client.write(message);
    });
}

// 监听端口
server.listen(3000, () => {
    console.log('Server is listening on port 3000');
});
解释：

创建服务器：使用net.createServer()创建一个TCP服务器，并传入一个回调函数来处理每个新连接的客户端。
存储客户端：将每个新连接的客户端保存在一个数组clients中。
处理数据：当接收到客户端的数据时，调用broadcast()函数将数据发送给所有客户端。
广播消息：broadcast()函数遍历clients数组，通过write()方法将消息发送给每个客户端。
处理客户端断开：当客户端断开连接时，将其从clients数组中删除。
监听端口：让服务器开始监听指定的端口（本例中为3000）。

以上代码展示了如何使用Node.js的net模块与Flash客户端通讯时，向所有连接的客户端广播消息。