大熊君大话NodeJS之------Stream模块

浏览数：16 / 时间：2015年06月09日

一，开篇分析

流是一个抽象接口，被 Node 中的很多对象所实现。比如对一个 HTTP 服务器的请求是一个流，stdout 也是一个流。流是可读，可写或兼具两者的。

最早接触Stream是从早期的unix开始的，数十年的实践证明Stream 思想可以很简单的开发出一些庞大的系统。

在unix里，Stream是通过 "|" 实现的。在node中，作为内置的stream模块，很多核心模块和三方模块都使用到。

和unix一样，node stream主要的操作也是.pipe()，使用者可以使用反压力机制来控制读和写的平衡。

Stream 可以为开发者提供可以重复使用统一的接口，通过抽象的Stream接口来控制Stream之间的读写平衡。

一个TCP连接既是可读流，又是可写流，而Http连接则不同，一个http request对象是可读流，而http response对象则是可写流。

流的传输过程默认是以buffer的形式传输的，除非你给他设置其他编码形式,以下是一个例子：

1 var http = require(‘http‘) ;
2  var server = http.createServer(function(req,res){
3     res.writeHeader(200, {‘Content-Type‘: ‘text/plain‘}) ;
4     res.end("Hello,大熊！") ;
5  }) ;
6  server.listen(8888) ;
7  console.log("http server running on port 8888 ...") ;

运行后会有乱码出现，原因就是没有设置指定的字符集，比如：“utf-8” 。

修改一下就好：

1  var http = require(‘http‘) ;
2  var server = http.createServer(function(req,res){
3     res.writeHeader(200,{
4         ‘Content-Type‘ : ‘text/plain;charset=utf-8‘  // 添加charset=utf-8
5     }) ;
6     res.end("Hello,大熊！") ;
7  }) ;
8  server.listen(8888) ;
9  console.log("http server running on port 8888 ...") ;

运行结果：

技术分享

为什么使用Stream

node中的I/O是异步的，因此对磁盘和网络的读写需要通过回调函数来读取数据，下面是一个文件下载例子

上代码：

1 var http = require(‘http‘) ;
2 var fs = require(‘fs‘) ;
3 var server = http.createServer(function (req, res) {
4     fs.readFile(__dirname + ‘/data.txt‘, function (err, data) {
5         res.end(data);
6     }) ;
7 }) ;
8 server.listen(8888) ;

代码可以实现需要的功能，但是服务在发送文件数据之前需要缓存整个文件数据到内存，如果"data.txt"文件很
大并且并发量很大的话，会浪费很多内存。因为用户需要等到整个文件缓存到内存才能接受的文件数据，这样导致
用户体验相当不好。不过还好(req,res)两个参数都是Stream，这样我们可以用fs.createReadStream()代替fs.readFile()。如下：

1 var http = require(‘http‘) ;
2 var fs = require(‘fs‘) ;
3 var server = http.createServer(function (req, res) {
4     var stream = fs.createReadStream(__dirname + ‘/data.txt‘) ;
5     stream.pipe(res) ;
6 }) ;
7 server.listen(8888) ;

.pipe()方法监听fs.createReadStream()的‘data‘ 和‘end‘事件，这样"data.txt"文件就不需要缓存整
个文件，当客户端连接完成之后马上可以发送一个数据块到客户端。使用.pipe()另一个好处是可以解决当客户
端延迟非常大时导致的读写不平衡问题。

有五种基本的Stream：readable，writable，transform，duplex，and "classic” 。（具体使用请自己查阅api）

二，实例引入

当内存中无法一次装下需要处理的数据时，或者一边读取一边处理更加高效时，我们就需要用到数据流。NodeJS中通过各种Stream来提供对数据流的操作。

以大文件拷贝程序为例，我们可以为数据源创建一个只读数据流，示例如下：

1 var rs = fs.createReadStream(pathname);
2 rs.on(‘data‘, function (chunk) {
4     doSomething(chunk) ; // 具体细节自己任意发挥
5 });
6 rs.on(‘end‘, function () {
8     cleanUp() ;
9 }) ;

代码中data事件会源源不断地被触发，不管doSomething函数是否处理得过来。代码可以继续做如下改造，以解决这个问题。

 1 var rs = fs.createReadStream(src) ;
 2 rs.on(‘data‘, function (chunk) {
 3     rs.pause() ;
 4     doSomething(chunk, function () {
 5         rs.resume() ;
 6     }) ;
 7 }) ;
 8 rs.on(‘end‘, function () {
 9     cleanUp();
10 })  ;

给doSomething函数加上了回调，因此我们可以在处理数据前暂停数据读取，并在处理数据后继续读取数据。

此外，我们也可以为数据目标创建一个只写数据流，如下：

1 var rs = fs.createReadStream(src) ;
2 var ws = fs.createWriteStream(dst) ;
3 rs.on(‘data‘, function (chunk) {
4     ws.write(chunk);
5 }) ;
6 rs.on(‘end‘, function () {
7     ws.end();
8 }) ;

doSomething换成了往只写数据流里写入数据后，以上代码看起来就像是一个文件拷贝程序了。但是以上代码存在上边提到的问题，如果写入速度跟不上读取速度的话，只写数据流内部的缓存会爆仓。我们可以根据.write方法的返回值来判断传入的数据是写入目标了，还是临时放在了缓存了，并根据drain事件来判断什么时候只写数据流已经将缓存中的数据写入目标，可以传入下一个待写数据了。因此代码如下：

 1 var rs = fs.createReadStream(src) ;
 2 var ws = fs.createWriteStream(dst) ;
 3 rs.on(‘data‘, function (chunk) {
 4     if (ws.write(chunk) === false) {
 5         rs.pause() ;
 6     }
 7 }) ;
 8 rs.on(‘end‘, function () {
 9     ws.end();
10 });
11 ws.on(‘drain‘, function () {
12     rs.resume();
13 }) ;

最终实现了数据从只读数据流到只写数据流的搬运，并包括了防爆仓控制。因为这种使用场景很多，例如上边的大文件拷贝程序，NodeJS直接提供了.pipe方法来做这件事情，其内部实现方式与上边的代码类似。

下面是一个更加完整的复制文件的过程：

 1 var fs = require(‘fs‘),
 2   path = require(‘path‘),
 3   out = process.stdout;
 4 
 5 var filePath = ‘/bb/bigbear.mkv‘;
 6 
 7 var readStream = fs.createReadStream(filePath);
 8 var writeStream = fs.createWriteStream(‘file.mkv‘);
 9 
10 var stat = fs.statSync(filePath);
11 
12 var totalSize = stat.size;
13 var passedLength = 0;
14 var lastSize = 0;
15 var startTime = Date.now();
16 
17 readStream.on(‘data‘, function(chunk) {
18 
19   passedLength += chunk.length;
20 
21   if (writeStream.write(chunk) === false) {
22     readStream.pause();
23   }
24 });
25 
26 readStream.on(‘end‘, function() {
27   writeStream.end();
28 });
29 
30 writeStream.on(‘drain‘, function() {
31   readStream.resume();
32 });
33 
34 setTimeout(function show() {
35   var percent = Math.ceil((passedLength / totalSize) * 100);
36   var size = Math.ceil(passedLength / 1000000);
37   var diff = size - lastSize;
38   lastSize = size;
39   out.clearLine();
40   out.cursorTo(0);
41   out.write(‘已完成‘ + size + ‘MB, ‘ + percent + ‘%, 速度：‘ + diff * 2 + ‘MB/s‘);
42   if (passedLength < totalSize) {
43     setTimeout(show, 500);
44   } else {
45     var endTime = Date.now();
46     console.log();
47     console.log(‘共用时：‘ + (endTime - startTime) / 1000 + ‘秒。‘);
48   }
49 }, 500);