nodejs实时通讯

⑴ Nodejs学习笔记之NET模块

一，开篇分析
从今天开始，我们来深入具体的模块学习，这篇文章是这个系列文章的第三篇，前两篇主要是以理论为主，相信大家在前两篇的学习中，
对NodeJS也有一个基本的认识，没事！！！趁热打铁，让我们继续将NodeJS进行到底，好了废话不多说，直接进入今天的主题
“Net模块”
，那么”Net“应该如何理解那？
它是做什么用的那？（Net模块可用于创建Socket服务器或Socket客户端。NodeJS
的数据通信，最基础的两个模块是
Net
和
Http，前者是基于
Tcp
的封装，后者本质还是
Tcp
层，只不过做了比较多的数据封装，我们视为表现层）。
这里参考一下NodeJS
“http.js”
中的源码：
从图中不难看出
HttpServer继承了Net类，具有了相关的通信能力，做了比较多的数据封装，我们视为更高级的表现层。
扩展知识（以下是“inherits”的源码）：
复制代码
代码如下:
exports.inherits
=
function(ctor,
superCtor)
{

ctor.super_
=
superCtor;

ctor.prototype
=
Object.create(superCtor.prototype,
{

constructor:
{

value:
ctor,

enumerable:
false,

writable:
true,

configurable:
true

}

});
};
功能是实现继承复用。
刚才做了一个简要的概述，里面有一些常用的概念，这里做个简短的概念普及介绍：
（1），TCP/IP------TPC/IP协议是传输层协议，主要解决数据如何在网络中传输。
（2），Socket------socket则是对TCP/IP协议的封装和应用(程序层面)。
（3），Http------HTTP是应用层协议，主要解决如何包装数据。
（4），网络七层模型------物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。
总结一下：Socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口(API)。
从而形成了我们知道的一些最基本的函数接口，比如Create、Listen、Connect、Accept、Send、Read和Write等等。
TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口
实际上，传输层的TCP是基于网络层的IP协议的，而应用层的HTTP协议又是基于传输层的TCP协议的，而Socket本身不算是协议，就像上面所说，它只是提供了一个针对TCP或者UDP编程的接口。
二，体验一把
好了，概念我们也有了，来个例子：
1，建立server.js
复制代码
代码如下:
var
net
=
require('net')
;
var
server
=
net.createServer(function(c)
{
//
Connection监听器

console.log("服务器已连接")
;

c.on("end",
function()
{

console.log("服务器已断开")
;

})
;

c.write("Hello,Bigbear
! ")
;

c.pipe(c)
;
})
;
server.listen(8124,
function()
{
//
Listening监听器

console.log("服务器已绑定")
;
})
;
2，建立client.js
复制代码
代码如下:
var
net
=
require('net')
;
var
client
=
net.connect({

port:
8124
},function(){
//
connect监听器

console.log("客户端已连接")
;

client.write('Hello,Baby
! ')
;
});
client.on("data",
function(data)
{

console.log(data.toString())
;

client.end()
;
});
client.on("end",
function(){

console.log("客户端断开连接")
;
})
;
分析一下：
服务端------net.createServer创建一个
TCP
服务，这个服务绑定（server.listen）在
8124
这个端口上，创建
Server
后我们看到有一个回调函数，
在调用上面函数的时候传入一个参数，这个参数也是函数，并且接受了
socket
，这个由其他方法构造的一个管道（pipe），他的作用就是用来数据交互的。
pipe
是需要
Client
跟
Server
打招呼才能建立的，如果此刻没有客户端访问
Server，这个
socket
就不会存在了。
客户端------net.connect顾名思义，就是连接到服务端，第一个参数是对象，设置端口（port）为
8124，也就是我们服务器监听的端口，由于没有设置
host
参数，那默认就是
localhost
（本地）。
在
Server
中，socket
是管道的一端，而在
client
中，client
本身就是管道的一端，如果是多个客户端连接
Server，Server
会新建多个
socket，每个
socket
对应一个
client。
运行结果：
三，案例引入
（1），下面代码仅仅是服务器向客户端输出一段文本，完成服务端到客户端的单向通讯。
复制代码
代码如下:
//
Sever
-->
Client
的单向通讯
var
net
=
require('net');
var
chatServer
=
net.createServer();
chatServer.on('connection',
function(client)
{

client.write('Hi! ');
//
服务端向客户端输出信息，使用
write()
方法

client.write('Bye! ');

client.end();
//
服务端结束该次会话
});
chatServer.listen(9000);
Telnet测试一下：telnet127.0.0.1:9000
执行
telnet后，与服务点连接，反馈
Hi!
Bye!
的字符，并立刻结束服务端程序终止连接。
如果我们要服务端接到到客户端的信息？
可以监听
server.data
事件并且不要中止连接（否则会立刻结束无法接受来自客户端的消息）。
（2），监听
server.data
事件并且不要中止连接（否则会立刻结束无法接受来自客户端的消息）。
复制代码
代码如下:
//
在前者的基础上，实现
Client
-->
Sever
的通讯，如此一来便是双向通讯
var
net
=
require('net');
var
chatServer
=
net.createServer(),

clientList
=
[];
chatServer.on('connection',
function(client)
{

//
JS
可以为对象自由添加属性。这里我们添加一个
name
的自定义属性，用于表示哪个客户端（客户端的地址+端口为依据）

client.name
=
client.remoteAddress
+
':'
+
client.remotePort;

client.write('Hi
'
+
client.name
+
'! ');

clientList.push(client);

client.on('data',
function(data)
{

broadcast(data,
client);//
接受来自客户端的信息

});
});
function
broadcast(message,
client)
{

for(var
i=0;i<clientList.length;i+=1)
{

if(client
!==
clientList[i])
{

clientList[i].write(client.name
+
"
says
"
+
message);

}

}
}
chatServer.listen(9000);
上面是不是一个完整功能的代码呢？我们说还有一个问题没有考虑进去：那就是一旦某个客户端退出，却仍保留在
clientList里面，这明显是一个空指针。
（3），处理clientList
复制代码
代码如下:
chatServer.on('connection',
function(client)
{

client.name
=
client.remoteAddress
+
':'
+
client.remotePort

client.write('Hi
'
+
client.name
+
'! ');

clientList.push(client)

client.on('data',
function(data)
{

broadcast(data,
client)

})

client.on('end',
function()
{

clientList.splice(clientList.indexOf(client),
1);
//
删除数组中的制定元素。

})
})
NodeTCPAPI已经为我们提供了
end
事件，即客户端中止与服务端连接的时候发生。
（4），优化broadcast
复制代码
代码如下:
function
broadcast(message,
client)
{

var
cleanup
=
[]

for(var
i=0;i<clientList.length;i+=1)
{

if(client
!==
clientList[i])
{

if(clientList[i].writable)
{
//
先检查
sockets
是否可写

clientList[i].write(client.name
+
"
says
"
+
message)

}
else
{

cleanup.push(clientList[i])
//
如果不可写，收集起来销毁。销毁之前要
Socket.destroy()
用
API
的方法销毁。

clientList[i].destroy()

}

}

}
//Remove
dead
Nodes
out
of
write
loop
to
avoid
trashing
loop
index

for(i=0;i<cleanup.length;i+=1)
{

clientList.splice(clientList.indexOf(cleanup[i]),
1)

}
}
注意的是一旦
“end”
没有被触发，会出现异常，所以才做优化工作。
（5），NetAPI中还提供一个
error
事件，用于捕捉客户端的异常
复制代码
代码如下:
client.on('error',
function(e)
{

console.log(e);
});
四，总结一下
1，理解开篇的相关概念
2，认识Http与Net模块之间的关系
3，结合本文的例子，查阅相关api去实践
4，socket客户端与服务器端之间的通信思想
5，有兴趣可以完善一下那个聊天室的例子

⑵ 怎么连接nodejs服务器

前面已经学习了WebSocket API，包括事件、方法和属性。详情：WebSocket(二)--APIWebSocket是基于事件驱动，支持全双工通信。下面通过三个简单例子体验一下。

简单开始

1.安装node。/

2.安装ws模块

ws：是nodejs的一个WebSocket库，可以用来创建服务。

3.server.js

在项目里面新建一个server.js，创建服务，指定8181端口，将收到的消息log出来。

//建立连接
var ws = new WebSocket("ws://localhost:8181"); var nickname = "";
ws.onopen = function (e) {
console.log('Connection to server opened');
} //显示
function appendLog(type, nickname, message) { if (typeof message == "undefined") return; var messages = document.getElementById('messages'); var messageElem = document.createElement("li"); var preface_label; if (type === 'notification') {
preface_label = "<span class="label label-info">*</span>";
} else if (type == 'nick_update') {
preface_label = "<span class="label label-warning">*</span>";
} else {
preface_label = "<span class="label label-success">"
+ nickname + "</span>";
} var message_text = "<h2>" + preface_label + "&nbsp;&nbsp;"
+ message + "</h2>";
messageElem.innerHTML = message_text;
messages.appendChild(messageElem);
} //收到消息处理
ws.onmessage = function (e) { var data = JSON.parse(e.data);
nickname = data.nickname;
appendLog(data.type, data.nickname, data.message);
console.log("ID: [%s] = %s", data.id, data.message);
}
ws.onclose = function (e) {
appendLog("Connection closed");
console.log("Connection closed");
} //发送消息
function sendMessage() { var messageField = document.getElementById('message'); if (ws.readyState === WebSocket.OPEN) {
ws.send(messageField.value);
}
messageField.value = '';
messageField.focus();
} //修改名称
function changName() { var name = $("#name").val(); if (ws.readyState === WebSocket.OPEN) {
ws.send("/nick " + name);
}
}

运行结果：

页面关闭之后，连接马上断开。

这种实时响应的体验简直不能太爽，代码也清爽了，前端体验也更好，客户端不用一直发请求，服务端不用等着被轮询。

小结：上面例子的代码都很好理解，接下来学习WebSocket协议。

⑶ c#怎么向nodejs的socket.io发送请求

1. 简介

首先是Socket.IO的官方网站：http://socket.io

官网非常简洁，甚至没有API文档，只有一个简单的“How to use”可以参考。因为Socket.IO就跟官网一样简洁好用易上手。

那么Socket.IO到底是什么呢？Socket.IO是一个WebSocket库，包括了客户端的js和服务器端的nodejs，它的目标是构建可以在不同浏览器和移动设备上使用的实时应用。它会自动根据浏览器从WebSocket、AJAX长轮询、Iframe流等等各种方式中选择最佳的方式来实现网络实时应用，非常方便和人性化，而且支持的浏览器最低达IE5.5，应该可以满足绝大部分需求了。

2. 安装部署

2.1 安装

首先安装非常简单，在node.js环境下只要一句：

复制代码
代码如下:

npm install socket.io

2.2 结合express来构建服务器

express是一个小巧的Node.js的Web应用框架，在构建HTTP服务器时经常使用到，所以直接以Socket.IO和express为例子来讲解。

复制代码
代码如下:

var express = require('express')
,
app = express()
, server = require('http').createServer(app)
, io
= require('socket.io').listen(server);
server.listen(3001);

若不使用express，请参考socket.io/#how-to-use

3. 基本使用方法

主要分为服务器端和客户端两段代码，都非常简单。

Server（app.js）：

复制代码
代码如下:

//接上面的代码
app.get('/', function (req,
res) {
res.sendfile(__dirname + '/index.html');});

io.sockets.on('connection', function (socket) {
socket.emit('news', {
hello: 'world' });
socket.on('other event', function (data) {

console.log(data);
});
});

首先io.sockets.on函数接受字符串"connection"作为客户端发起连接的事件，当连接成功后，调用带有socket参数的回调函数。我们在使用socket.IO的时候，基本上都在这个回调函数里面处理用户的请求。

socket最关键的是emit和on两个函数，前者提交（发出）一个事件（事件名称用字符串表示），事件名称可以自定义，也有一些默认的事件名称，紧接着是一个对象，表示向该socket发送的内容；后者接收一个事件（事件名称用字符串表示），紧接着是收到事件调用的回调函数，其中data是收到的数据。

在上面的例子中，我们发送了news事件和收到了other
event事件，那么客户端应该会有对应的接收和发送事件。没错，客户端代码和服务器正好相反，而且非常相似。

Client（client.js）

复制代码
代码如下:

<script
src="/socket.io/socket.io.js"></script>
<script>
var
socket = io.connect('http://localhost');
socket.on('news', function
(data) {
console.log(data);
socket.emit('other event', {
my: 'data' });
});
</script>

有两点要注意的：socket.io.js路径要写对，这个js文件实际放在了服务器端的node_moles文件夹中，在请求这个文件时会重定向，因此不要诧异服务器端不存在这个文件但为什么还能正常工作。当然，你可以把服务器端的socket.io.js这个文件拷贝到本地，使它成为客户端的js文件，这样就不用每次都向Node服务器请求这个js文件，增强稳定性。第二点是要用var
socket =
io.connect('网站地址或ip');来获取socket对象，接着就可以使用socket来收发事件。关于事件处理，上面的代码表示收到“news”事件后，打印收到的数据，并向服务器发送“other
event”事件。

注：内置默认的事件名例如“disconnect”表示客户端连接断开，“message”表示收到消息等等。自定义的事件名称，尽量不要跟Socket.IO中内置的默认事件名重名，以免造成不必要的麻烦。

4. 其他常用API

1).向所有客户端广播：socket.broadcast.emit('broadcast message');

2).进入一个房间（非常好用！相当于一个命名空间，可以对一个特定的房间广播而不影响在其他房间或不在房间的客户端）：socket.join('your
room name');

3).向一个房间广播消息（发送者收不到消息）：socket.broadcast.to('your room name').emit('broadcast
room message');

4).向一个房间广播消息（包括发送者都能收到消息）（这个API属于io.sockets）：io.sockets.in('another room
name').emit('broadcast room message');

5).强制使用WebSocket通信：（客户端）socket.send('hi')，（服务器）用socket.on('message',
function(data){})来接收。

5. 使用Socket.IO构建一个聊天室

最后，我们通过一个简单的实例来结束本篇。用Socket.IO构建一个聊天室就是50行左右的代码的事情，实时聊天效果也非常好。以下贴出关键代码：

Server（socketChat.js）

复制代码
代码如下:

//一个客户端连接的字典，当一个客户端连接到服务器时，
//会产生一个唯一的socketId，该字典保存socketId到用户信息（昵称等）的映射
var
connectionList = {};

exports.startChat = function (io) {
io.sockets.on('connection',
function (socket) {
//客户端连接时，保存socketId和用户名
var socketId =
socket.id;
connectionList[socketId] = {
socket:
socket
};

//用户进入聊天室事件，向其他在线用户广播其用户名
socket.on('join', function
(data) {
socket.broadcast.emit('broadcast_join',
data);
connectionList[socketId].username =
data.username;
});

//用户离开聊天室事件，向其他在线用户广播其离开
socket.on('disconnect', function
() {
if (connectionList[socketId].username) {

socket.broadcast.emit('broadcast_quit', {
username:
connectionList[socketId].username
});

}
delete connectionList[socketId];
});

//用户发言事件，向其他在线用户广播其发言内容
socket.on('say', function (data)
{
socket.broadcast.emit('broadcast_say',{

username: connectionList[socketId].username,
text:
data.text
});
});
})
};

Client(socketChatClient.js)

复制代码
代码如下:

var socket =
io.connect('http://localhost');
//连接服务器完毕后，马上提交一个“加入”事件，把自己的用户名告诉别人
socket.emit('join',
{
username: 'Username hehe'
});

//收到加入聊天室广播后，显示消息
socket.on('broadcast_join', function (data) {

console.log(data.username + '加入了聊天室');
});

//收到离开聊天室广播后，显示消息
socket.on('broadcast_quit', function(data) {

console.log(data.username + '离开了聊天室');
});

//收到别人发送的消息后，显示消息
socket.on('broadcast_say', function(data) {

console.log(data.username + '说: ' + data.text);
});

//这里我们假设有一个文本框textarea和一个发送按钮.btn-send
//使用jQuery绑定事件
$('.btn-send').click(function(e)
{
//获取文本框的文本
var text = $('textarea').val();

//提交一个say事件，服务器收到就会广播
socket.emit('say', {
username: 'Username
hehe'
text: text
});
});

⑷ 什么是node.js

1、起源
Node.js起源于2009年3月。最初Ryan Dahl是为了构建一个高性能的文本服务器，而node.js是他在寻找一种更高提升web服务器性能发现的，事件驱动、非阻塞I/O这种方式能更好的提高性能。随着Nodejs的不断发展，Nodejs渐渐演变成一种构建网络应用的基础框架，并发展为一个不共享任何资源的单线程、单进程系统，但包含了很适合网络的库，这样Nodejs就为构建大型分布式应用提供了基础设施。他们的目标都是为了构建快速、可伸缩的网络应用平台。它自身非常简单、采用通信协议来组织许多的Node，非常容易通过拓展来达成构建大型网络应用的目的。
2、node.js简介
Node.js是一个可以快速构建网络服务及应用的平台。该平台的构建是基于Chrome'sJavaScriptruntime，也就是说，实际上它是对GoogleV8引擎(应用于GoogleChrome浏览器)进行了封装。Nodejs不是一个js应用而是一个js运行平台。其是由C++编写而成。但是Nodejs是一个后端的运行环境。因此你可以编写系统级或者服务器端的js让Nodejs帮你执行。
3、优势
1)node.js采用事件驱动、异步编程，为网络服务而设计。
2)node.js采用非阻塞模式的IO处理，可以使node.js在相对低系统资源耗，拥有出色的负载能力，非常适合用作依赖其它IO资源的中间层服务。
3)node.js轻量高效，可以认为是数据密集型分布式部署环境下的实时应用系统的完美解决方案。
4)使用node.js配合CoffeeScript 写异步操作链非常便利，相比之下Tornado无论是写命名函数的回调，还是 yield 一个 Task 都没那么自然。