Koa源码阅读-中间件原理分析

网上有很多bolg分析Koa源码阅读的项目,但是我依然想写,
因为每个人和每个人的表述语言不一样,每个人和每个人的侧重点也不一样。
写这篇希望给不用读源码的人,一眼就能很轻松的看明白。

so,开始吧

下载koa并启动

koa官方开源项目
koa文档

// 安装
npm install

koa没有例子,所以我们自己建一个( 我认为这是非常重要的一步,好多人多没写)

通过package.json

"main": "lib/application.js",

我们知道lib文件夹下的application.js就是入口,只要引入它,我们就能引入整个Koa

在Koa第一层新建index.js

输入

// 把require('koa') 换成相对路径文件
const Koa = require('./lib/application.js');
const app = new Koa();

// logger
app.use(async (ctx, next) => {
  console.log(1)
  await next();
  console.log(5)
  const rt = ctx.response.get('X-Response-Time');
  console.log(`${ctx.method} ${ctx.url} - ${rt}`);
});

// x-response-time
app.use(async (ctx, next) => {
  console.log(2)
  const start = Date.now();
  await next();
  console.log(4)
  const ms = Date.now() - start;
  ctx.set('X-Response-Time', `${ms}ms`);
});

// response
app.use(async ctx => {
    console.log(3)
    ctx.body = 'Hello World';
});

app.listen(3000);

在命令行输入

node index.js

开启项目
访问 http://localhost:3000/

终端打印 1,2,3,4,5
这就是洋葱模型

疑问一,洋葱模型怎么实现的?
疑问二,洋葱模型有什么好处?

koa很迷你

文档mini,源码也很小,只有4个js文件(
Application.js,context.js request.js,response.js)由于主线是解释中间件,就只解释中间件有关的

class Application extends Emitter {
    constructor() {
        super();
        // 定义middleware为数据类型
        this.middleware = [];
    }
    
    listen() {
        debug('listen');
        const server = http.createServer(this.callback());
        return server.listen.apply(server, arguments);
    }
    //把异步函数全部放到this.middleware数组
    use(fn) {
        this.middleware.push(fn);
        return this;
    }
    
    
  callback() {
    const fn = compose(this.middleware);
    if (!this.listeners('error').length) this.on('error', this.onerror);

    const handleRequest = (req, res) => {
      res.statusCode = 404;
      const ctx = this.createContext(req, res);
      const onerror = err => ctx.onerror(err);
      const handleResponse = () => respond(ctx);
      onFinished(res, onerror);
      fn(ctx).then(handleResponse).catch(onerror);
    };

    return handleRequest;
  }

}

执行app.listen(3000);调用listen(),listen() 调用callback()

app.use(),把异步函数全部放到this.middleware数组

callback()

// 把包含多个异步函数的数组经过compose变成一个函数
fn = compose(this.middleware)

我们打开node_modules下的koa-compose文件index.js

核心就这一个函数

const Promise = require('any-promise')

function compose (middleware) {
  // middleware必须是数组
  if (!Array.isArray(middleware)) throw new TypeError('Middleware stack must be an array!')
  // middleware数组里面必须是函数
  for (const fn of middleware) {
    if (typeof fn !== 'function') throw new TypeError('Middleware must be composed of functions!')
  }

  /**
   * @param {Object} context
   * @return {Promise}
   * @api public
   */
  return 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
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, function next () {
          return dispatch(i + 1)
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}

compose有点绕,我们慢慢分析

compose返回一个函数,这个函数返回一个立即执行函数dispatch(0)
这个是执行的,特地强调,然后dispatch(i)返回的是Promise

一般我们用 promise 是这样用

const promise = new Promise(function(resolve, reject) {
  // ... some code

  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

这样用也可以

let a = ()=>{
      console.log(1)
     return 1
}
await Promise.resolve(a());

返回的是a函数执行的结果,如果函数没有返回那么就是undifined

const fn = compose(this.middleware);
fn(ctx).then(handleResponse).catch(onerror);

fn是返回的最外层函数,当fn执行的时候传入(ctx)返回的是promise

return function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    // 从0开始递归
    function dispatch (i) {
      index = i
      // 获取middleware第i个异步函数
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, function next () {
          //等下一个Promise结果
          return dispatch(i + 1)
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }

在们的例子里一共有3个异步函数,middleware.length的长度为3,第一个和第二个传递了next,第三个没有,所以i = 2就结束了
没有走到如下这里

if (i === middleware.length) fn = next
 if (!fn) return Promise.resolve()

return dispatch(i + 1)
所以 await next(); 等得是下一个异步函数的Promise

return Promise.resolve(fn(context, function next () {
    //等下一个Promise结果
    return dispatch(i + 1)
}))

fn有两个参数 第一个是context,第二个是next 函数返回Promise,

Promise返回的是异步函数的执行结果

app.use(async (ctx, next) => {
  console.log(1)
  let c = await next();
  // 这里能获取到值111111
  console.log(c)
  console.log(5)
  const rt = ctx.response.get('X-Response-Time');
  console.log(`${ctx.method} ${ctx.url} - ${rt}`);
});


// x-response-time
app.use(async (ctx, next) => {
  console.log(2)
  const start = Date.now();
  let a = await next();
  console.log(4)
  // 这里返回数字
  return 111111
  const ms = Date.now() - start;
  ctx.set('X-Response-Time', `${ms}ms`);
});

当第三个函数执行,返回promise,结果是undified,然后执行第二个异步函数,最后执行第一个

总结:compose函数写的真妙,tj是个天才

洋葱模型(中间件)有什么意义?

不用写回调,有点一本道的感觉。
await 的好处是不用写回调,不要牵强附会。

好处就是最初给的例子:

比如一个服务器处理时间/日志的中间件的开发:
请求一开始记录时间

const start = Date.now();

请求结束回来再记录一次时间

const ms = Date.now() - start;

可以很方便的统计请求时间,解耦。

代码是写给人看的,顺便让机器执行而已。

koa的优势不在能实现更强的功能,而是可以更简单地完成功能。

相关推荐