compose函数实现

  • 每一个中间件需要封装一个 Promise
  • 洋葱模型的先进后出操作，对应Promise.resolve的前后操作
  1. const middleware1 = async (ctx, next) => {
  2.   console.log(1);
  3.   await next();
  4.   console.log(6);
  5. };
  7. const middleware2 = async (ctx, next) => {
  8.   console.log(2);
  9.   await next();
  10.   console.log(5);
  11. };
  13. const middleware3 = async (ctx, next) => {
  14.   console.log(3);
  15.   await next();
  16.   console.log(4);
  17. };
  19. const fn = compose([middleware1, middleware2, middleware3]);
  21. fn().then(() => {
  22.   console.log("end");
  23. });
  25. function compose(middlewares) {
  26.   if (!Array.isArray(middlewares)) {
  27.     throw new TypeError("middle need a array");
  28.   }
  29.   return function (ctx, next) {
  30.     let index = -1;
  31.     // 第一次调用
  32.     return dispatch(0);
  34.     function dispatch(i) {
  35.       if (i < index) {
  36.         return Promise.reject(new Error("next() call multiple times"));
  37.       }
  39.       index = i;
  41.       let fn = middlewares[i];
  43.       if (i === middlewares.length) {
  44.         fn = next;
  45.       }
  47.       if (!fn) {
  48.         return Promise.resolve();
  49.       }
  51.       try {
  52.         return Promise.resolve(
  53.           fn(ctx, () => {
  54.             return dispatch(i + 1);
  55.           })
  56.         );
  57.       } catch (e) {
  58.         return Promise.reject(e);
  59.       }
  60.     }
  61.   };
  62. }
  64. // 结果显示
  65. // "1"
  66. // "2"
  67. // "3"
  68. // "4"
  69. // "5"
  70. // "6"
  71. // "end"

结合http与events模块实现

  1. const http = require("http");
  2. const Emitter = require("events");
  4. const context = {
  5.   _body: null,
  7.   get body() {
  8.     return this._body;
  9.   },
  11.   set body(val) {
  12.     this._body = val;
  13.     this.res.end(this._body);
  14.   },
  15. };
  17. function compose(middlewares) {
  18.   if (!Array.isArray(middlewares)) {
  19.     throw new TypeError("middle need a array");
  20.   }
  21.   return function (ctx, next) {
  22.     let index = -1;
  23.     // 第一次调用
  24.     return dispatch(0);
  26.     function dispatch(i) {
  27.       if (i < index) {
  28.         return Promise.reject(new Error("next() call multiple times"));
  29.       }
  31.       index = i;
  33.       let fn = middlewares[i];
  35.       if (i === middlewares.length) {
  36.         fn = next;
  37.       }
  39.       if (!fn) {
  40.         return Promise.resolve();
  41.       }
  43.       try {
  44.         return Promise.resolve(
  45.           fn(ctx, () => {
  46.             return dispatch(i + 1);
  47.           })
  48.         );
  49.       } catch (e) {
  50.         return Promise.reject(e);
  51.       }
  52.     }
  53.   };
  54. }
  56. class MyKoa extends Emitter {
  57.   constructor() {
  58.     super();
  59.     this.middleware = [];
  60.     this.context = Object.create(context);
  61.   }
  63.   /**
  64.    * 服务端监听
  65.    * @param  {...any} args
  66.    */
  68.   listen(...args) {
  69.     const server = http.createServer(this.callback());
  70.     return server.listen(...args);
  71.   }
  73.   /**
  74.    * 注册使用中间件
  75.    * @param {*} fn
  76.    */
  77.   use(fn) {
  78.     if (typeof fn === "function") {
  79.       this.middleware.push(fn);
  80.     }
  81.   }
  83.   /**
  84.    * 中间件回调方法
  85.    */
  86.   callback() {
  87.     let that = this;
  89.     if (this.listeners("error").length === 0) {
  90.       this.on("error", this.onerror);
  91.     }
  93.     const handleRequest = (req, res) => {
  94.       let context = this.createContext(req, res);
  95.       let middleware = this.middleware;
  96.       compose(middleware)(context).catch((err) => this.onerror(err));
  97.     };
  98.     return handleRequest;
  99.   }
  101.   /**
  102.    * 异常处理监听
  103.    * @param {EndOfStreamError} err
  104.    */
  105.   onerror(err) {
  106.     console.log(err);
  107.   }
  109.   /**
  110.    * 创建通用上下文
  111.    * @param {Object} req
  112.    * @param {Object} res
  113.    */
  115.   createContext(req, res) {
  116.     let context = Object.create(this.context);
  117.     context.req = req;
  118.     context.res = res;
  119.     return context;
  120.   }
  121. }
  123. const app = new MyKoa();
  124. const PORT = 3001;
  126. app.use(async (ctx) => {
  127.   ctx.body = "<p>this is a body</p>";
  128. });
  130. app.listen(PORT, () => {
  131.   console.log(`the web server is starting at port ${PORT}`);
  132. });