Node.js 中间件原理：从 Express 到 Koa

一、中间件到底是什么

中间件（middleware）是 Node Web 框架的核心机制：每个请求按顺序经过一系列函数，每个函数可以处理请求、决定是否放行给下一个，最后响应返回。

// Express 里最经典的中间件
app.use((req, res, next) => {
  console.log(`${req.method} ${req.url}`)   // 记录日志
  next()                                     // 放行给下一个中间件
})

二、Express：线性中间件

Express 中间件按注册顺序线性执行，next() 决定是否进入下一个：

const express = require('express')
const app = express()

// 1. 日志中间件
app.use((req, res, next) => {
  console.log('中间件 1：日志')
  next()
})

// 2. 鉴权中间件
app.use('/api', (req, res, next) => {
  const token = req.headers.authorization
  if (!token) {
    return res.status(401).json({ message: '未登录' })  // 拦截，不 next
  }
  next()
})

// 3. 路由
app.get('/api/user', (req, res) => {
  res.json({ name: '张三' })
})

// 4. 404 兜底
app.use((req, res) => {
  res.status(404).json({ message: '接口不存在' })
})

// 5. 错误处理中间件（4 个参数，必须带 err）
app.use((err, req, res, next) => {
  console.error(err)
  res.status(500).json({ message: '服务器错误' })
})

next(err) 的语义：传给 next 任何参数（除了字符串 ‘route’），Express 会跳过普通中间件，直接跳到错误处理中间件。

三、Koa：洋葱模型

Koa 的中间件可以 await，执行流程是”进进出出“的洋葱：

const Koa = require('koa')
const app = new Koa()

app.use(async (ctx, next) => {
  console.log('1. 进入 A')
  await next()                    // 等下游执行完
  console.log('4. 离开 A')        // 下游返回后再执行
})

app.use(async (ctx, next) => {
  console.log('2. 进入 B')
  await next()
  console.log('3. 离开 B')
})

// 执行顺序：1 → 2 → 3 → 4

为什么这样设计：await next() 之后的代码在”响应回来之后”执行，非常适合：

计算响应耗时
统一包装响应格式
记录响应状态

经典案例——响应耗时统计：

app.use(async (ctx, next) => {
  const start = Date.now()
  await next()
  const ms = Date.now() - start
  ctx.set('X-Response-Time', `${ms}ms`)
})

四、对比与选型

对比	Express	Koa
中间件模型	线性（next 只前进）	洋葱（可出可入）
异步支持	回调为主（新版支持 Promise）	原生 async/await
内置能力	路由、静态资源齐全	极简，路由要装 koa-router
生态	最丰富	较丰富
适用	快速上手、老项目	需要精细控制、追求现代写法

日常选型：快速开发用 Express；对请求生命周期控制要求高、想要干净异步代码用 Koa。

五、手写一个迷你中间件框架

理解了原理，自己实现一个也很简单：

// mini-framework.js
class MiniApp {
  constructor() {
    this.middlewares = []
  }

  use(fn) {
    this.middlewares.push(fn)
    return this
  }

  // 模拟处理一个请求
  handle(req, res) {
    let index = 0

    // next 递归推进中间件
    const next = (err) => {
      if (err) {
        // 跳到错误处理
        const errorHandler = this.middlewares.find((fn) => fn.length === 4)
        return errorHandler ? errorHandler(err, req, res, () => {}) : res.end('500')
      }

      const fn = this.middlewares[index++]
      if (!fn) return

      // 4 个参数的是错误处理中间件，跳过
      if (fn.length === 4) return next()

      fn(req, res, next)
    }

    next()
  }
}

// 使用
const app = new MiniApp()

app.use((req, res, next) => {
  console.log('日志：', req.url)
  next()
})

app.use((req, res, next) => {
  if (req.url === '/private' && !req.token) {
    res.statusCode = 401
    return res.end('Unauthorized')   // 不调 next，直接结束
  }
  next()
})

app.use((req, res) => {
  res.end('Hello ' + req.url)
})

app.handle({ url: '/private', token: '' }, { statusCode: 200, end: (s) => console.log('响应：', s) })