1. 请讲一下 koa 的中间件思想，以及洋葱模型

什么是 AOP？

所谓的洋葱模型其实是 AOP （面向切面编程）的一种应用。

举个例子，假如我想把一个苹果（源数据）处理成果盘（最终数据）我该怎么做？
① 苹果（源数据） ——>
② 洗苹果 ——>
③ 切苹果 ——>
④ 放入盘子 ——>
⑤ 果盘（最终数据）

如果我想升级一下果盘，打算在切苹果之前先削皮，放入盘子后摆成五角星形状那么我的步骤应该如下：
① 苹果（源数据） ——>
② 洗苹果 ——>
③ 削皮 ——>
④ 切苹果 ——>
⑤ 放入盘子 ——>
⑥ 摆成五角星形状 ——>
⑦ 果盘（最终数据）

上面每个步骤都可以看成相应的方法，步骤 ③ 和 ⑥ 加入与否都不影响我制作出果盘这个结果，可以看出这样是非常灵活的

上面的这个例子就是 AOP，中文含义为面向切面编程，他是函数式编程的一种衍生范式。

什么是洋葱模型？

const Koa = require('koa');
const app = new Koa();
// 中间件1
app.use((ctx, next) => {
    console.log(1);
    next();
    console.log(2);
});
// 中间件 2 
app.use((ctx, next) => {
    console.log(3);
    next();
    console.log(4);
});
app.listen(8000, '0.0.0.0', () => {
    console.log(`Server is starting`);
});
// 1
// 3
// 4
// 2

如上述代码，我们依次进行拆解：

use 方法

use 方法就是做了一件事，维护得到 middleware 中间件数组

  use(fn) {
    // ...
    // 维护中间件数组——middleware
    this.middleware.push(fn);
    return this;
  }

listen 方法 和 callback 方法

执行 app.listen 方法的时候，其实是 Node.js 原生 http 模块 createServer 方法创建了一个服务，其回调为 callback 方法。callback 方法中就有我们今天的重点 compose 函数，它的返回是一个 Promise 函数。

  listen(...args) {
    debug('listen');
    // node http 创建一个服务
    const server = http.createServer(this.callback());
    return server.listen(...args);
  }
  callback() {
    // 返回值是一个函数
    const fn = compose(this.middleware);
    const handleRequest = (req, res) => {
      // 创建 ctx 上下文环境
      const ctx = this.createContext(req, res);
      return this.handleRequest(ctx, fn);
    };
    return handleRequest;
  }

handleRequest 中会执行 compose 函数中返回的 Promise 函数并返回结果。

handleRequest(ctx, fnMiddleware) {
    const res = ctx.res;
    res.statusCode = 404;
    const onerror = err => ctx.onerror(err);
    const handleResponse = () => respond(ctx);
    onFinished(res, onerror);
    // 执行 compose 中返回的函数，将结果返回
    return fnMiddleware(ctx).then(handleResponse).catch(onerror);
  }

koa-compose

compose 函数引用的是 koa-compose 这个库。其实现如下所示：

function compose (middleware) {
  // ...
  return function (context, next) {
    // last called middleware #
    let index = -1
    // 一开始的时候传入为 0，后续会递增
    return dispatch(0)
    function dispatch (i) {
      // 假如没有递增，则说明执行了多次
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      // 拿到当前的中间件
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      // 当 fn 为空的时候，就会开始执行 next() 后面部分的代码
      if (!fn) return Promise.resolve()
      try {
        // 执行中间件，留意这两个参数，都是中间件的传参，第一个是上下文，第二个是 next 函数
        // 也就是说执行 next 的时候也就是调用 dispatch 函数的时候
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}

代码很简单，我们来看看具体的执行流程是怎样的：
当我们执行第一次的时候，调用的是 dispatch(0)，这个时候 i 为 0，fn 为第一个中间件函数。并执行中间件，留意这两个参数，都是中间件的传参，第一个是上下文，第二个是 next 函数。也就是说中间件执行 next 的时候也就是调用 dispatch 函数的时候，这就是为什么执行 next 逻辑的时候就会执行下一个中间件的原因：

return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));

当第二、第三次执行 dispatch 的时候，跟第一次一样，分别开始执行第二、第三个中间件，执行 next() 的时候开始执行下一个中间件。
当执行到第三个中间件的时候，执行到 next() 的时候，dispatch 函数传入的参数是 3，fn 为 undefined。这个时候就会执行

if (!fn) return Promise.resolve()

这个时候就会执行第三个中间件 next() 之后的代码，然后是第二个、第一个，从而形成了洋葱模型。