Koajs原理

本文地址 http://www.cnblogs.com/jasonxuli/p/5382090.html
Koajs让习惯阻塞式代码写法的同学感到很舒服，再也不用盖楼式的callback了，而且也不需要学习Promise的then，catch这些新东西。

但实际上，Koajs这样的写法有点像是语言的语法糖，它只不过把yield又包装成了Promise的链式调用。做这件事儿的库就是co库和compose库，compose库把koajs中的一堆中间件改装成了函数套娃，而co则把这些套娃改装成了Promise链。想要了解Koajs的原理，还真需要先了解一下Promise的基本概念。本文假设你已经了解了Promise的基本知识。

koajs的用法大概是这样的：

var koa = require('koa')();

koa.use(function* m1(next){
...
yield next;
...
}

koa.use(function* m2(next){
...
yield next;
...
}

koa .listen(3000);

这个koa.listen默认的callback是koa库的application.js中的app.callback，也就是在这个app.callback中，调用了关键的这一句：

var fn = this.experimental
? compose_es7(this.middleware)
: co.wrap(compose(this.middleware));

这也引出了co库和compose库这两个koajs的核心库。

先说compose库：
koa.use函数关键的代码就是这一句

this.middleware.push(fn);

也就是说这个this.middleware是个中间件的数组。
实际上，compose是把[m1, m2, ...] 改装成了 m1(m2(m3(...)))，以方便co库的下一步改装，如下：

function compose(middleware){

return function *(next){

var i = middleware.length;

var prev = next || noop();

var curr;

while (i--) {
curr = middleware[i]; // curr = m3
prev = curr.call(this, prev); // m3.call(this, null) >>> m3() 即 prev=m3()
}

yield *prev; // m3()
}
}

最后的结果相当于返回了一个函数套娃：m1(m2(m3))

这个结果作为co的参数，又发生了什么呢？

co lib:
Actually, co convert yields to promise thens.

// fake codes
function co(gen){
if gen is a function
gen = gen();

if gen is null || gen is not a function
return resolve(gen);

　　onFulfilled();

// onFulfilled() {
try{
var ret = gen.next();
}catch(){
reject(ret);
}
　　　　next();
}

// next() {
if ret.done == true
return resolve(ret);

// toPromise(){
if ret is a general value
return resove(ret)
if ret is a generator // 按深度延展： 处理 yield*
return co(ret)
}

if (isPromise(value))
return value.then(onFulfilled, onRejected); // 按广度延展：处理下一个yield
}
}

这段co代码去除了很多看起来稍稍复杂的细节，有利于捋清楚脉络。

看明白co库和compose库，你就知道，koajs只是给了大家用同步阻塞方式写IO处理的自由，实际上它在背后偷偷的采用了Promise链式调用的方式。
我刚开始了解koajs的时候，最大的疑问也正是这个：为什么一个异步非阻塞的语言可以用阻塞的方式处理异步的IO呢？
现在这个问题有了答案。

2015-11-16 于Evernote