KOA2框架原理解析和实现

Posted 腾讯IMWeb前端团队

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了KOA2框架原理解析和实现相关的知识，希望对你有一定的参考价值。

什么是koa框架？

koa是一个基于node实现的一个新的web框架，它是由express框架的原班人马打造的。它的特点是优雅、简洁、表达力强、自由度高。它更express相比，它是一个更轻量的node框架，因为它所有功能都通过插件实现，这种插拔式的架构设计模式，很符合unix哲学。

koa框架现在更新到了2.x版本，本文从零开始，循序渐进，讲解koa2的框架源码结构和实现原理，展示和详解koa2框架源码中的几个最重要的概念，然后手把手教大家亲自实现一个简易的koa2框架，帮助大家学习和更深层次的理解koa2，看完本文以后，再去对照koa2的源码进行查看，相信你的思路将会非常的顺畅。

本文所用的框架是koa2，它跟koa1不同，koa1使用的是generator+co.js的执行方式，而koa2中使用了async/await，因此本文的代码和demo需要运行在node 8版本及其以上，如果读者的node版本较低，建议升级或者安装babel-cli，用其中的babel-node来运行本文涉及到的代码。

koa源码结构

上图是koa2的源码目录结构的lib文件夹，lib文件夹下放着四个koa2的核心文件：application.js、context.js、request.js、response.js。

application.js

application.js是koa的入口文件，它向外导出了创建class实例的构造函数，它继承了events，这样就会赋予框架事件监听和事件触发的能力。application还暴露了一些常用的api，比如toJSON、listen、use等等。

listen的实现原理其实就是对http.createServer进行了一个封装，重点是这个函数中传入的callback，它里面包含了中间件的合并，上下文的处理，对res的特殊处理。

use是收集中间件，将多个中间件放入一个缓存队列中，然后通过koa-compose这个插件进行递归组合调用这一些列的中间件。

实现koa2的四大模块

上文简述了koa2源码的大体框架结构，接下来我们来实现一个koa2的框架，笔者认为理解和实现一个koa框架需要实现四个大模块，分别是：

  1. 封装node http server、创建Koa类构造函数

  2. 构造request、response、context对象

  3. 中间件机制和剥洋葱模型的实现

  4. 错误捕获和错误处理

下面我们就逐一分析和实现。

模块一：封装node http server和创建Koa类构造函数

阅读koa2的源码得知，实现koa的服务器应用和端口监听，其实就是基于node的原生代码进行了封装，如下图的代码就是通过node原生代码实现的服务器监听。

 
   
   
 
    
  
    
    
  
  1. let http = require('http');
    2. 
  
    
    
  
  2. let server = http.createServer((req, res) => {
    3. 
  
    
    
  
  3.     res.writeHead(200);
    4. 
  
    
    
  
  4.     res.end('hello world');
    5. 
  
    
    
  
  5. });
    6. 
  
    
    
  
  6. server.listen(3000, () => {    
    7. 
  
    
    
  
  7.     console.log('listenning on 3000');
    8. 
  
    
    
  
  8. });
    9.

我们需要将上面的node原生代码封装实现成koa的模式：

 
   
   
 
    
  
    
    
  
  1. const http = require('http');
    2. 
  
    
    
  
  2. const Koa = require('koa');
    3. 
  
    
    
  
  3. const app = new Koa();
    4. 
  
    
    
  
  4. app.listen(3000);
    5.

实现koa的第一步就是对以上的这个过程进行封装，为此我们需要创建application.js实现一个Application类的构造函数：

 
   
   
 
    
  
    
    
  
  1. let http = require('http');
    2. 
  
    
    
  
  2. class Application {    
    3. 
  
    
    
  
  3.     constructor() {        
    4. 
  
    
    
  
  4.         this.callbackFunc;
    5. 
  
    
    
  
  5.     }
    6. 
  
    
    
  
  6.     listen(port) {        
    7. 
  
    
    
  
  7.         let server = http.createServer(this.callback());
    8. 
  
    
    
  
  8.         server.listen(port);
    9. 
  
    
    
  
  9.     }
    10. 
  
    
    
  
  10.     use(fn) {
    11. 
  
    
    
  
  11.         this.callbackFunc = fn;
    12. 
  
    
    
  
  12.     }
    13. 
  
    
    
  
  13.     callback() {
    14. 
  
    
    
  
  14.         return (req, res) => {
    15. 
  
    
    
  
  15.             this.callbackFunc(req, res);
    16. 
  
    
    
  
  16.         };
    17. 
  
    
    
  
  17.     }
    18. 
  
    
    
  
  18. }
    19. 
  
    
    
  
  19. module.exports = Application;
    20.

然后创建example.js，引入application.js，运行服务器实例启动监听代码：

 
   
   
 
    
  
    
    
  
  1. let Koa = require('./application');
    2. 
  
    
    
  
  2. let app = new Koa();
    3. 
  
    
    
  
  3. app.use((req, res) => {
    4. 
  
    
    
  
  4.     res.writeHead(200);
    5. 
  
    
    
  
  5.     res.end('hello world');
    6. 
  
    
    
  
  6. });
    7. 
  
    
    
  
  7. app.listen(3000, () => {
    8. 
  
    
    
  
  8.     console.log('listening on 3000');
    9. 
  
    
    
  
  9. });
    10.

现在在浏览器输入localhost:3000即可看到浏览器里显示“hello world”。现在第一步我们已经完成了，对http server进行了简单的封装和创建了一个可以生成koa实例的类class，这个类里还实现了app.use用来注册中间件和注册回调函数，app.listen用来开启服务器实例并传入callback回调函数，第一模块主要是实现典型的koa风格和搭好了一个koa的简单的架子。接下来我们开始编写和讲解第二模块。

模块二：构造request、response、context对象

阅读koa2的源码得知，其中context.js、request.js、response.js三个文件分别是request、response、context三个模块的代码文件。context就是我们平时写koa代码时的ctx，它相当于一个全局的koa实例上下文this，它连接了request、response两个功能模块，并且暴露给koa的实例和中间件等回调函数的参数中，起到承上启下的作用。

request、response两个功能模块分别对node的原生request、response进行了一个功能的封装，使用了getter和setter属性，基于node的对象req/res对象封装koa的request/response对象。我们基于这个原理简单实现一下request.js、response.js，首先创建request.js文件，然后写入以下代码：

 
   
   
 
    
  
    
    
  
  1. let url = require('url');
    2. 
  
    
    
  
  2. module.exports = {
    3. 
  
    
    
  
  3.     get query() {
    4. 
  
    
    
  
  4.         return url.parse(this.req.url, true).query;
    5. 
  
    
    
  
  5.     }
    6. 
  
    
    
  
  6. };
    7.

这样当你在koa实例里使用ctx.query的时候，就会返回url.parse(this.req.url, true).query的值。看源码可知，基于getter和setter，在request.js里还封装了header、url、origin、path等方法，都是对原生的request上用getter和setter进行了封装，笔者不再这里一一实现。

接下来我们实现response.js文件代码模块，它和request原理一样，也是基于getter和setter对原生response进行了封装，那我们接下来通过对常用的ctx.body和ctx.status这个两个语句当做例子简述一下如果实现koa的response的模块，我们首先创建好response.js文件，然后输入下面的代码：

 
   
   
 
    
  
    
    
  
  1. module.exports = {
    2. 
  
    
    
  
  2.     get body() {
    3. 
  
    
    
  
  3.         return this._body;
    4. 
  
    
    
  
  4.     },
    5. 
  
    
    
  
  5.     set body(data) {
    6. 
  
    
    
  
  6.         this._body = data;
    7. 
  
    
    
  
  7.     },
    8. 
  
    
    
  
  8.     get status() {
    9. 
  
    
    
  
  9.         return this.res.statusCode;
    10. 
  
    
    
  
  10.     },
    11. 
  
    
    
  
  11.     set status(statusCode) {
    12. 
  
    
    
  
  12.         if (typeof statusCode !== 'number') {
    13. 
  
    
    
  
  13.             throw new Error('something wrong!');
    14. 
  
    
    
  
  14.         }
    15. 
  
    
    
  
  15.         this.res.statusCode = statusCode;
    16. 
  
    
    
  
  16.     }
    17. 
  
    
    
  
  17. };
    18.

以上代码实现了对koa的status的读取和设置，读取的时候返回的是基于原生的response对象的statusCode属性，而body的读取则是对this._body进行读写和操作。这里对body进行操作并没有使用原生的this.res.end，因为在我们编写koa代码的时候，会对body进行多次的读取和修改，所以真正返回浏览器信息的操作是在application.js里进行封装和操作。

现在我们已经实现了request.js、response.js，获取到了request、response对象和他们的封装的方法，然后我们开始实现context.js，context的作用就是将request、response对象挂载到ctx的上面，让koa实例和代码能方便的使用到request、response对象中的方法。现在我们创建context.js文件，输入如下代码：

 
   
   
 
    
  
    
    
  
  1. let proto = {};
    2. 
  
    
    
  
  2. function delegateSet(property, name) {
    3. 
  
    
    
  
  3.     proto.__defineSetter__(name, function (val) {
    4. 
  
    
    
  
  4.         this[property][name] = val;
    5. 
  
    
    
  
  5.     });
    6. 
  
    
    
  
  6. }
    7. 
  
    
    
  
  7. function delegateGet(property, name) {
    8. 
  
    
    
  
  8.     proto.__defineGetter__(name, function () {
    9. 
  
    
    
  
  9.         return this[property][name];
    10. 
  
    
    
  
  10.     });
    11. 
  
    
    
  
  11. }
    12. 
  
    
    
  
  12. let requestSet = [];
    13. 
  
    
    
  
  13. let requestGet = ['query'];
    14. 
  
    
    
  
  14. let responseSet = ['body', 'status'];
    15. 
  
    
    
  
  15. let responseGet = responseSet;
    16. 
  
    
    
  
  16. requestSet.forEach(ele => {
    17. 
  
    
    
  
  17.     delegateSet('request', ele);
    18. 
  
    
    
  
  18. });
    19. 
  
    
    
  
  19. requestGet.forEach(ele => {
    20. 
  
    
    
  
  20.     delegateGet('request', ele);
    21. 
  
    
    
  
  21. });
    22. 
  
    
    
  
  22. responseSet.forEach(ele => {
    23. 
  
    
    
  
  23.     delegateSet('response', ele);
    24. 
  
    
    
  
  24. });
    25. 
  
    
    
  
  25. responseGet.forEach(ele => {
    26. 
  
    
    
  
  26.     delegateGet('response', ele);
    27. 
  
    
    
  
  27. });
    28. 
  
    
    
  
  28. module.exports = proto;
    29.

context.js文件主要是对常用的request和response方法进行挂载和代理，通过context.query直接代理了context.request.query，context.body和context.status代理了context.response.body与context.response.status。而context.request，context.response则会在application.js中挂载。

本来可以用简单的setter和getter去设置每一个方法，但是由于context对象定义方法比较简单和规范，在koa源码里可以看到，koa源码用的是defineSetter和defineSetter来代替setter/getter每一个属性的读取设置，这样做主要是方便拓展和精简了写法，当我们需要代理更多的res和req的方法的时候，可以向context.js文件里面的数组对象里面添加对应的方法名和属性名即可。

目前为止，我们已经得到了request、response、context三个模块对象了，接下来就是将request、response所有方法挂载到context下，让context实现它的承上启下的作用，修改application.js文件，添加如下代码：

 
   
   
 
    
  
    
    
  
  1. let http = require('http');
    2. 
  
    
    
  
  2. let context = require('./context');
    3. 
  
    
    
  
  3. let request = require('./request');
    4. 
  
    
    
  
  4. let response = require('./response');
    5. 
  
    
    
  
  5. createContext(req, res) {       
    6. 
  
    
    
  
  6.    let ctx = Object.create(this.context);
    7. 
  
    
    
  
  7.    ctx.request = Object.create(this.request);
    8. 
  
    
    
  
  8.    ctx.response = Object.create(this.response);
    9. 
  
    
    
  
  9.    ctx.req = ctx.request.req = req;
    10. 
  
    
    
  
  10.    ctx.res = ctx.response.res = res; 
    11. 
  
    
    
  
  11.    return ctx;
    12. 
  
    
    
  
  12. }
    13.

可以看到，我们添加了createContext这个方法，这个方法是关键，它通过Object.create创建了ctx，并将request和response挂载到了ctx上面，将原生的req和res挂载到了ctx的子属性上，往回看一下context/request/response.js文件，就能知道当时使用的this.res或者this.response之类的是从哪里来的了，原来是在这个createContext方法中挂载到了对应的实例上，构建了运行时上下文ctx之后，我们的app.use回调函数参数就都基于ctx了。

模块三：中间件机制和剥洋葱模型的实现

目前为止我们已经成功实现了上下文context对象、 请求request对象和响应response对象模块，还差一个最重要的模块，就是koa的中间件模块，koa的中间件机制是一个剥洋葱式的模型，多个中间件通过use放进一个数组队列然后从外层开始执行，遇到next后进入队列中的下一个中间件，所有中间件执行完后开始回帧，执行队列中之前中间件中未执行的代码部分，这就是剥洋葱模型，koa的中间件机制。

koa的剥洋葱模型在koa1中使用的是generator + co.js去实现的，koa2则使用了async/await + Promise去实现的，接下来我们基于async/await + Promise去实现koa2中的中间件机制。首先，假设当koa的中间件机制已经做好了，那么它是能成功运行下面代码的：

 
   
   
 
    
  
    
    
  
  1. let Koa = require('../src/application');
    2. 
  
    
    
  
  2. let app = new Koa();
    3. 
  
    
    
  
  3. app.use(async (ctx, next) => {
    4. 
  
    
    
  
  4.     console.log(1);
    5. 
  
    
    
  
  5.     await next();
    6. 
  
    
    
  
  6.     console.log(6);
    7. 
  
    
    
  
  7. });
    8. 
  
    
    
  
  8. app.use(async (ctx, next) => {
    9. 
  
    
    
  
  9.     console.log(2);
    10. 
  
    
    
  
  10.     await next();
    11. 
  
    
    
  
  11.     console.log(5);
    12. 
  
    
    
  
  12. });
    13. 
  
    
    
  
  13. app.use(async (ctx, next) => {
    14. 
  
    
    
  
  14.     console.log(3);
    15. 
  
    
    
  
  15.     ctx.body = "hello world";
    16. 
  
    
    
  
  16.     console.log(4);
    17. 
  
    
    
  
  17. });
    18. 
  
    
    
  
  18. app.listen(3000, () => {
    19. 
  
    
    
  
  19.     console.log('listenning on 3000');
    20. 
  
    
    
  
  20. });
    21.

运行成功后会在终端输出123456，那就能验证我们的koa的剥洋葱模型是正确的。接下来我们开始实现，修改application.js文件，添加如下代码：

 
   
   
 
    
  
    
    
  
  1.     compose() {
    2. 
  
    
    
  
  2.         return async ctx => {
    3. 
  
    
    
  
  3.             function createNext(middleware, oldNext) {
    4. 
  
    
    
  
  4.                 return async () => {
    5. 
  
    
    
  
  5.                     await middleware(ctx, oldNext);
    6. 
  
    
    
  
  6.                 }
    7. 
  
    
    
  
  7.             }
    8. 
  
    
    
  
  8.             let len = this.middlewares.length;
    9. 
  
    
    
  
  9.             let next = async () => {
    10. 
  
    
    
  
  10.                 return Promise.resolve();
    11. 
  
    
    
  
  11.             };
    12. 
  
    
    
  
  12.             for (let i = len - 1; i >= 0; i--) {
    13. 
  
    
    
  
  13.                 let currentMiddleware = this.middlewares[i];
    14. 
  
    
    
  
  14.                 next = createNext(currentMiddleware, next);
    15. 
  
    
    
  
  15.             }
    16. 
  
    
    
  
  16.             await next();
    17. 
  
    
    
  
  17.         };
    18. 
  
    
    
  
  18.     }
    19. 
  
    
    
  
  19.     callback() {
    20. 
  
    
    
  
  20.         return (req, res) => {
    21. 
  
    
    
  
  21.             let ctx = this.createContext(req, res);
    22. 
  
    
    
  
  22.             let respond = () => this.responseBody(ctx);
    23. 
  
    
    
  
  23.             let onerror = (err) => this.onerror(err, ctx);
    24. 
  
    
    
  
  24.             let fn = this.compose();
    25. 
  
    
    
  
  25.             return fn(ctx);
    26. 
  
    
    
  
  26.         };
    27. 
  
    
    
  
  27.     }
    28.

koa通过use函数，把所有的中间件push到一个内部数组队列this.middlewares中，剥洋葱模型能让所有的中间件依次执行，每次执行完一个中间件，遇到next()就会将控制权传递到下一个中间件，下一个中间件的next参数，剥洋葱模型的最关键代码是compose这个函数：

 
   
   
 
    
  
    
    
  
  1. compose() {
    2. 
  
    
    
  
  2.         return async ctx => {
    3. 
  
    
    
  
  3.             function createNext(middleware, oldNext) {
    4. 
  
    
    
  
  4.                 return async () => {
    5. 
  
    
    
  
  5.                     await middleware(ctx, oldNext);
    6. 
  
    
    
  
  6.                 }
    7. 
  
    
    
  
  7.             }
    8. 
  
    
    
  
  8.             let len = this.middlewares.length;
    9. 
  
    
    
  
  9.             let next = async () => {
    10. 
  
    
    
  
  10.                 return Promise.resolve();
    11. 
  
    
    
  
  11.             };
    12. 
  
    
    
  
  12.             for (let i = len - 1; i >= 0; i--) {
    13. 
  
    
    
  
  13.                 let currentMiddleware = this.middlewares[i];
    14. 
  
    
    
  
  14.                 next = createNext(currentMiddleware, next);
    15. 
  
    
    
  
  15.             }
    16. 
  
    
    
  
  16.             await next();
    17. 
  
    
    
  
  17.         };
    18. 
  
    
    
  
  18.     }
    19.

createNext函数的作用就是将上一个中间件的next当做参数传给下一个中间件，并且将上下文ctx绑定当前中间件，当中间件执行完，调用next()的时候，其实就是去执行下一个中间件。

 
   
   
 
    
  
    
    
  
  1. for (let i = len - 1; i >= 0; i--) {
    2. 
  
    
    
  
  2.         let currentMiddleware = this.middlewares[i];
    3. 
  
    
    
  
  3.         next = createNext(currentMiddleware, next);
    4. 
  
    
    
  
  4.  }
    5.

上面这段代码其实就是一个链式反向递归模型的实现，i是从最大数开始循环的，将中间件从最后一个开始封装，每一次都是将自己的执行函数封装成next当做上一个中间件的next参数，这样当循环到第一个中间件的时候，只需要执行一次next()，就能链式的递归调用所有中间件，这个就是koa剥洋葱的核心代码机制。

到这里我们总结一下上面所有剥洋葱模型代码的流程，通过use传进来的中间件是一个回调函数，回调函数的参数是ctx上下文和next，next其实就是控制权的交接棒，next的作用是停止运行当前中间件，将控制权交给下一个中间件，执行下一个中间件的next()之前的代码，当下一个中间件运行的代码遇到了next()，又会将代码执行权交给下下个中间件，当执行到最后一个中间件的时候，控制权发生反转，开始回头去执行之前所有中间件中剩下未执行的代码，这整个流程有点像一个伪递归，当最终所有中间件全部执行完后，会返回一个Promise对象，因为我们的compose函数返回的是一个async的函数，async函数执行完后会返回一个Promise，这样我们就能将所有的中间件异步执行同步化，通过then就可以执行响应函数和错误处理函数。

当中间件机制代码写好了以后，运行我们的上面的例子，已经能输出123456了，至此，我们的koa的基本框架已经基本做好了，不过一个框架不能只实现功能，为了框架和服务器实例的健壮，还需要加上错误处理机制。

模块四：错误捕获和错误处理

要实现一个基础框架，错误处理和捕获必不可少，一个健壮的框架，必须保证在发生错误的时候，能够捕获到错误和抛出的异常，并反馈出来，将错误信息发送到监控系统上进行反馈，目前我们实现的简易koa框架还没有能实现这一点，我们接下加上错误处理和捕获的机制。

 
   
   
 
    
  
    
    
  
  1. throw new Error('oooops');
    2.

基于现在的框架，如果中间件代码中出现如上错误异常抛出，是捕获不到错误的，这时候我们看一下application.js中的callback函数的return返回代码，如下：

 
   
   
 
    
  
    
    
  
  1. return fn(ctx).then(respond);
    2.

可以看到，fn是中间件的执行函数，每一个中间件代码都是由async包裹着的，而且中间件的执行函数compose返回的也是一个async函数，我们根据es7的规范知道，async返回的是一个promise的对象实例，我们如果想要捕获promise的错误，只需要使用promise的catch方法，就可以把所有的中间件的异常全部捕获到，修改后callback的返回代码如下：

 
   
   
 
    
  
    
    
  
  1. return fn(ctx).then(respond).catch(onerror);
    2.

现在我们已经实现了中间件的错误异常捕获，但是我们还缺少框架层发生错误的捕获机制，我们希望我们的服务器实例能有错误事件的监听机制，通过on的监听函数就能订阅和监听框架层面上的错误，实现这个机制不难，使用nodejs原生events模块即可，events模块给我们提供了事件监听on函数和事件触发emit行为函数，一个发射事件，一个负责接收事件，我们只需要将koa的构造函数继承events模块即可，构造后的伪代码如下：

 
   
   
 
    
  
    
    
  
  1. let EventEmitter = require('events');
    2. 
  
    
    
  
  2. class Application extends EventEmitter {}
    3.

继承了events模块后，当我们创建koa实例的时候，加上on监听函数，代码如下：

 
   
   
 
    
  
    
    
  
  1. let app = new Koa();
    2. 
  
    
    
  
  2. app.on('error', err => {
    3. 
  
    
    
  
  3.     console.log('error happends: ', err.stack);
    4. 
  
    
    
  
  4. });
    5.

这样我们就实现了框架层面上的错误的捕获和监听机制了。总结一下，错误处理和捕获，分中间件的错误处理捕获和框架层的错误处理捕获，中间件的错误处理用promise的catch，框架层面的错误处理用nodejs的原生模块events，这样我们就可以把一个服务器实例上的所有的错误异常全部捕获到了。至此，我们就完整实现了一个轻量版的koa框架了。

结尾

目前为止，我们已经实现了一个轻量版的koa框架了，我们实现了封装node http server、创建Koa类构造函数、构造request、response、context对象、中间件机制和剥洋葱模型的实现、错误捕获和错误处理这四个大模块，理解了这个轻量版koa的实现原理，再去看koa2的源码，你就会发现一切都豁然开朗，koa2的源码无非就是在这个轻量版基础上加了很多工具函数和细节的处理，限于篇幅笔者就不再一一介绍了。

关注我们

IMWeb 团队隶属腾讯公司，是国内最专业的前端团队之一。

我们专注前端领域多年，负责过 QQ 资料、QQ 注册、QQ 群等亿级业务。目前聚焦于在线教育领域，精心打磨 腾讯课堂 及 企鹅辅导 两大产品。

社区官网：

http://imweb.io/

https://hr.tencent.com/position_detail.php?id=26701



以上是关于KOA2框架原理解析和实现的主要内容，如果未能解决你的问题，请参考以下文章

koa2中间件koa和koa-compose源码分析原理

koa2中间件

Spring AOP源码解析：Spring事务实现原理

Koa原理和封装

koa2、koa1、express比较

Dubbo原理和源码解析之服务暴露