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);
  }

• onerror 为请求设置了错误处理的方法
• handleResponse 是当中间件完成后给浏览器返回 response 的方法，里面是原生的 res.end(body)
• onFinished 是判断请求最终有没有完成，根据不同的结果采取不同的策略
• fnMiddleware(ctX) 就是执行所有中间件函数，然后返回一个 Promise 对象，不出错的话执行 handleResponse

洋葱式的中间件

function (context,next) {
    // last called middleware #
    let index = -1
    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
      
      // 返回给 next()
      if (!fn) return Promise.resolve() 
      try {
      
        // 返回给 next()，最外一层返回给 fnMiddleware(ctX).then(handleResponsE)
        return Promise.resolve(fn(context,function next () { 
        
          // 返回给外一层 fn 的 await
          return dispatch(i + 1) 
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }

• 执行一次 dispatch 就是执行一个中间件，算是洋葱的一层
• 每个 dispatch 都会返回一个 Promise.resolve 给外面一层的 await（除了第一次，他返回给的是 fnMiddleware(ctX).then(handleResponsE)）
• 每个 dispatch 都有一个自己的序号，也就是参数 i (他用闭包控制住了) ，从 0 开始
• 闭包里有一个 index，是记录执行过的中间件数量。一旦有序号大于数量，说明有中间件执行了两次 await next，这是不被允许的
• 每一层用 Promise.resolve 包裹是因为 await 需要接收一个 Promise 对象

function dispatch(0){ // 第一层的序号
        return Promise.resolve(async function a0(){
            cnosole.log('0-0')
            await 111(function next0(){
                return (function dispatch(1){ // 第二层的序号
                    return Promise.resolve(async function a1(){
                        cnosole.log('1-0')
                        await 222(function next1(){
                            return (function dispatch(2){ // 第三层的序号
                                return Promise.resolve(async function a2(){
                                    cnosole.log('2-0')
                                    await 333(function next2(){
                                        return (function dispatch(3){ // i == middleware.length ，算是洋葱芯吧
                                        
                                            // fn[3] == undefined，说明中间件已经到洋葱的最里面了，开始向外返回
                                            return Promise.resolve()
                                        })()
                                    })()333
                                    console.log('2-1')
                                })
                            })()
                        })()222
                        console.log('1-1')
                    })
                })()
            })()111
            console.log('0-1')
        })
    }    

    dispatch(0).then(handleResponsE)

思考

1. 普通函数采用 dispatch 算法也能取得洋葱式的流程，为何要使用 async ?

app.use(async function (ctx,next) {
    console.log('1-1')
    await new Promise(function(resolve,reject){
        setTimeout(function () {
            console.info

            ("wait for 10 mini seconds.");
            resolve();
        },10);
    });
    console.log('1-2')
    next();
    console.log('1-3')
})

app.use(async function (ctx,next) {
    console.log('2-1')
    await new Promise(function(resolvE){
        setTimeout(function () {
            console.info

            ("wait for 10 mini seconds");
            resolve();
        },10);
    });
    console.log('2-2')
    next();
    console.log('2-3')
})

2. 为何要用 Promise.resolve 返回

总结

END