本次分析的KOA版本是2.13.1，它非常轻量，诸如路由、模板等功能默认都不提供，需要自己引入相关的中间件。
源码的目录结构比较简单，主要分为3部分，__tests__，lib和docs，从名称中就可以了解到。
__tests__是单元测试，lib是核心代码，docs是文档。在lib目录中只有4个文件。
├── __tests__ ------------------------ 单元测试 ├── docs ----------------------------- 文档 ├── lib ------------------------------ 源码目录 │ ├── application.js --------------- 运行 │ ├── context.js ------------------- 上下文 │ ├── request.js ------------------- 请求 │ ├── response.js ------------------ 响应
阅读源码除了能学到不经常使用的概念之外，还能学到各种软件开发思路，见识到各种类型的第三方库，对于提升自己的日常编码很有帮助。
一、package.json
在package.json文件中，可以看到KOA的入口是 application.js。
"main": "lib/application.js",
在devDependencies中，依赖的是ESLint和单元测试库。
在dependencies中，好几个都是与通信有关的库，还有几个工具库，具体包括：
- accepts：为给定的 req 创建一个新的 Accepts 对象。
- cache-content-type：与 mime-types 的 contentType 方法相同，但缓存了结果。
- content-disposition：创建和解析 HTTP Content-Disposition 头。
- content-type：根据 RFC 7231 创建和解析 HTTP Content-Type 头。
- cookies：一个用于获取和设置 HTTP(S) cookie 的 node.js 模块。
- debug：一个模仿 Node.js 核心调试技术的小型 JavaScript 调试实用程序。
- delegates：创建一个委托实例，让一个对象可以直接访问其属性对象的属性和方法（在下一篇中会详细说明）。
- destroy：销毁一个流，确保流被销毁，处理不同的 API 和 Node.js 错误。
- encodeurl：将 URL 编码为百分比编码形式，不包括已编码的序列。
- escape-html：将特殊字符转换成HTML实体。例如 foo & bar =》foo & bar。
- fresh：HTTP 响应新鲜度测试。
- http-assert：状态码断言，像 Koa 中的 ctx.throw() 一样，但是有一个守卫。
- http-errors：为 Express、Koa、Connect 等创建 HTTP 错误。
- koa-compose：组合给定的中间件，KOA的插件。
- on-finished：当 HTTP 请求关闭、完成或出错时执行回调。
- only：指定属性白名单，然后只返回这几个属性。
- parseurl：解析给定请求对象的 URL（req.url 属性）并返回结果，结果与 url.parse 相同。在 req.url 不变的同一个 req 上多次调用此函数将返回一个缓存的解析对象。
- statuses：返回已知 HTTP 状态代码的状态消息字符串。
- type-is：检查请求的内容类型是否是 content-type 中的一种类型。
- vary：将给定的头字段添加到 res 的 Vary 响应头中。
二、application.js
application.js是KOA的入口文件，在此文件中，会引入lib目录的另外3个文件，以及多个依赖库。
const debug = require('debug')('koa:application')
const onFinished = require('on-finished')
const response = require('./response')
const compose = require('koa-compose')
const context = require('./context')
const request = require('./request')
const statuses = require('statuses')
const Emitter = require('events')
const util = require('util')
const Stream = require('stream')
const http = require('http')
const only = require('only')
const { HttpError } = require('http-errors')
在下面的代码中，去掉了大部分的方法体，只留下了方法名和注释。其中Application继承自Emitter，这样就能监听和触发自定义事件了。
/** * 继承自 Emitter.prototype */ module.exports = class Application extends Emitter { constructor (options) { } /** * 简写： * http.createServer(app.callback()).listen(...) */ listen (...args) { } /** * JSON格式化 */ toJSON () { return only(this, ['subdomainOffset', 'proxy', 'env']) } /** * Inspect implementation. */ inspect () { return this.toJSON() } /** * 使用给定的中间件 fn */ use (fn) { } /** * 请求处理程序回调，用于本机 http 服务器 */ callback () { } /** * 在回调中处理请求 */ handleRequest (ctx, fnMiddleware) { } /** * 初始化一个新的上下文 */ createContext (req, res) { } /** * 默认错误处理程序 */ onerror (err) { } /** * 帮助 TS 用户遵守 CommonJS、ESM、bundler mismatch * @see https://github.com/koajs/koa/issues/1513 */ static get default () { return Application } } /** * 响应助手 */ function respond (ctx) { } /** * 使库的消费者可以使用 HttpError，这样消费者就不会直接依赖于 `http-errors` */ module.exports.HttpError = HttpError
在看过源码后，再来阅读一段简单的demo，在初始化KOA实例后，调用了Application的 use() 和 listen() 两个方法。
const Koa = require("koa");
const app = new Koa();
app.use(async (ctx, next) => {
ctx.body = "hello，KOA";
});
app.listen(3000);
1）构造函数
在构造函数中，会声明各种参数，包括代理信息、环境变量等。
其中Object.create()用于创建一个新对象，带着指定的原型对象和属性。
因为在同一个应用中可能会有多个KOA实例，所以为了防止相互污染，通过Object.create()的拷贝将他们不再引用同一个地址。
constructor (options) { super() options = options || {} // 参数 this.proxy = options.proxy || false// 是否代码模式 this.subdomainOffset = options.subdomainOffset || 2 this.proxyIpHeader = options.proxyIpHeader || 'X-Forwarded-For' // 代理 IP 头，默认为 X-Forwarded-For this.maxIpsCount = options.maxIpsCount || 0 // 从代理 IP 标头读取的最大 IP，默认为 0（表示无穷大） this.env = options.env || process.env.NODE_ENV || 'development' // 环境变量 if (options.keys) this.keys = options.keys this.middleware = [] this.context = Object.create(context) // 创建一个新的context this.request = Object.create(request)// 创建一个新的request this.response = Object.create(response)// 创建一个新的response // util.inspect.custom support for node 6+ /* istanbul ignore else */ if (util.inspect.custom) { this[util.inspect.custom] = this.inspect } }
2）use()
在KOA实例中，会维护一个中间件数组（middleware），在添加fn之前，会利用typeof判断其是否是函数类型。
use (fn) { if (typeof fn !== 'function') throw new TypeError('middleware must be a function!') this.middleware.push(fn) return this }
KOA的中间件采用的是著名的洋葱模型，后面会细说。
3）listen()
listen()内部直接调用http.createServer()创建一个server，监听指定端口，并且每个请求都会回调当前实例的callback()方法。
listen (...args) { const server = http.createServer(this.callback()) return server.listen(...args) }
在callback()方法中，会调用洋葱模型的compose()函数，监听error事件（回调error()函数），最后处理请求调用handleRequest()方法。
callback () { // 包装所有的中间件，返回一个可执行函数，compose()是洋葱模型的实现 const fn = compose(this.middleware) // 若未指定error事件，那么创建error事件监听器 if (!this.listenerCount('error')) { this.on('error', this.onerror) } const handleRequest = (req, res) => { // 为ctx包装Node原生的req和res，并且每个请求都是单独的ctx const ctx = this.createContext(req, res) // 实例的handleRequest()，并不是递归 return this.handleRequest(ctx, fn) } return handleRequest }
4）compose()
中间件通常用于完成一些全局的特定功能，例如权限验证、错误处理、日志添加等。
下面是一个简单的中间件示例，用于处理500响应。
export default () => async (ctx, next) => { try { await next(); } catch (error) { ctx.status = 500; ctx.body = { error: String(error), stack: error.stack }; } };
compose()引用自koa-compose库，在该库中，中间件会被next()函数分成两部分，先执行next()之前的部分，在请求处理完毕后，再执行next()后面的部分。
下图是官方给的一张中间件执行顺序示意图。
在下图中，每一层相当于是一个中间件，在request时，处理的是next()的前半部分，在response时，处理的是其后半部分。
下面就是koa-compose库的所有代码，已加注释，为了便于理解，我已经将可执行的代码放到codepen中，在线调试。
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!') } /** * 返回一个函数 * context就是ctx * next()函数就是下一个中间件函数 */ return function (context, next) { // 上一个中间件的索引 let index = -1 // 启动dispatch()函数，初始值是0 return dispatch(0) function dispatch (i) { // 以免在一个中间件内，调用多次next() if (i <= index) return Promise.reject(new Error('next() called multiple times')) index = i // fn就是中间件函数 let fn = middleware[i] // 中间件都已执行过一次，fn是undefined if (i === middleware.length) fn = next // 终止递归 if (!fn) return Promise.resolve() try { // fn是中间件，dispatch()就是下一个中间件的next()函数 return Promise.resolve(fn(context, dispatch.bind(null, i + 1))) } catch (err) { return Promise.reject(err) } } } }
函数分为几步：
- 第一步是检查中间件数组和中间件的类型。
- 第二步是返回一个函数，参数是 ctx 和 next()，其中 next() 就是下一个中间件函数。
- 第三步是调用 dispatch(0) 启动中间件的运行，并且在一个中间件中，不允许多次调用 next() 函数。
- 第四步是递归地依次为每一个要执行的中间件传递参数，其第二个参数是下一个 dispatch() 函数。
递归过程中的 dispatch() 其实就是中间件中的 next() 函数。
Promise.resolve(fn(context, dispatch.bind(null, i + 1))) 会先运行一次中间件，然后遇到 next()，就去运行下一个中间件，递归终止后，再回溯处理中间件余下的逻辑。
5）createContext()
每次HTTP请求都生成一个新的context，与其他请求中的context之间相互隔离。
createContext (req, res) { // 每次HTTP请求都生成一个新的context 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 // 挂载Node原生的req和res 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 // 可自定义的状态，例如koa-jwt库就使用了该属性 context.state = {} return context }
context具备高内聚的特征，因为它能访问KOA提供的所有数据和方法。
并且还预留了一个state属性，可用于传递自定义的状态值。
6）handleRequest()
在 handleRequest() 函数中，会运行中间件函数，以及处理响应的不同情况。
/** * 在回调中处理请求 * @param {*} ctx 上下文 * @param {*} fnMiddleware 可执行的中间件函数 * @returns */ handleRequest (ctx, fnMiddleware) { const res = ctx.res res.statusCode = 404 const onerror = err => ctx.onerror(err) // 不同情况的响应处理 const handleResponse = () => respond(ctx) onFinished(res, onerror) return fnMiddleware(ctx).then(handleResponse).catch(onerror) }
respond()函数内容比较多，包括为格式化JSON格式的body，流类型的body调用pipe()，为HEAD请求加 Content-Length 头等。
官方也提供了属性，来绕开上述这些处理。
function respond (ctx) { // 允许绕过KOA的处理 if (ctx.respond === false) return if (!ctx.writable) return const res = ctx.res let body = ctx.body const code = ctx.status // code不是已知的状态码 if (statuses.empty[code]) { // strip headers ctx.body = null return res.end() } // HEAD请求 if (ctx.method === 'HEAD') { // 加Content-Lengthh头 if (!res.headersSent && !ctx.response.has('Content-Length')) { const { length } = ctx.response if (Number.isInteger(length)) ctx.length = length } return res.end() } // status body if (body == null) { if (ctx.response._explicitNullBody) { ctx.response.remove('Content-Type') ctx.response.remove('Transfer-Encoding') ctx.length = 0 return res.end() } if (ctx.req.httpVersionMajor >= 2) { body = String(code) } else { body = ctx.message || String(code) } if (!res.headersSent) { ctx.type = 'text' ctx.length = Buffer.byteLength(body) } return res.end(body) } // 对body的三种类型采用不同的处理 if (Buffer.isBuffer(body)) return res.end(body) if (typeof body === 'string') return res.end(body) if (body instanceof Stream) return body.pipe(res) // JSON格式的body body = JSON.stringify(body) if (!res.headersSent) { ctx.length = Buffer.byteLength(body) } res.end(body) }
参考资料：