koa2 总体流程原理浅析(二) 之中间件原理

zhoutk 发布于2019-08-22 16:23 / 1253人阅读

摘要：任何一层报错，都能用捕获总结是一个非常轻量级的框架，只实现了中间件处理流程和对对象的封装。其他的功能都由外部中间件提供。

koa 的中间件机制巧妙的运用了闭包和 async await 的特点，形成了一个洋葱式的流程，和 JS 的事件流 (捕获 -> target -> 冒泡) 相似

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

上述代码是 request 事件的句柄，也就是说每一个请求到来，都会执行这个总方法

onerror 为请求设置了错误处理的方法

handleResponse 是当中间件完成后给浏览器返回 response 的方法，里面是原生的 res.end(body)

onFinished 是判断请求最终有没有完成，根据不同的结果采取不同的策略

fnMiddleware(ctx) 就是执行所有中间件函数，然后返回一个 Promise 对象，不出错的话执行 handleResponse

洋葱式的中间件

值得一提的是，中间件原理的代码并没有放在 koa 中，而是多带带打了一个模块，叫做 ==koa-compose==

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

试试 next() 前面加上 await 和不加 await 的区别就明白了

2. 为何要用 Promise.resolve 返回

因为他是洋葱式的层级，如果用普通的 Boolean 返回的话，只能返回到上一层，没法全局获取，对错误的把控难以控制。Promise 任何一层报错，都能用 catch 捕获

总结

koa 是一个非常轻量级的框架，只实现了中间件处理流程和对 res、req 对象的封装。其他的功能都由外部中间件提供。代码不是很多，但是很精妙，对于代码能力的提高有不小的帮助

END

专线服务超融合服务器消息中间件原理 php消息中间件原理 tomcat插件原理流程最小二乘法拟合算法流程图

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/94307.html

koa2 总体流程原理浅析(一) 之 koa 启动服务器解析

摘要：启动流程主要的启动流程就是下面的步引入包实例化编写中间件监听服务器引入包引入包其实就是引入的一个继承于原生的类的类其中就包含了等原型方法实例化执行，将等对象封装在实例中编写中间件首先判断的类型，不是方法直接抛错是生成器函数的话用封装是函数启动流程 koa 主要的启动流程就是下面的 4 步：引入 koa 包 => 实例化 koa => 编写中间件 => 监听服务器 const koa ...

fsmStudy 2019-08-22 16:23 评论0 收藏0
koa原理浅析

摘要：应用级别顶层处理在上面中间件执行时看到，会自动帮我们捕获错误并处理，如下捕获错误在中处理我们看发现它事实上是出发监听的事件假如我们没有定义回调怎么办呢，也为我们定义了默认的错误处理函数方法做了判断全文完 koa原理浅析选取的版本为koa2 原文链接 koa的源码由四个文件组成 application.js koa的骨架 context.js ctx的原型 requ...

cnio 2019-08-22 11:17 评论0 收藏0
KOA2框架原理解析和实现

摘要：实现的四大模块上文简述了源码的大体框架结构，接下来我们来实现一个的框架，笔者认为理解和实现一个框架需要实现四个大模块，分别是封装创建类构造函数构造对象中间件机制和剥洋葱模型的实现错误捕获和错误处理下面我们就逐一分析和实现。什么是koa框架？ koa是一个基于node实现的一个新的web框架，它是由express框架的原班人马打造的。它的特点是优雅、简洁、表达力强、自由度...

tracymac7 2019-08-26 13:37 评论0 收藏0
KOA2框架原理解析和实现

摘要：实现的四大模块上文简述了源码的大体框架结构，接下来我们来实现一个的框架，笔者认为理解和实现一个框架需要实现四个大模块，分别是封装创建类构造函数构造对象中间件机制和剥洋葱模型的实现错误捕获和错误处理下面我们就逐一分析和实现。什么是koa框架？ koa是一个基于node实现的一个新的web框架，它是由express框架的原班人马打造的。它的特点是优雅、简洁、表达力强、自由度...

liangzai_cool 2019-08-02 14:29 评论0 收藏0
KOA2框架原理解析和实现

摘要：实现的四大模块上文简述了源码的大体框架结构，接下来我们来实现一个的框架，笔者认为理解和实现一个框架需要实现四个大模块，分别是封装创建类构造函数构造对象中间件机制和剥洋葱模型的实现错误捕获和错误处理下面我们就逐一分析和实现。什么是koa框架？ koa是一个基于node实现的一个新的web框架，它是由express框架的原班人马打造的。它的特点是优雅、简洁、表达力强、自由度...

suemi 2019-08-05 18:13 评论0 收藏0