Koa源码解读

0.062字数 1398阅读 200
// 第一步 - 初始化app对象
var koa = require('koa');
var app = koa();
// 第二步 - 监听端口
app.listen(1995);

初始化

执行koa()的时候初始化了一些很有用的东西,包括初始化一个空的中间件集合,基于Request,Response,Context为原型,生成实例等操作。Request和Response的属性和方法委托到Context中也是在这一步进行的。在这一步并没有启动Server。

module.exports = class Application extends Emitter {
    /**
    * Initialize a new 'Application'.
    *
    * @api public
    */
    constructor() {
        super();
        this.proxy = false;
        this.middleware = [];
        this.subdomainOffset = 2;
        this.env = process.env.NODE_ENV || 'development';
        this.context = Object.create(context);
        this.request = Object.create(request);
        this.response = Object.create(response);
    }
    ...

几项配置的含义:
env 环境,默认为 NODE_ENV 或者 development
proxy 如果为 true,则解析 "Host" 的 header 域,并支持 X-Forwarded-Host
subdomainOffset 默认为2,表示 .subdomains 所忽略的字符偏移量。

启动Server

app.listen = function () {
    debug('listen');
    var server = http.createServer(this.callback());
    return server.listen.apply(server, arguments);
};

在执行app.listen(1995)的时候,启动了一个server,并且监听端口。
http.createServer接收一个函数作为参数,每次服务器接收到请求都会执行这个函数,并传入两个参数(request和response,简称req和res),那么现在重点在this.callback这个方法上。

callback

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,他的作用是把一个个不相干的中间件串联在一起。

// 有3个中间件
this.middlewares = [function *m1() {}, function *m2() {}, function *m3() {}];
// 通过compose转换
var middleware = compose(this.middlewares);
// 转换后得到的middleware是这个样子的
function *() {
yield *m1(m2(m3(noop())))
}

上述是V1的代码,跟V2意思差不多。generator函数的特性是,第一次执行并不会执行函数里的代码,而是生成一个generator对象,这个对象有next,throw等方法。
这就造成了一个现象,每个中间件都会有一个参数,这个参数就是下一个中间件执行后,生成出来的generator对象,没错,这就是大名鼎鼎的 next。
那compose是如何实现这样的功能的呢?我们看一下代码:

module.exports = compose
function compose(middleware) {
    if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
    for (const fn of middleware) {
        if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
    }
    return function (context, next) {
        // last called middleware #
        let index = -1
        return dispatch(0)
        function dispatch(i) {
            if (i <= index) return Promise.reject(new Error('next() called multiple times'))
            index = i
            let fn = middleware[i]
            if (i === middleware.length) fn = next
            if (!fn) return Promise.resolve()
            try {
                return Promise.resolve(fn(context, function next() {
                    return dispatch(i + 1)
                }))
            } catch (err) {
                return Promise.reject(err)
            }
        }
    }

这里的逻辑就是:先把中间件从后往前依次执行,并把每一个中间件执行后得到的值赋值给变量next,当下一次执行中间件的时候(也就是执行前一个中间件的时候),把next传给第二个参数。这样就保证前一个中间件的参数是下一个中间件生成的值,第一次执行的时候next为underfined。



compose(this.middleware)() = this.middleware[0](context, this.middleware[1](context, this.middleware[2](context, null)))
有一个问题,什么时候会出现i <= index的情况?答案是当一个中间件中两次调用next时。比如,当第二个中间件里两次调用next,那执行结果就变成了这样。

可以看出,当第二次执行next时,index===i,就会抛出异常。

注意:一个中间件里是不能多次调用next的。

接收请求

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);
}

创建上下文

var ctx = self.createContext(req, res);

对应的源码是:

/**
* Initialize a new context.
*
* @api private
*/
createContext(req, res) {
    const context = Object.create(this.context);
    const request = context.request = Object.create(this.request);
    const response = context.response = Object.create(this.response);
    context.app = request.app = response.app = this;
    context.req = request.req = response.req = req;
    context.res = request.res = response.res = res;
    request.ctx = response.ctx = context;
    request.response = response;
    response.request = request;
    context.originalUrl = request.originalUrl = req.url;
    context.cookies = new Cookies(req, res, {
        keys: this.keys,
        secure: request.secure
    });
    request.ip = request.ips[0] || req.socket.remoteAddress || '';
    context.accept = request.accept = accepts(req);
    context.state = {};
    return context;
}

koa中的this其实就是app.createContext方法返回的完整版context
又由于这段代码的执行时间是接受请求的时候,所以表明:
每一次接受到请求,都会为该请求生成一个新的上下文
可以看看,经过这一步处理后他们之间的关系是怎样的,可以用这个图来表示:

从上图中,可以看到分别有五个箭头指向ctx,表示ctx上包含5个属性,分别是request,response,req,res,app。request和response也分别有5个箭头指向它们,所以也是同样的逻辑。


介绍一下这几个概念:
ctx,就是上下文,context 在每个 request 请求中被创建,在中间件中作为接收器(receiver)来引用,或者通过 this 标识符来引用:

app.use(function *(){
    this; // is the Context
    this.request; // is a koa Request
    this.response; // is a koa Response
});

node里有request和response两个对象,分别有处理请求和响应的API。在koa里,将这两个对象封装在了ctx里,可以通过ctx.req(=noderequest)和ctx.res(=node request)来使用。
Koa Request 对象(=ctx.request)是对 node 的 request 进一步抽象和封装,提供了日常 HTTP 服务器开发中一些有用的功能。
Koa Response 对象(=ctx.response)是对 node 的 response 进一步抽象和封装,提供了日常 HTTP 服务器开发中一些有用的功能。
许多 context 的访问器和方法为了便于访问和调用,简单的委托给他们的 ctx.request 和 ctx.response 所对应的等价方法,比如说 ctx.type 和 ctx.length 代理了 response 对象中对应的方法,ctx.path 和 ctx.method 代理了 request 对象中对应的方法。
app是应用实例引用。
具体API看http://koa.bootcss.com/


错误监视

onFinished(res, ctx.onerror);

这行代码的作用是监听response,如果response有错误,会执行ctx.onerror中的逻辑,设置response类型,状态码和错误信息等。

执行中间件

fn.call(ctx).then(function () {
    respond.call(ctx);
}).catch(ctx.onerror);

fn是compose(初始化中间件)执行后的结果,fn.call(ctx)执行中间件逻辑,执行成功则接着执行response.call(ctx),否则进行错误处理。
请求的时候会经过一次中间件,响应的时候又会经过一次中间件。


var koa = require('koa');
var app = koa();
app.use(function* f1(next) {
    console.log('f1: pre next');
    yield next;
    console.log('f1: post next');
    yield next;
    console.log('f1: fuck');
});
app.use(function* f2(next) {
    console.log(' f2: pre next');
    yield next;
    console.log(' f2: post next');
    yield next;
    console.log(' f2: fuck');
});
app.use(function* f3(next) {
    console.log(' f3: pre next');
    yield next;
    console.log(' f3: post next');
    yield next;
    console.log(' f3: fuck');
});
app.use(function* (next) {
    console.log('hello world')
    this.body = 'hello world';
});
app.listen(3000);

打印如下:

f1: pre next
f2: pre next
f3: pre next
hello world
f3: post next
f3: fuck
f2: post next
f2: fuck
f1: post next
f1: fuck

用一张图表示如下:



由于每次接收请求,都会执行callback,所以每次接收请求以下操作都会被执行:

  • 初始化中间件
  • 生成新的上下文
  • 执行中间件逻辑
  • 响应请求或错误处理

推荐阅读更多精彩内容