简介

Koa 是一个新的 web 框架，由 Express 幕后的原班人马打造， 致力于成为 web 应用和 API 开发领域中的一个更小、更富有表现力、更健壮的基石。 通过利用 async 函数，Koa 帮你丢弃回调函数，并有力地增强错误处理。 Koa 并没有捆绑任何中间件， 而是提供了一套优雅的方法，帮助您快速而愉快地编写服务端应用程序。

今天要简单的看一下koa的源码，首先需要说明的一点，本文都是笔者个人观点，同时我接触koa的时间并不长，设置接触nodejs的时间也不长，所以大家最好都带着批判的思维来阅读本文，希望不要对大家造成误导。

使用

最简单的一个应用

const Koa = require('koa');
const app = new Koa();
app.listen(3000);

这是一个无作用的 Koa 应用程序被绑定到 3000 端口

上手使用一个框架，只需要5分钟。正因为如此很多人都忽略了框架的内部实现。

知其然，知其所以然。我们下面了解一下其源码构成。

源码解析

进入正题，关于源码，找到了两套，一个在github上，https://github.com/koajs/koa

另一个是在我之前使用的koa项目里，项目里通过ide点击跳转过去的是一个 index.d.ts，是一个typescript的实现，不过这两套代码在功能上应该是完全一样的。

这里由于我之前并未接触过typescript，所以选择去解读一下GitHub上的开源代码。

在代码lib目录下，有4个文件application.js、context.js、request.js、response.js 差不多可以猜测结构，对外暴露的koa就是这边的 application.js 里export的对象，其他三个为application的重要组成部分。

先从application看起。

'use strict';
/**
 * Module dependencies.
 */
const isGeneratorFunction = require('is-generator-function');
const debug = require('debug')('koa:application');
const onFinished = require('on-finished');
const response = require('./response');
const compose = require('koa-compose');
const isJSON = require('koa-is-json');
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 convert = require('koa-convert');
const deprecate = require('depd')('koa');

这边use strict开启JavaScript的严格模式，这种写法在框架代码中很常见，越是底层的代码，越需要严格，所以在我们平时写上层应用时，use strict就用的少很多了。

然后是依赖的相关文件，这里可以看到的确依赖同级目录下的context、request、response文件，但同时还依赖很多外部扩展。

• is-generator-function 判断是否是generator函数
• debug来调试，用于打印相关log
• on-finished 看了说明，用来监听http请求结束时的回调
• koa-compose用于构建中间件
• koa-is-json用于Check if a body is JSON
• statuses提供http的status单元
• events实现了事件机制 Node's event emitter for all engines
• util提供了一系列常用工具函数
• stream 是 Node.js 中处理流式数据的抽象接口。 stream 模块提供了一些 API，用于构建实现了流接口的对象。Node.js 提供了多种流对象。 例如，HTTP 服务器的请求和 process.stdout 都是流的实例。流可以是可读的、可写的、或者可读可写的。 所有的流都是 EventEmitter 的实例。
• http 要使用 HTTP 服务器与客户端，需要 require('http')
• only Return whitelisted properties of an object.
• koa-convert 用于支持之前版本的koajs
• depd类似命名空间的用法

到这里就把依赖的库大致讲了一遍，当然没搞明白也没关系，这里只需要有个大致的概念，后面具体用到了可以回过头来在看。

然后就是application的主要部分了

/**
 * Expose `Application` class.
 * Inherits from `Emitter.prototype`.
 */
module.exports = class Application extends Emitter {
}

这里可以看到 application是继承自Emitter,也就是 events.继续看内部的代码

 /**
 * 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);
 if (util.inspect.custom) {
 this[util.inspect.custom] = this.inspect;
 }
 }

这是构造函数，里面定义了一些成员变量，不一一说明了。继续往下到了listen方法

 /**
 * Shorthand for:
 *
 * http.createServer(app.callback()).listen(...)
 *
 * @param {Mixed} ...
 * @return {Server}
 * @api public
 */
 listen(...args) {
 debug('listen');
 const server = http.createServer(this.callback());
 return server.listen(...args);
 }

这里的listen其实就对http.createServer(callback).listen的一种缩写。算是一个语法糖。不难理解。继续往下。

/**
 * Return JSON representation.
 * We only bother showing settings.
 *
 * @return {Object}
 * @api public
 */
 toJSON() {
 return only(this, [
 'subdomainOffset',
 'proxy',
 'env'
 ]);
 }

/**
 * Inspect implementation.
 *
 * @return {Object}
 * @api public
 */
 inspect() {
 return this.toJSON();
 }

这个就是一个简单的成员变量保护，只对外暴露三个属性。

/**
 * Use the given middleware `fn`.
 *
 * Old-style middleware will be converted.
 *
 * @param {Function} fn
 * @return {Application} self
 * @api public
 */
 use(fn) {
 if (typeof fn !== 'function') throw new TypeError('middleware must be a function!');
 if (isGeneratorFunction(fn)) {
 deprecate('Support for generators will be removed in v3. ' +
 'See the documentation for examples of how to convert old middleware ' +
 'https://github.com/koajs/koa/blob/master/docs/migration.md');
 fn = convert(fn);
 }
 debug('use %s', fn._name || fn.name || '-');
 this.middleware.push(fn);
 return this;
 }

这个是use方法，平时的use就是把函数推到middleware属性中，如果是generator函数，这边会做个转化，然后再推入，逻辑也相当简单。

/**
 * Return a request handler callback
 * for node's native http server.
 *
 * @return {Function}
 * @api public
 */
 callback() {
 const fn = compose(this.middleware);
 if (!this.listenerCount('error')) this.on('error', this.onerror);
 const handleRequest = (req, res) => {
 const ctx = this.createContext(req, res);
 return this.handleRequest(ctx, fn);
 };
 return handleRequest;
 }

callback先把middleware组装好，然后开启了一个错误事件监听。然后有调用了下面的createContext和handleRequest方法。结合上面的listen方法可以看到callback被用到http.createServer(this.callback())中，也就是一个简单的封装而已。并不难理解，那继续往下看。

/**
 * Handle request in callback.
 *
 * @api private
 */
 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);
 }

这个用在callback里的方法，可以看到执行了fnMiddleware方法，同时用到下面的onerror和respond。这里的onFinished也是一个监听吧，暂时这么理解，先往下看。

 /**
 * 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.state = {};
 return context;
 }

这一步也不难理解，创建了一个context对象，并且初始化了他的各项属性值。接下来的onerror也很好理解。

/**
 * Default error handler.
 *
 * @param {Error} err
 * @api private
 */
 onerror(err) {
 if (!(err instanceof Error)) throw new TypeError(util.format('non-error thrown: %j', err));
 if (404 == err.status || err.expose) return;
 if (this.silent) return;
 const msg = err.stack || err.toString();
 console.error();
 console.error(msg.replace(/^/gm, ' '));
 console.error();
 }

就在控制台打印了一些错误，并没什么难懂的。

然后application内部的方法就没了，梳理下来很少，并且几乎一眼看懂其作用，然后就是定义外的一个辅助方法，或者叫他工具方法。

/**
 * Response helper.
 */
function respond(ctx) {
 // allow bypassing koa
 if (false === ctx.respond) return;
 const res = ctx.res;
 if (!ctx.writable) return;
 let body = ctx.body;
 const code = ctx.status;
 // ignore body
 if (statuses.empty[code]) {
 // strip headers
 ctx.body = null;
 return res.end();
 }
 if ('HEAD' == ctx.method) {
 if (!res.headersSent && isJSON(body)) {
 ctx.length = Buffer.byteLength(JSON.stringify(body));
 }
 return res.end();
 }
 // status body
 if (null == body) {
 body = ctx.message || String(code);
 if (!res.headersSent) {
 ctx.type = 'text';
 ctx.length = Buffer.byteLength(body);
 }
 return res.end(body);
 }
 // responses
 if (Buffer.isBuffer(body)) return res.end(body);
 if ('string' == typeof body) return res.end(body);
 if (body instanceof Stream) return body.pipe(res);
 // body: json
 body = JSON.stringify(body);
 if (!res.headersSent) {
 ctx.length = Buffer.byteLength(body);
 }
 res.end(body);
}

这个函数顾名思义，就是一个response的封装函数，50行代码，也很清晰。

总的看下来逻辑非常清楚，需要主要到一点的，所有的res和req都是同一个对象，在不同的方法里反复传递使用，所以非常方便。

看到这边，感觉koa的核心思想真的非常简单，说直接点仅仅就是实现了use而已，提供了一个干净的中间件框架。我们可以很方便的写中间件，除此之后，和原生的http模块几乎没什么区别。

看过很多框架源码、类库源码，koa可以说是我见过最简短的一个了。

希望大家能从我的分享中有所收获，还有不足不对之处欢迎指出。