上次我们聊了一下 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
其实这个文件就是导出了一个对象，如下：
代码语言：javascript复制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__ 可以实现属性的委托。
代码语言：javascript复制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。
参考
- 一文搞懂koa2核心原理[4]
- koa源码分析（二）ctx[5]
参考资料
[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
