同步与异步中间件的区别

同步与异步中间件的概念

中间件是Koa2框架的核心机制，允许在请求和响应之间执行一系列操作。同步中间件按照代码顺序依次执行，而异步中间件则可能涉及非阻塞操作，需要特殊处理。理解这两种中间件的差异对构建高效应用至关重要。

同步中间件的特点

同步中间件是最简单的形式，每个中间件函数按顺序执行，直到遇到next()调用。Koa2会暂停当前中间件，执行后续中间件，最后再回到当前中间件继续执行。

app.use(async (ctx, next) => {
  console.log('中间件1开始');
  await next();
  console.log('中间件1结束');
});

app.use(async (ctx, next) => {
  console.log('中间件2开始');
  ctx.body = 'Hello World';
  console.log('中间件2结束');
});

输出顺序将是：

中间件1开始
中间件2开始
中间件2结束
中间件1结束

异步中间件的处理

当中间件包含异步操作时，必须使用async/await或返回Promise。Koa2的洋葱模型要求正确处理异步流程，否则可能导致中间件执行顺序混乱。

app.use(async (ctx, next) => {
  const start = Date.now();
  await next();
  const ms = Date.now() - start;
  console.log(`请求耗时: ${ms}ms`);
});

app.use(async (ctx) => {
  await new Promise(resolve => setTimeout(resolve, 1000));
  ctx.body = '延迟响应';
});

错误处理差异

同步中间件的错误可以直接用try-catch捕获，而异步中间件需要特殊处理：

// 同步错误
app.use((ctx, next) => {
  try {
    throw new Error('同步错误');
  } catch (err) {
    ctx.status = 500;
    ctx.body = err.message;
  }
});

// 异步错误
app.use(async (ctx, next) => {
  try {
    await someAsyncOperation();
  } catch (err) {
    ctx.status = 500;
    ctx.body = '异步操作失败';
  }
});

性能影响

同步中间件会阻塞事件循环，而异步中间件能更好地利用Node.js的非阻塞特性。考虑这个文件读取例子：

// 同步版本（不推荐）
app.use((ctx) => {
  const data = fs.readFileSync('largefile.txt');
  ctx.body = data;
});

// 异步版本（推荐）
app.use(async (ctx) => {
  const data = await fs.promises.readFile('largefile.txt');
  ctx.body = data;
});

组合使用场景

实际应用中常混合使用两种中间件。例如身份验证中间件可能是同步的，而数据库操作中间件则是异步的：

app.use((ctx, next) => {
  if (!ctx.headers.authorization) {
    ctx.throw(401, '未授权');
  }
  return next();
});

app.use(async (ctx) => {
  const user = await User.findOne({ token: ctx.headers.authorization });
  ctx.body = user;
});

中间件执行顺序的陷阱

异步操作可能导致意想不到的执行顺序。下面示例展示了常见问题：

app.use(async (ctx, next) => {
  console.log('A开始');
  await next();
  console.log('A结束');
});

app.use(async (ctx, next) => {
  console.log('B开始');
  setTimeout(() => {
    console.log('定时器回调');
  }, 0);
  await next();
  console.log('B结束');
});

app.use((ctx) => {
  console.log('C');
  ctx.body = '完成';
});

输出可能是：

A开始
B开始
C
B结束
A结束
定时器回调

最佳实践建议

1. 尽量使用async函数声明中间件
2. 所有异步操作都应await或返回Promise
3. 避免在中间件中使用同步IO操作
4. 复杂的异步流程考虑使用koa-compose
5. 错误处理应放在最外层中间件

// 使用koa-compose组合中间件
const compose = require('koa-compose');

const middleware1 = async (ctx, next) => {
  // ...
  await next();
};

const middleware2 = async (ctx, next) => {
  // ...
  await next();
};

app.use(compose([middleware1, middleware2]));