node中koa中間件機(jī)制的原理是什么

今天就跟大家聊聊有關(guān)node中koa中間件機(jī)制的原理是什么，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結(jié)了以下內(nèi)容，希望大家根據(jù)這篇文章可以有所收獲。

koa

koa是由express原班人馬打造的一個(gè)更小、更富有表現(xiàn)力、更健壯的web框架。

在我眼中，koa的確是比express輕量的多，koa給我的感覺更像是一個(gè)中間件框架，koa只是一個(gè)基礎(chǔ)的架子，需要用到的相應(yīng)的功能時(shí)，用相應(yīng)的中間件來實(shí)現(xiàn)就好，諸如路由系統(tǒng)等。一個(gè)更好的點(diǎn)在于，express是基于回調(diào)來處理，至于回調(diào)到底有多么的不好，大家可以自行搜索來看。koa1基于的co庫(kù)，所以koa1利用Generator來代替回調(diào)，而koa2由于node對(duì)async/await的支持，所以koa2利用的是async/await。關(guān)于async以及co庫(kù)等，大家可以參考我之前寫過的一篇文章（理解async）。koa可以說是一個(gè)各種中間件的架子，下面就來看一下koa對(duì)于中間件部分的實(shí)現(xiàn)：

koa1的中間件

koa1主要利用的是Generator來實(shí)現(xiàn)，一般來說，koa1的一個(gè)中間件大概是長(zhǎng)這個(gè)樣子的：

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

這樣的輸出會(huì)是1, 2, 3, 4, 5，koa的中間件的實(shí)現(xiàn)主要依靠的是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(){}

源碼非常的簡(jiǎn)單，實(shí)現(xiàn)的功能就是將所有的中間件串聯(lián)起來，首先給倒數(shù)第一個(gè)中間件傳入一個(gè)noop作為其next，再將這個(gè)整理后的倒數(shù)第一個(gè)中間作為next傳入倒數(shù)第二個(gè)中間件，最終得到的next就是整理后的第一個(gè)中間件。說起來比較復(fù)雜，畫圖來看：

實(shí)現(xiàn)的效果如同上圖，與redux需要實(shí)現(xiàn)的目標(biāo)類似，只要遇到了yield next就去執(zhí)行下一個(gè)中間件，利用co庫(kù)很容易將這個(gè)流程串聯(lián)起來，下面來簡(jiǎn)單模擬下，中間件完整的實(shí)現(xiàn)：

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('數(shù)據(jù)已經(jīng)取出'), 1000);
});

function *response(next) {
  // 模擬異步讀取數(shù)據(jù)庫(kù)數(shù)據(jù)
  const data = yield getData;
  console.log(data);
}

middlewares.push(mid1, mid2, response);
// 簡(jiǎn)單模擬co庫(kù)
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的返回值轉(zhuǎn)換為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'));
    }
  });
}
// 調(diào)用方式
const gen = compose(middlewares);
co(gen);

koa2的中間件

隨著node對(duì)于async/await的支持，貌似不需要再借助于co這種工具庫(kù)了，直接利用原生的就好，于是koa也做出了改變，來看目前的koa-compose：

function compose (middleware) {
 // 參數(shù)檢驗(yàn)
 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]
   // 最后一個(gè)中間件的調(diào)用
   if (i === middleware.length) fn = next
   if (!fn) return Promise.resolve()
   // 用Promise包裹中間件，方便await調(diào)用
   try {
    return Promise.resolve(fn(context, function next () {
     return dispatch(i + 1)
    }))
   } catch (err) {
    return Promise.reject(err)
   }
  }
 }
}

koa-compose利用了Promise，koa2的中間件的參數(shù)也有一個(gè)變?yōu)榱藘蓚€(gè)，而且執(zhí)行下一個(gè)的中間件利用的是await next()，要達(dá)到與上面的示例代碼的相同效果，需要更改中間件的寫法：

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 () => {
  // 模擬異步讀取數(shù)據(jù)庫(kù)數(shù)據(jù)
  const data = await getData();
  console.log(data);
};
const getData = () => new Promise((resolve, reject) => {
  setTimeout(() => resolve('數(shù)據(jù)已經(jīng)取出'), 1000);
});
middlewares.push(mid1, mid2);

// 調(diào)用方式
compose(middlewares)(null, response);

如何做到兼容

可以看到的是，koa1與koa2對(duì)于中間件的實(shí)現(xiàn)還是有著很多的不同的，將koa1的中間件直接拿到koa2下面來使用肯定是會(huì)出現(xiàn)錯(cuò)誤的，如何兼容這兩個(gè)版本也成了一個(gè)問題，koa團(tuán)隊(duì)寫了一個(gè)包來是koa1的中間件可以用于koa2中，叫做koa-convert，先來看看這個(gè)包怎么使用：

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

來看下這個(gè)包實(shí)現(xiàn)的思路：

// 將參數(shù)轉(zhuǎn)為數(shù)組，對(duì)每一個(gè)koa1的中間件執(zhí)行convert操作
convert.compose = function (arr) {
 if (!Array.isArray(arr)) {
  arr = Array.from(arguments)
 }
 return compose(arr.map(convert))
}
// 關(guān)鍵在于convert的實(shí)現(xiàn)
const convert = mw => (ctx, next) => {
  // 借助co庫(kù)，返回一個(gè)Promise，同時(shí)執(zhí)行yield
  return co.call(ctx, mw.call(ctx, createGenerator(next)));
};

function * createGenerator (next) {
 /*
   next為koa-compomse中：
   function next () {
     return dispatch(i + 1)
   }
 */
 return yield next()
 // 執(zhí)行完koa1的中間件，又回到了利用await執(zhí)行koa2中間件的正軌
}

個(gè)人感覺koa-convert的思路就是對(duì)Generator封裝一層Promise，使上一個(gè)中間件可以利用await next()的方式調(diào)用，對(duì)于Generator的執(zhí)行，利用co庫(kù)，從而達(dá)到了兼容的目的。

看完上述內(nèi)容，你們對(duì)node中koa中間件機(jī)制的原理是什么有進(jìn)一步的了解嗎？如果還想了解更多知識(shí)或者相關(guān)內(nèi)容，請(qǐng)關(guān)注億速云行業(yè)資訊頻道，感謝大家的支持。