源码阅读系列的开篇就不多废话了，开门见山。
首先看添加中间件的入口 app.use 的源码
/**
* Use the given middleware `fn`.
*
* @param {GeneratorFunction} fn
* @return {Application} self
* @api public
*/
app.use = function (fn) {
if (!this.experimental) {
//es7 async functions are not allowed,
//so we have to make sure that `fn` is a generator function
assert(
fn && "GeneratorFunction" == fn.constructor.name,
"app.use () requires a generator function"
);
}
debug("use % s", fn._name || fn.name || "-");
// 主要就是做这个事情
// 根据上面的 assert，这里的 fn 均为 generator function
this.middleware.push(fn);
return this;
};
接着，来看一下 Server 是怎么起来的
/**
* Shorthand for:
*
* http.createServer (app.callback ()).listen (...)
*
* @param {Mixed} ...
* @return {Server}
* @api public
*/
app.listen = function () {
debug("listen");
// 非常熟悉的 createServer
// 调用的是 app.callback
var server = http.createServer(this.callback());
return server.listen.apply(server, arguments);
};
很显然，app.callback 里应该就有我们想要的中间件执行的部分
/**
* Return a request handler callback
* for node's native http server.
*
* @return {Function}
* @api public
*/
app.callback = function () {
if (this.experimental) {
console.error(
"Experimental ES7 Async Function support is deprecated. Please look into Koa v2 as the middleware signature has changed."
);
}
var fn = this.experimental
? compose_es7(this.middleware)
: co.wrap(compose(this.middleware)); // 把中间件串起来
var self = this;
if (!this.listeners("error").length) this.on("error", this.onerror);
return function (req, res) {
res.statusCode = 404;
var ctx = self.createContext(req, res);
onFinished(res, ctx.onerror);
fn.call(ctx)
.then(function () {
respond.call(ctx);
})
.catch(ctx.onerror);
};
};
这里的 compose 是关键，我们来到 koa-compose 的源码，仅仅就这 38 行代码，就构成了 KOA 中间件执行的核心部分，这里我们暂且不讨论 co.wrap
/**
* Expose compositor.
*/
module.exports = compose;
/**
* Compose `middleware` returning
* a fully valid middleware comprised
* of all those which are passed.
*
* @param {Array} middleware
* @return {Function}
* @api public
*/
function compose(middleware) {
return function* (next) {
if (!next) next = noop();
var i = middleware.length;
while (i--) {
next = middleware[i].call(this, next);
}
return yield* next;
};
}
/**
* Noop.
*
* @api private
*/
function* noop() {}
这么快就看到这行了？我觉得上面的代码信息量很大，道友们再细细品味一下，确定品味完了，下面的开胃 DEMO 可以帮助你更好的理解这个执行过程
#!/usr/bin/env node
// 中间件 a
function* a(next) {
yield 1;
// 执行下一个中间件
yield* next;
yield " 继续执行 A 中间件 ";
}
// 中间件 b
function* b(next) {
yield 2;
yield 3;
}
var next = function* () {};
var i = [a, b].length;
// 通过 next 首尾相连
while (i--) {
next = [a, b][i].call(null, next);
}
// 包裹第一个 middleware
function* start(ne) {
return yield* ne;
}
// 输出
console.log(start(next).next());
console.log(start(next).next());
console.log(start(next).next());
console.log(start(next).next());
输出结果：
➜ a-lab ./a
{ value: 1, done: false }
{ value: 2, done: false }
{ value: 3, done: false }
{ value: ' 继续执行 A 中间件 ', done: false }
等等，我们的 co 去哪儿了？大家有没有发现上面 Demo 中和我们平时用 KOA 写中间件的不同之处，我们来看一下 KOA 的官方示例代码：
var koa = require ('koa');
var app = koa ();
//x-response-time
app.use (function *(next){
var start = new Date;
yield next;
var ms = new Date - start;
this.set ('X-Response-Time', ms + 'ms');
});
//logger
app.use (function *(next){
var start = new Date;
yield next;
var ms = new Date - start;
console.log ('% s % s - % s', this.method, this.url, ms);
});
//response
app.use (function *(){
this.body = 'Hello World';
});
app.listen (3000);
有没有发现？如果还没有发现我就公布答案啦：
根据上文，我们已经知道，那个负责把所有中间件串起来的 next 其实本身也是一个 generator，但是，如果在 Generater 函数内部，调用另一个 Generator 函数，默认情况下是没有效果的，这个时候我们必须使用 yield* next
但是，我们写代码的时候明明写的是 yield next 啊，这就是 co 的巧妙之处了：
co 帮我们 “自动管理” generator 的 next，并根据调用返回的 value 做出不同的响应，这个响应是通过 toPromise 方法进行的，我们可以在 toPromise 中发现：
- 如果遇到另外一个 generator，co 会继续调用自己，这就是为什么我们不需要写 yield* next 的原因，而只要写 yield next
yield next;
可以看一下这个 toPromise
/**
* Convert a `yield`ed value into a promise.
*
* @param {Mixed} obj
* @return {Promise}
* @api private
*/
function toPromise(obj) {
if (!obj) return obj;
if (isPromise(obj)) return obj;
if (isGeneratorFunction(obj) || isGenerator(obj)) return co.call(this, obj);
if ("function" == typeof obj) return thunkToPromise.call(this, obj);
if (Array.isArray(obj)) return arrayToPromise.call(this, obj);
if (isObject(obj)) return objectToPromise.call(this, obj);
return obj;
}
所以，co 对 yield 后面跟的类型是严格约定的，如果我们在项目中直接使用了 DEMO 中的
yield 1
co 就会给我们一个错误
You may only yield a function, promise, generator, array, or object.
所以，我们一般在项目中如果想要 “同步” 写法，都会用 Promise 封装一下，比如这样：
let getAuthInfo = function (req) {
return new Promise((resolve, reject) => {
rp(req)
.then((authres) => {
if (authres.status === 0 && authres.code === 0) {
resolve(authres);
} else {
resolve(null);
}
})
.catch((err) => {
reject(err);
});
});
};
然后，我们就可以这样使用了：
let authinfo = yield getAuthInfo (authReq);
执行完所有中间件之后，KOA 才会进入到 respond
fn.call(ctx)
.then(function () {
respond.call(ctx);
})
.catch(ctx.onerror);
respond
/**
* Response helper.
*/
function respond() {
//allow bypassing koa
if (false === this.respond) return;
var res = this.res;
if (res.headersSent || !this.writable) return;
var body = this.body;
var code = this.status;
//ignore body
if (statuses.empty[code]) {
//strip headers
this.body = null;
return res.end();
}
if ("HEAD" == this.method) {
if (isJSON(body)) this.length = Buffer.byteLength(JSON.stringify(body));
return res.end();
}
//status body
if (null == body) {
this.type = "text";
body = this.message || String(code);
this.length = Buffer.byteLength(body);
return res.end(body);
}
//responses
if (Buffer.isBuffer(body)) return res.end(body);
if ("string" == typeof body) return res.end(body);
if (body instanceof Stream) return body.pipe(res);
//body: json
body = JSON.stringify(body);
this.length = Buffer.byteLength(body);
res.end(body);
}
所以，我们说使用 KOA 写中间件的时候，我们可以任意修改我们的 response body，然后再返回给客户端
总结
-
KOA 通过 next 将中间件 “串” 了起来，形成了链表，然后通过最外层的 generator function 触发整个执行过程
-
在 compose 的时候，拿取中间件的顺序是 FILO 的，但是拿出来之后做的操作是循环 i– 赋值 next，因此，依然可以保证正确的顺序执行
-
KOA 框架通过 co 框架包装 generator 来达到 “同步” 写法
-
KOA 在执行完所有中间件之后才会真正执行 respond，在此之前，我们可以对 response body 做任何你想做的修改，这点与 Express 有本质上的区别
留下评论