洋葱模型是一种中间件流程控制方式。
洋葱模型
这是 koa.js 的示例代码：
const Koa = require('koa');
const app = new Koa();
app.use(async (ctx, next) => {
console.log('中间件 1 进入');
await next();
console.log('中间件 1 退出');
});
app.use(async (ctx, next) => {
console.log('中间件 2 进入');
await next();
console.log('中间件 2 退出');
});
app.use(async (ctx, next) => {
console.log('中间件 3');
});
app.listen(3000);
任意一个请求到来将输出如下的执行结果：
中间件 1 进入
中间件 2 进入
中间件 3
中间件 2 退出
中间件 1 退出
koa 在内部维护了一个中间件数组：
this.middleware = [];
调用 use 就是在给数组新增一项：
use(fn) {
this.middleware.push(fn);
return this;
}
如何让中间件数组以洋葱模型调用呢？
使用递归实现是很简单的
const m1 = (ctx, next) => {
ctx.req.user = null;
console.log('中间件1 进入', ctx.req);
next()
console.log('中间件1 退出', ctx.req);
}
const m2 = (ctx, next) => {
ctx.req.user = { id: 1 };
console.log('中间件2 进入');
next()
console.log('中间件2 退出');
}
const m3 = (ctx, next) => {
console.log('中间件3');
}
const middlewares = [m1, m2, m3];
const context = { req: {}, res: {} };
function dispatch(i) {
if (i === middlewares.length) return;
return middlewares[i](context, () => dispatch(i + 1));
}
dispatch(0);
输出结果如下：
中间件1 进入 { user: null }
中间件2 进入
中间件3
中间件2 退出
中间件1 退出 { user: { id: 1 } }
koa 的中间件都是异步函数，它做了对异步函数的相关处理：
let index = -1
function dispatch (i) {
index = i
let fn = middleware[i]
if (i === middleware.length) fn = next
if (!fn) return Promise.resolve()
try {
return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
} catch (err) {
return Promise.reject(err)
}
}
尾递归
递归函数会保留父级作用域的调用栈，如果层级很深它就会导致堆栈溢出。而尾递归则可以进行优化，在 express.js 中就是使用的尾递归实现中间件流程控制的。
const m1 = (req, res, next) => {
req.user = null;
console.log('中间件1 进入', req);
next();
console.log('中间件1 退出', req);
}
const m2 = (req, res, next) => {
req.user = { id: 1 };
console.log('中间件2 进入');
next();
console.log('中间件2 退出');
}
const m3 = (req, res, next) => {
console.log('中间件3');
}
const middlewares = [m1, m2, m3];
const req = {};
const res = {};
let idx = 0;
function next(err) {
if (idx >= middlewares.length) return;
let m;
while (idx < middlewares.length) {
m = middlewares[idx++];
m(req, res, next);
}
}
next();
输出结果如下：
中间件1 进入 { user: null }
中间件2 进入
中间件3
中间件2 退出
中间件1 退出 { user: { id: 1 } }
尾递归可以被优化成循环，这样每次执行完调用栈就会被释放，也就不会导致堆栈溢出了。
尽管尾调用优化是ECMAScript 2015规范的一部分，但是大多数JavaScript解释器都不支持它。
