Koa源码分析(三) -- middleware机制的实现
Abstract
本系列是关于Koa框架的文章,目前关注版本是Koa v1。主要分为以下几个方面:
Koa概括
Koa是基于generator与co之上的新一代中间件框架,它的优势主要集中在以下几个方面
- 中间件机制
- 封装了request/response, context对象
- 使用yield,方便异步编程进行流程控制
- 在忽略同步或者异步的情况下,使用try catch可以获取程序运行中的异常(错误处理是服务端程序的核心)
示例代码
var Koa = require('koa');
var app = new Koa();
//添加中间件1
app.use(function *(next){
var start = new Date;
console.log("start=======1111");
yield next;
console.log("end =======1111");
var ms = new Date - start;
console.log('%s %s - %s', this.method, this.url, ms);
});
//添加中间件2
app.use(function *(){
console.log("start=======2222");
this.body = 'Hello World';
console.log("end =======2222");
});
app.listen(3000);
/*
start=======1111
start=======2222
end =======2222
end =======1111
GET / - 10
start=======1111
start=======2222
end =======2222
end =======1111
GET /favicon.ico - 5
*/
从上述代码中,我们添加了两个middleware,其中第一个middleware中有一个输入参数next
,并通过yield
进行调用。通过分析输出的log信息,不难发现,先运行middelware1中的yield
之前的代码,然后进入到middleware2中运行,待middleware2运行结束后又回到middleware1中,并运行yield
之后的代码。
由于app.use
输入的是generator函数,如果熟悉generator函数的同学,或许会说,这是将middleware2作为middleware1中的next参数,依次调用多个generator函数。对,没错,实际运行就是这样的,但是koa框架是如何组织代码实现这样方面的调用,将地狱式调用的异步编程编程这样清晰的结构?请看下文的源码分析
源码分析
Application初始化
function Application() {
if (!(this instanceof Application)) return new Application;
this.env = process.env.NODE_ENV || 'development';
this.subdomainOffset = 2;
// 用于存放中间件,即generator对象
this.middleware = [];
this.proxy = false;
// 获得封装的上下文对象
this.context = Object.create(context);
// 获取封装的请求对象
this.request = Object.create(request);
// 获取封装的响应对象
this.response = Object.create(response);
}
启动服务
listen() {
debug('listen');
// 调用node原生中的创建服务
// 其中callback()是服务创建的核心,具体见下面分析
const server = http.createServer(this.callback());
// 开启服务的监听
return server.listen.apply(server, arguments);
}
添加中间件
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 || '-');
// 将输入的fn依次push到middleware数组中
this.middleware.push(fn);
// 返回this,以便链式调用
return this;
};
node native 创建服务
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.')
}
// 将中间件按照加入的顺序,实现yield的链式调用,即组织异步调用结构,详细见下面的compose
// co.wrap方法将generator函数转化为Promise
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);
// 返回node native的请求处理函数
return function handleRequest(req, res){
res.statusCode = 404;
var ctx = self.createContext(req, res);
onFinished(res, ctx.onerror);
fn.call(ctx).then(function handleResponse() {
respond.call(ctx);
}).catch(ctx.onerror);
}
};
中间件异步构建
// 返回一个启动函数
function compose(middleware){
return function *(next){
if (!next) next = noop();
var i = middleware.length;
// 对中间件队列从后遍历,逐个获取对应的generator对象
while (i--) {
// 将后面的generator对象传递给前面中间件的generatorFunction
next = middleware[i].call(this, next);
}
// 返回一个yield,next指向第一个中间件的generator
return yield *next;
}
}
function *noop(){}
这样,我们就从返回的启动函数(generator函数)的yield处指向第一个中间件,然后从之前while
循环构成的从前往后的调用链,依次调用下一个中间件,直至最后一个中间件然后再返回。
这边我们再次回到callback()
这个启动函数处,调用co.wrap()
实现对generator函数的逐步调用。