Koa 是一款非常著名的 Node 服务端框架, 有 1.x 版本和 2.x 版本前者使用了 generator 来进行异步操作, 后者则用了最新的 async/await 方案
一开始使用这种写法的时候, 我遇到一个问题, 代码如下:
- const Koa = require('koa');
- const app = new Koa();
- const doSomething = time = >{
- return new Promise(resolve = >{
- setTimeout(() = >{
- resolve('task done!')
- },
- time)
- })
- }
- // 用来打印请求信息
- app.use((ctx, next) = >{
- console.log(`$ {
- ctx.method
- }: ::$ {
- ctx.url
- }`) next()
- }) app.use(async ctx = >{
- const result = await doSomething(3000) console.log(result);
- ctx.body = result
- }) app.listen(3000);
让我们测试一下: curl http://localhost:3000
期望结果:
(3 秒后...)task done!
然而现实却是:
(立即)
Not Found
什么鬼? 为什么没有按照预期执行? 这就需要我们来理解下 Koa 中中间件是如何串联起来的了翻一下源码, 将 middlewares 串联起来的代码如下:
- function compose(middleware) {
- return function(context, next) {
- // 这个 index 用来计数, 防止 next 被多次调用
- let index = -1
- // 执行入口
- return dispatch(0) function dispatch(i) {
- // 如果 next 被多次调用, 报异常
- if (i <= index) return Promise.reject(new Error('next() called multiple times')) index = i
- // 取出第一个 middleware
- let fn = middleware[i]
- // 将最初传入的 next 作为最后一个函数执行
- if (i === middleware.length) fn = next
- if (!fn) return Promise.resolve() try {
- /**
- 这里就是关键了, Promise.resolve 是什么意思呢?
- Promise.resolve 方法有下面三种形式:
- Promise.resolve(value);
- Promise.resolve(promise);
- Promise.resolve(theanable);
- 这三种形式都会产生一个新的 Promise 其中:
- 第一种形式提供了自定义 Promise 的值的能力, 它与 Promise.reject(reason) 对应两者的不同, 在于得到的 Promise 的状态不同
- 第二种形式, 提供了创建一个 Promise 的副本的能力
- 第三种形式, 是将一个类似 Promise 的对象转换成一个真正的 Promise 对象它的一个重要作用是将一个其他实现的 Promise 对象封装成一个当前实现的 Promise 对象例如你正在用 bluebird, 但是现在有一个 Q 的 Promise, 那么你可以通过此方法把 Q 的 Promise 变成一个 bluebird 的 Promise 第二种形式可以归在第三种里面
- **/
- return Promise.resolve(fn(context,
- function next() {
- // 执行下一个 middleware, 返回结果也是一个 Promise
- return dispatch(i + 1)
- }))
- } catch(err) {
- return Promise.reject(err)
- }
- }
- }
- }
有了以上基础, 我们再来看一下之前的问题, 为什么 response 没有等到第二个 middleware 执行完成就立即返回了呢?
因为第一个 middleware 并不是一个异步函数啊
由于每次 next 方法的执行, 实际上都是返回了一个 Promise 对象, 所以如果我们在某个 middleware 中执行了异步操作, 要想等待其完成, 就要在执行这个 middleware 之前添加 await
那我们来改写一下之前的代码
- app.use(async (ctx, next) => {
- console.log(`${ctx.method}:::${ctx.url}`)
- await next()
- })
- app.use(async ctx => {
- const result = await doSomething(3000)
- console.log(result);
- ctx.body = result
- })
好了, 没有问题, 一切如期望执行: clap:
错误处理
借助了 Promise 强大的功力, 配合 async/await 语法, 我们只需要把 try/catch 的操作写在最外层的 middleware 中, 就可以捕获到之后所有中间件的异常!
- app.use(async (ctx, next) => {
- try{
- await next()
- }catch(err){
- console.log(err)
- }
- })
- app.use(async (ctx)=>{
- throw new Error('something wrong!')
- ctx.body = 'Hello'
- })
基于中间件链的完全控制, 并且基于 Promise 的事实使得一切都变得容易操作起来不再是到处的 if (err) return next(err) 而只有 promise
来源: http://www.jb51.net/article/134442.htm