<br />Nodejs本身是基于事件驱动的，这个都知道。如果你看过Nodejs events模块，应该很了解Nodejs是如何驱动异步回调的。

现在有许多人对异步和异步后台多并发产生了迷惑，或借助koa，或借助async，但是代码一出来，结果是什么呢？ 我认为是维护灾难！这样的代码被扔到大量的语法糖构造起来的数组中，所有使用这个代码的人必须同意和遵守潜在的约定，才能知道这个代码是怎么串行或者并行的。

我想，这绝对不是Nodejs作者对异步设计的初衷。事件的优势是“分发”，在任何一个事件都对自己的代码有绝对的控制权。Nodejs源代码本身就提供了很好的异步事件驱动模型编码的范例。

下面，我们谈谈，最典型的例子：

并发|串行向数据库异步提取数据，然后把返回的所有数据聚合，并且作出响应。

Step I 为了模拟这个数据库操作，现在构建这么两个函数:

var dbFindA = function (name, callback) {
// 数据库查询模拟函数，输入name，1秒后返回结果
    setTimeout(function () {
        callback(name.length * 1000);
    }, 1000);
};
var dbFindB = function (id, callback) {
// 数据库查询模拟函数，输入id，2秒后返回结果
    setTimeout(function () {
        callback(parseInt(id) + 1000);
    }, 2000);
};

dbFindA耗时1秒，dbFindB耗时2秒。<br />

Step II 使用内置的EventEmitter来达到事件驱动的效果：

var events = require('events');

function Model (name, id) {
// 基于事件驱动的并发查询模型
    var self = this;
    var count = 2;

    function roll () {
    // 检测查询完成处理器数
        if (--count === 0) {
            self.emit('end');
        }
    }

    dbFindA(name, function (result) {
        self.emit('name', result);
        roll();
    });
    dbFindB(id, function (result) {
        self.emit('id', result);
        roll();
    });
}
Model.prototype = Object.create(events.EventEmitter.prototype);

这就是写出来的基于事件驱动的数据并发读取模型，按照设计，会有3个事件:

• “name” dbFindA查询完的时候触发
• “id” dbFindB查询完的时候触发
• “end” 所有的查询完的时候触发<br />

Step III 测试一下这个模型是不是我们想要的：

var assert = require('assert');
var results = {};
var m = new Model('lili', 10);
m
.on('name', function (result) { 
    results['name'] = result;
    assert.ok(typeof result === 'number');
    assert.strictEqual(result, 4000);
})
.on('id', function (result) {
    results['id'] = result;
    assert.ok(typeof result === 'number');
    assert.strictEqual(result, 1010);
})
.on('end', function () {
    console.log('-- results: ', results);
    assert.deepEqual(results, {
        name: 4000,
        id: 1010
    });
});

这里会得到想到的结果。<br />

实际的模型会是这样的：

var events = require('events');

function Model (db, userColl, articleColl, userSelector, articleSelector) {
// 基于事件驱动的并发查询模型
    var self = this;
    var count = 2;

    function roll () {
    // 检测查询完成处理器数
        if (--count === 0) {
            self.emit('end');
        }
    }

    db.collection(userColl).findOne(userSelector, function (err, result) {
        self.emit('user', err, result);
        roll();
    });
    db.collection(articleColl).findOne(articleSelector, function (err, result) {
        self.emit('article', err, result);
        roll();
    });
}
Model.prototype = Object.create(events.EventEmitter.prototype);

var results = {};
var m = new Model(db, 'users', 'articles', { username:'lili' }, { articleID:'123456' });

m
.on('user', function (err, result) { 
    results['user'] = {err:err, result:result};
})
.on('article', function (err, result) {
    results['article'] = {err:err, result:result};
})
.on('end', function () {
    console.log('-- results: ', results);
});

<br />

编写的思想是:

先使用构造器，编写出我们想要的逻辑结构，然后暴露事件接口。在外部通过事件来控制数据和状态。