【kao 源码】聊聊 Koa 中的 context

上次我们聊了一下 Koa 中的洋葱模型，具体可以看——[【Node】深入浅出 Koa 的洋葱模型] [1]。今天来聊聊 koa 中另外一个重要的概念——context 的实现。

上下文(Context)

官方介绍如下：

Koa Context 将 node 的 request 和 response 对象封装到单个对象中，为编写 Web 应用程序和 API 提供了许多有用的方法。这些操作在 HTTP 服务器开发中频繁使用，它们被添加到此级别而不是更高级别的框架，这将强制中间件重新实现此通用功能。

每个请求都将创建一个 Context，并在中间件中作为接收器引用，或者 ctx 标识符，如以下代码片段所示：

app.use(async ctx => {
  ctx; // 这是 Context
  ctx.request; // 这是 koa Request
  ctx.response; // 这是 koa Response
});

为什么要用 Context

我理解 Context 一个很重要的职责就是保存和传递数据。一来它身上委托了很多 request 和 response 的属性和方法。二来当需要传递用户自定义的数据的时候，它也能发挥其作用(通过 ctx.state 还可以加一个命名空间)。koa 处理请求是按照中间件的形式的，我们可以看到每个中间件的入参第一个都是 ctx，结合[洋葱模型] ，这就方便了各个中间件之间传递数据。

每个请求中 http.createServer 中的回调都会有一个 req 和 res 参数，那为什么不直接将数据挂在这两个对象中呢？设计模式的基本原则就是开闭原则，就是在不修改原有模块的状况下对其进行扩展。对于以后的 req 和 res 对象的拓展，我们是未知的。假如我们将某个属性（比如 usename 挂载在该对象中），后面 http 模块更新加上了这个属性的话，我们就比较难办了。

可以看到 koa 的官方文档[2]中的介绍，其实花了大篇幅的都是在描写 ctx，包括 request 和 response 的内容。

我们来看看它是怎么实现的吧~

入口和创建 context

在 koa 的源码中，只有四个文件，如下所示：

├── application.js
├── context.js
├── request.js
└── response.js

通过 package.json 中的 main 字段，我们知道入口为 lib/application.js 文件。

listen

当我们调用 app.listen 的时候，就会调用该方法。其实就是 Node.js 中的 http 模块中的 http.createServer。

// 创建一个 HTTP 服务，并监听传入的端口。callback 为监听端口的回调
listen(...args) {
  debug('listen');
  const server = http.createServer(this.callback());
  return server.listen(...args);
}

再来看 callback 函数。其中 componse 函数非常重要，是用来创建洋葱模型的的函数，但这不是我们今天的重点。可以看到返回 handleRequest 函数，这个是 http.createServer() 的回调函数。今天的重点在于 createContext 这个函数，这个函数就是用来创建上下文的。

callback() {
  // compose 函数。主要是创建了洋葱模型
  const fn = compose(this.middleware);
  // ..
  // 将 createServer 中的 req 和 res 挂在 context 中。
  const handleRequest = (req, res) => {
    // 创建执行上下文
    const ctx = this.createContext(req, res);
    // 返回一个函数，传入的参数为执行上下文和洋葱模型创建的函数
    return this.handleRequest(ctx, fn);
  };
  // 返回 handleRequest 函数。
  return handleRequest;
}

createContext

可以看到，每次请求，我们都通过 Object.create 创建一个上下文信息，也就是 context，它的原型会指向 context.js 中导出对象。也就是每个请求的上下文信息是唯一而且隔离的。

一个 ctx 即可获得所有 koa 提供的数据和方法，而 koa 会继续将这些职责进行进一步的划分，比如 request 是用来进一步封装 req 的（主要的实现在 request.js 中），response 是用来进一步封装 res 的（主要实现在 response.js），这样职责得到了分散，降低了耦合。

  createContext(req, res) {
  // 目的就是让每次http请求都生成一个context，并且单次生成的context是全局唯一的，相互之间隔离。
  const context = Object.create(this.context);
  const request = context.request = Object.create(this.request);
  const response = context.response = Object.create(this.response);
  // 在 request.app 和 response 中挂了一个 app 属性，指向 this
  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.state = {};
  return context;
}

我们来看看，context.js 中到底做了什么？

context.js

其实这个文件就是导出了一个对象，如下：

const proto = module.exports = {
  inspect() {
  },
  toJSON() {
    // ...
  },
  assert: httpAssert,
  throw(...args) {
    // ...
  },

  // 错误处理
  onerror(err) {
    // ...
  },
  // 对 cookie 的操作
  get cookies() {
    // ...
  },
  set cookies(_cookies) {
    this[COOKIES] = _cookies;
  }
};

但上面这些大部分都不是我们常见的 API，比如 ctx.method 等。其实它的实现在该对象后面。其调用的是另外一个库——delegate[3]。它的作用是将 proto(也就是我们的 Context)的部分属性和函数委托给 response 和 request。我们来看看这个库的实现。

delegate(proto, 'response')
  .method('attachment')
  .method('redirect')
  .method('remove')
  .method('vary')
  .method('has')
  .method('set')
  .method('append')
  .method('flushHeaders')
  .access('status')
  .access('message')
  .access('body')
  .access('length')
  .access('type')
  .access('lastModified')
  .access('etag')
  .getter('headerSent')
  .getter('writable');

delegates-委托模式的应用

delegates 可以帮我们方便快捷地使用设计模式当中的委托模式，即外层暴露的对象（这里指的是 context 对象）将请求委托给内部的其他对象（request 和 response 对象）进行处理。

我们来看看 koa 中用到的两个方法:

method

通过 method 方法，当我们调用该属性方法的时候，就会调用内层对象的该属性方法。另外为了支持链式调用，返回 this。

Delegator.prototype.method = function(name){
  var proto = this.proto;
  var target = this.target;
  this.methods.push(name);

  proto[name] = function(){
    return this[target][name].apply(this[target], arguments);
  };

  return this;
};

getter

通过 __defineGetter__ 可以实现属性的委托。

defineGetter 方法可以将一个函数绑定在当前对象的指定属性上，当那个属性的值被读取时，你所绑定的函数就会被调用。

Delegator.prototype.getter = function(name){
  var proto = this.proto;
  var target = this.target;
  this.getters.push(name);

  proto.__defineGetter__(name, function(){
    return this[target][name];
  });

  return this;
};

request.js 和 response.js

request.js。request 对象基于 Node 原生 req 封装了一系列便利属性和方法，供处理请求时调用。所以当你访问 ctx.request.xxx 的时候，实际上是在访问 request 对象上的 setter 和 getter。response 也是同理。

总结

基于 Node 原生的 req 和 res，koa 封装了高内聚的 context。

参考资料

[1]【Node】深入浅出 Koa 的洋葱模型: https://juejin.cn/post/7012031464237694983

[2]官方文档: https://koa.bootcss.com/

[3]delegate: https://github.com/tj/node-delegates

[4]一文搞懂koa2核心原理: https://juejin.cn/post/6966432934756794405

[5]koa源码分析（二）ctx: http://www.noobyard.com/article/p-kwcfzwul-gv.html