十分钟带你看完 KOA 源码

十分钟带你看完 KOA 源码

前段时间看了 koa 源码,得益于 koa 良好抽象,不仅提供了简洁的 api ,同时也使得源码相当的简洁和优雅。今天花点时间画了一张 koa 源码的结构图来分析其源码,在总结的同时,希望能够帮到相关的同学。

注:源码是基于 2.x 版本,源码结构与 1.x 完全一致,代码更加简洁直观一点。

基础知识

任何用过 node 的人对下面的代码都不会陌生,如下:

const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\n');
});
 
server.listen(3000);

上面的代码很简单,http 的 createServer 方法创建了一个 http.Server 的实例,http.Sever 继承于 EventEmitter 类。我们传入的函数,其实是添加到了 server 的 request 事件中,相当于一种快捷方式。所以你也完全可以不传入任何参数,然后手动去监听 request 事件。代码的最后将 server 绑定到 3000 端口,开始监听所有来自 3000 端口的请求。

然后,我们看一下 request 事件的监听函数,其函数接受两个参数,分别是 req 和 res。其中 req 是一个可读流,res 是一个可写流。我们通过 req 获取该请 http 请求的所有信息,同时将数据写入到 res 来对该请求作出响应。

以上就是所有你需要知道的基础知识,是不是很简单?

koa 源码解读

分析源码之前,先直观看一下 koa 如何创建一个 server:

const Koa = require('koa');
const app = new Koa();

app.use(ctx => {
  ctx.body = 'Hello Koa';
});

app.listen(3000);

现在,我们由上面这段简单的代码开始深入到 koa 源码,在分析源码之前,我直接放上文章开头提到的示意图,以便我们结合示意图进行分析。




构造函数

首先我们创建了 Koa 的实例 app,其构造函数十分简单,如下:

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

结合示意图,这个代码很简单,其中 context 、request 和 response 就是 3 个字面量形式创建的简单对象,上面封装了一些列方法(其实绝大部分是属性的赋值器(setter)和取值器(getter)),暂时不用管它们。就像示意图所示,他们将作为 app 相应属性的原型。

值得一提的是 Application 是继承于 EventEmitter,如下:

class Application extends Emitter { //... }

中间件

接下来使用 use 的方法注册一个中间件,其实就是简单的 push 到自身的 mideware 这个数组中。如下:

use(fn) {
  // 省略了一点点校验参数性质的代码
  this.middleware.push(fn);
  return this;
}

启动应用

核心的代码在 listen 这个方法,但是它做的事件也很简单。我们已经知道,通过向 http.createServer 传递一个函数作为参数的形式来创建其的一个实例,其实 app.listen 里面就做了这个一个事情,源码依旧十分简单:

listen() {
  const server = http.createServer(this.callback());
  return server.listen.apply(server, arguments);
}

唯一需要我们关注的就是这个 this.callback ,也是理解 koa 应用的核心所在。

this.callback() 执行的结果肯定是一个函数,根据我们基础知识,这个函数无非就是根据 req 获取信息,同时向 res 中写入数据而已。

那么这个函数具体是怎么做的呢?首先,它基于 req 和 res 封装出我们中间件所使用的 ctx 对象,再将 ctx 传递给中间件所组合成的一个嵌套函数。中间件组合的嵌套函数返回的是一个 Promise 的实例,等到这个组合函数执行完( resolve ),通过 ctx 中的信息(例如 ctx.body )想 res 中写入数据,执行过程中出错 (reject),这调用默认的错误处理函数。

原理还是很简单,看一下代码:

callback() {
  const fn = compose(this.middleware);

  if (!this.listeners('error').length) this.on('error', this.onerror);

  return (req, res) => {
    res.statusCode = 404;
    const ctx = this.createContext(req, res);
    const onerror = err => ctx.onerror(err);
    onFinished(res, onerror);
    fn(ctx).then(() => respond(ctx)).catch(onerror);
  };
}

就像我们分析的一样,callback 首先会将我们的中间件组合成为一个嵌套函数供返回的函数执行时调用。createContext 根据 req 和 res 封装中间件所需要的 ctx。onFinished 是确保一个流在关闭、完成和报错时都会执行相应的回调函数。onerror 就是我们错误处理函数,最后分析。respond 就是我们根据 ctx 中的数据,然后集中的向 res 中写入数据,响应 http 请求。代码很简单但是有点长,就不贴出来了。

现在核心是 createContext 是如何封装出 ctx 的,直接看源码,因为太简单了:

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;
  // 省略一点无关紧要的代码
  return context;
}

简单的说就是创建了3个简单的对象,并且将他们的原型指定为我们 app 中对应的对象。然后将原生的 req 和 res 赋值给相应的属性,就完成了。

如我们示意图,整个 Koa 的结构就完整了。

但是,ctx 上不是暴露出来很多属性吗?它们在哪?他们就在我们示意图的最右边,一开始我们略过的 3 个简单对象。通过原型链的形式,我们 ctx.request 所能访问属性和方法绝大部分都在其对应的 request 这个简单的对象上面。request 又是怎么封装的呢?我只需要简单的贴一点源码,大家就秒懂了。

module.exports = {
  //...
  get method() {
    return this.req.method;
  },

  set method(val) {
    this.req.method = val;
  }
  //...
}

所以你访问 ctx.request.xxx 属性都是定义在右边 resquest 这个简单对象上的属性的赋值器(setter)和取值器(getter)。

response 同理,也就不再赘述。

值得一提的是右边 context 这个对象上面只提供了极少的方法,其他属性都是简单的代理到自身的 request 和 response 这两个对象上。

错误处理

最后简单的分析一下错误处理,由之前 callback 中的源码我们可以看到,app 会默认注册一个错误处理函数。

if (!this.listeners('error').length) this.on('error', this.onerror);

但是我们每次 http 请求的错误其实是交个 ctx.onerror 处理的:

const onerror = err => ctx.onerror(err);
onFinished(res, onerror);
fn(ctx).then(() => respond(ctx)).catch(onerror);

onFinished 是确保一个流在关闭、完成和报错时都会执行相应的回调函数。ctx.onerror 这个函数在参数为空或者 null 的时候,直接返回,不会做任何操作。

if (null == err) return;

否则,则会触发 app 产生一个错误事件。

this.app.emit('error', err, this);

然后如果判断该请求处理依旧没有结束,也就是 app 注册的 onerror 事件没有结束该请求,则会尝试向客户端产生一个 500 的错误。判断方式:

if (this.headerSent || !this.writable) {
  err.headerSent = true;
  return;
}

总结起来,我们可以在不同的抽象层次上处理错误。比如,我们可以在顶层的中间件将所有中间件产生的错误捕获并处理了,这样错误就不会被上层捕获。我们也可以覆盖 ctx.onerror 的方式来捕获所有的异常,而且可以不触发 app 的 error 事件。最后我们当然也可以直接监听 app 的 error 事件的方式来处理错误。

最后的话

如文章开头所言,koa 恰当的抽象,不仅提供了简洁实用的 api ,同时也使得源码相当的简洁和优雅。虽然文章标题为看完 koa 源码,但实际上并没有对 response 和 request 封装的细枝末节进行详细的阐述,如果你看懂了这边文章,再去看源码应该就得心应手了。

最后如果阐述不清楚,或者不恰到的地方欢迎反馈。

编辑于 2018-03-03