nodejs学习笔记 —— 异步编程解决方案

在js或者node编程中,由于异步的频繁和广度使用,使得回调和嵌套的深度导致编程的体验遇到一些挑战,如果写出优雅和好看的代码,本文主要针对异步编程的主流方案做一些总结

1、事件发布/订阅模式

事件监听器模式是一种广泛用于异步编程的模式, 是回调函数的事件化,又称发布/订阅模式, node自身提供events模块,是该模式的一个简单实现。

EventPorxy 

2、promise/deferrd模式

在2009年被Kris Zyp抽象为一个提议草案,发布在CommonJS规范中, 目前,CommonJS草案中已经包括Promise/A、Promise/B、Promise/D这些异步模型。由于Promise/A较为常用也较为简单,只需要具备then()方法即可。所以先介绍一些改模式。

一般来说,then()的方法定义如下:

then(fulfilledHandler, errorHandler, progressHandler)

Promises/A

通过继承Node的events模块,我们可以实现一个简单Promise模块。

promise部分

var Promise = function() {
    EventEmitter.call(this);
}
util.inherits(Promise, EventEmitter); // util是node自带的工具类
 
Promise.prototype.then = function(fulfilledHandler, errorHandler, progressHandler) {
    if(typeof fulfilledHandler === "function") {
        this.once('success', fulfilledHandler);
    }
    if(typeof errorHandler === "function") {
        this.once('error', errorHandler);
    }
    if(typeof progressHandler === "function") {
        this.on('progress', progressHandler);
    }
    return this;
}
 

deferred部分

var Deferred = function() {
    this.state = 'unfulfilled';
    this.promise = new Promise();
}
 
Deferred.prototype.resolve = function(obj) {
    this.state = 'fulfilled';
    this.promise.emit('success', obj);
}
 
Deferred.prototype.reject = function(obj) {
    this.state = 'failed';
    this.promise.emit('error', obj);
}
 
Deferred.prototype.progress = function(obj) {
    this.promise.emit('progress', obj);
}

使用

function readFile(file, encoding) {
      var deferred = new Deferred();
      fs.readFile(file, encoding, deferred.resolve);
      return deferred.promise;
}

readFile('/test.txt',  'utf-8').then(function(data) {
      ... 
}, function(err) {
      ...
});    

以上是promise/deferred模式的简单实现,状态转换图可以描述如下:

promise模式比发布/订阅模式略为优雅, 但还不能满足很多场景的实际需求,比如一组纯异步的API为了协同完成一串事情。 

Promises/A+

规范将之前 Promises/A 规范的建议明确为了行为标准。其扩展了原规范以覆盖一些约定俗成的行为,以及省略掉一些仅在特定情况下存在的或者有问题的部分

详见:中文版:http://www.ituring.com.cn/article/66566, 英文版:https://promisesaplus.com/

3、流程控制库

尾触发与next

尾触发目前应用最多的地方是Connect的中间件, 中间件处理网络请求时,可以向面向切面编程一样进行过滤、验证、日志等功能,最简单的中间件如下:

function(req, res, next) {
     //中间件      
}

每个中间件传递请求对象、响应对象和尾触发函数,通过队列形成一个处理流,如下:

  

看一个例子

app.use(function(req, res, next) {
    setTimeout(function() {
        next(); 
    }, 0) 
}, function(req, res, next) {
    setTimeout(function() {
         next(); 
    }, 0);
});

从这个实例中可以简单猜到尾触发的实现原理了,简单讲就是通过调用use维护一个队列, 调用next的时候出队并执行,依次循环。

async

目前最知名的流程控制模块,async模块提供了20多个方法用于处理异步的多种写作模式, 如:

1、异步的串行执行

async.series([
    function(callback){
        // do some stuff ...
        callback(null, 'one');
    },
    function(callback){
        // do some more stuff ...
        callback(null, 'two');
    }
],
// optional callback
function(err, results){
    // results is now equal to ['one', 'two']
});

// an example using an object instead of an array
async.series({
    one: function(callback){
        setTimeout(function(){
            callback(null, 1);
        }, 200);
    },
    two: function(callback){
        setTimeout(function(){
            callback(null, 2);
        }, 100);
    }
},
function(err, results) {
    // results is now equal to: {one: 1, two: 2}
});  

异常处理原则是一遇到异常,即结束所有调用,并将异常传递给最终回调函数的第一个参数

2、异步的并行执行

// an example using an object instead of an array
async.parallel({
    one: function(callback){
        setTimeout(function(){
            callback(null, 1);
        }, 200);
    },
    two: function(callback){
        setTimeout(function(){
            callback(null, 2);
        }, 100);
    }
},
function(err, results) {
    // results is now equals to: {one: 1, two: 2}
});

与EventProxy基于事件发布和订阅模式的不同在于回调函数的使用上, async回调函数由async封装后传入, 而EventProxy则通过done(), fail()方法来生成新的回调函数, 实现方式都是高阶函数的应用。

3、异步调用的依赖处理

async.waterfall([
    function(callback){
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback){
       // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback){
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
   // result now equals 'done'    
});

4、自动依赖处理

async.auto({
    get_data: function(callback){
        console.log('in get_data');
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback){
        console.log('in make_folder');
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: ['get_data', 'make_folder', function(callback, results){
        console.log('in write_file', JSON.stringify(results));
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(callback, results){
        console.log('in email_link', JSON.stringify(results));
        // once the file is written let's email a link to it...
        // results.write_file contains the filename returned by write_file.
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

在现实的业务环境中,具有很多复杂的依赖关系, 并且同步和异步也不确定,为此auto方法能根据依赖关系自动分析执行。

Step

轻量的async, 在API暴露上也具备一致性, 因为只有一个接口Step。 

在异步处理上有一些不同, Step一旦产生异常,会将异做为下一个方法的第一个参数传入

var s = require('step');
s(
    function readSelf() {
        fs.readFile(__filename, this);
    },  
    function(err, content) {
        //并行执行任务
        fs.readFile(__filename, this.parallel());
        fs.readFile(__filename, this.parallel());
    },  
    function() {
//任务分组保存结果 var group = this.group(); console.log(arguments); fs.readFile(__filename, group()); fs.readFile(__filename, group()); }, function () { console.log(arguments); } )

Wind

待补充

 

总结

对比几种方案的区别:事件发布/订阅模式相对是一种原始的方式,Promise/Deferred模式贡献了一个非常不错的异步任务模型的抽象,重头在于封装异步的调用部分, 而流程控制库则要灵活很多。

除了async、step、EventProxy、wind等方案外,还有一类通过源代码编译的方案来实现流程控制的简化, streamline是一个典型的例子。

 

参考

《深入浅出nodejs》第四章

https://promisesaplus.com/

https://github.com/caolan/async/

https://github.com/creationix/step

http://www.ituring.com.cn/article/66566

 

posted @ 2014-10-27 13:54  mininice  阅读(623)  评论(0编辑  收藏  举报