ノードの koa ミドルウェア メカニズムの問題を分析する

この記事では主にnodeのkoaミドルウェアの仕組みを詳しく紹介しており、koaと互換性の問題についても詳しく紹介していますので、興味のある方はぜひご覧ください

koa

koaは。 Express のオリジナル クラス Centaur によって構築された、より小さく、より表現力豊かで、より堅牢な Web フレームワーク。

私の目には、koaは実際にexpressよりもはるかに軽いです。koaは、対応する機能を使用する必要がある場合は、対応するミドルウェアを実装するだけです。ルーティングシステムなどより良い点は、Express がコールバックに基づいて処理されることです。コールバックがどの程度悪いかについては、自分で検索して確認できます。 koa1 は co ライブラリに基づいているため、koa1 はコールバックの代わりにジェネレーターを使用し、koa2 はノードの async/await のサポートにより async/await を使用します。 async および co ライブラリについては、以前に書いた記事 (async について) を参照してください。 Koa は、さまざまなミドルウェアのシェルフであると言えます。 koa のミドルウェア部分の実装を見てみましょう。

koa1 のミドルウェアは、主に Generator を使用して実装されています。これ:

app.use(function *(next){
  console.log(1);
  yield next;
  console.log(5);
});
app.use(function *(next){
  console.log(2);
  yield next;
  console.log(4);
});
app.use(function *(){
  console.log(3);
});

出力は 1、2、3、4、5 になります。 koa のミドルウェアの実装は主に koa-compose に依存しています:

function compose(middleware){
 return function *(next){
  if (!next) next = noop();

  var i = middleware.length;
  // 组合中间件
  while (i--) {
   next = middleware[i].call(this, next);
  }

  return yield *next;
 }
}
function *noop(){}

ソースコードは非常にシンプルです。すべてのミドルウェアを直列に接続するには、最初に noop を次のミドルウェアとして最後のミドルウェアに渡し、次にソートされた最初のミドルウェアを次のミドルウェアとしてカウントダウンに渡します。最後の次はソート後の最初のミドルウェアです。言うのはもっと複雑ですが、図を見てみましょう:

達成される効果は上の図に示されているとおりで、これは redux が次に yield に遭遇する限り、達成する必要がある目標と似ています。次のミドルウェアを実行するには、co ライブラリを使用してこのプロセスを完了するのが簡単です。これらを直列に接続して、ミドルウェアの完全な実装を単純にシミュレートしてみましょう:

koa2 ミドルウェア

async/await では、co のようなツール ライブラリに頼る必要はないようです。ここでは、ネイティブのものを使用するだけです。それで、koa にも変更が加えられています。

const middlewares = [];

const getTestMiddWare = (loggerA, loggerB) => {
  return function *(next) {
    console.log(loggerA);
    yield next;
    console.log(loggerB);
  }
};
const mid1 = getTestMiddWare(1, 4),
  mid2 = getTestMiddWare(2, 3);

const getData = new Promise((resolve, reject) => {
  setTimeout(() => resolve('数据已经取出'), 1000);
});

function *response(next) {
  // 模拟异步读取数据库数据
  const data = yield getData;
  console.log(data);
}

middlewares.push(mid1, mid2, response);
// 简单模拟co库
function co(gen) {
  const ctx = this,
    args = Array.prototype.slice.call(arguments, 1);
  return new Promise((reslove, reject) => {
    if (typeof gen === 'function') gen = gen.apply(ctx, args);
    if (!gen || typeof gen.next !== 'function') return resolve(gen);

    const baseHandle = handle => res => {
      let ret;
      try {
        ret = gen[handle](res);
      } catch(e) {
        reject(e);
      }
      next(ret);
    };
    const onFulfilled = baseHandle('next'),
      onRejected = baseHandle('throw');
      
    onFulfilled();
    function next(ret) {
      if (ret.done) return reslove(ret.value);
      // 将yield的返回值转换为Proimse
      let value = null;
      if (typeof ret.value.then !== 'function') {
        value = co(ret.value);
      } else {
        value = ret.value;
      }
      if (value) return value.then(onFulfilled, onRejected);
      return onRejected(new TypeError('yield type error'));
    }
  });
}
// 调用方式
const gen = compose(middlewares);
co(gen);

を見てみましょう。 koa-compose は Promise を使用し、koa2 のミドルウェアのパラメータも 1 から 2 に変更され、次のミドルウェアを実行するミドルウェアは、上記のコード例と同じ効果を実現するために、次のことを行う必要があります。ミドルウェアの記述方法を変更します:

function compose (middleware) {
 // 参数检验
 return function (context, next) {
  // last called middleware #
  let index = -1
  return dispatch(0)
  function dispatch (i) {
   if (i <= index) return Promise.reject(new Error(&#39;next() called multiple times&#39;))
   index = i
   let fn = middleware[i]
   // 最后一个中间件的调用
   if (i === middleware.length) fn = next
   if (!fn) return Promise.resolve()
   // 用Promise包裹中间件，方便await调用
   try {
    return Promise.resolve(fn(context, function next () {
     return dispatch(i + 1)
    }))
   } catch (err) {
    return Promise.reject(err)
   }
  }
 }
}

互換性を実現する方法

を参照してください。 私が気づいたことは、koa1 と koa2 のミドルウェアの実装にはまだ多くの違いがあるということです。 koa2 の直下で使用すると、間違いなくエラーが発生します。これら 2 つのバージョンをどのように互換性を持たせるかが問題になります。koa チームは、koa-convert という koa2 で使用できるミドルウェアを作成しました。このパッケージの使用方法を見てみましょう:

const middlewares = [];
const getTestMiddWare = (loggerA, loggerB) => async (ctx, next) => {
  console.log(loggerA);
  await next();
  console.log(loggerB);
};

const mid1 = getTestMiddWare(1, 4),
  mid2 = getTestMiddWare(2, 3);
const response = async () => {
  // 模拟异步读取数据库数据
  const data = await getData();
  console.log(data);
};
const getData = () => new Promise((resolve, reject) => {
  setTimeout(() => resolve('数据已经取出'), 1000);
});
middlewares.push(mid1, mid2);

// 调用方式
compose(middlewares)(null, response);

このパッケージを実装するためのアイデアを見てみましょう:

function *mid3(next) {
  console.log(2, 'koa1的中间件');
  yield next;
  console.log(3, 'koa1的中间件');
}
convert.compose(mid3)

個人的には、koa-convert のアイデアはカプセル化することだと感じていますPromise for Generator の層を追加し、await next() を使用して以前のミドルウェアを呼び出すことができるようにするため、Generator の実行には co ライブラリが使用され、互換性が実現されます。

以上がノードの koa ミドルウェア メカニズムの問題を分析するの詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。