Node.js 中间件设计模式：Express、Koa 与自定义中间件开发

一、中间件的本质认知

当我们谈论Node.js中间件时，脑海中浮现的应该是一条流淌着HTTP请求的河道。中间件就像是河岸边的水电站，每个电站都能对水流进行加工处理，这种模块化的设计正是现代Web框架的灵魂所在。让我们用生活中的场景来理解：

想象咖啡店的流水线制作过程：研磨咖啡豆（中间件A）→ 萃取浓缩液（中间件B）→ 添加奶泡（中间件C）。每个工序都独立运作且可灵活调整顺序，这正是中间件模式的精髓。

二、Express中间件执行原理

（技术栈：Node.js + Express 4.x）

2.1 基础中间件示例

// 简易日志中间件
const logMiddleware = (req, res, next) => {
    const start = Date.now();
    res.on('finish', () => {
        console.log(`${req.method} ${req.url} - ${Date.now()-start}ms`);
    });
    next(); // 传递控制权
};

app.use(logMiddleware);

2.2 多中间件组合示例

// 认证中间件
const authMiddleware = (req, res, next) => {
    if (!req.headers.token) {
        return res.status(401).send('请先登录');
    }
    req.user = decodeToken(req.headers.token);
    next(); // 进入下个处理环节
};

// 数据校验中间件
const validateMiddleware = (req, res, next) => {
    if (!req.body.content) {
        return res.status(400).send('内容不能为空');
    }
    next();
};

app.post('/posts', authMiddleware, validateMiddleware, (req, res) => {
    // 处理有效请求
    db.createPost(req.body);
    res.sendStatus(201);
});

重点特征分析：

• 中间件按注册顺序线性执行
• 通过next()手动传递控制流
• 每个中间件独立负责特定功能
• 异常传播需要手动处理

三、Koa中间件进化之路

（技术栈：Node.js + Koa 2.x）

3.1 洋葱模型实例演示

// 请求计时中间件
app.use(async (ctx, next) => {
    const start = Date.now();
    await next(); // 进入下游中间件
    const duration = Date.now() - start;
    ctx.set('X-Response-Time', `${duration}ms`);
});

// 响应格式化中间件
app.use(async (ctx, next) => {
    await next();
    if (ctx.status === 404) {
        ctx.body = { code: 404, message: '资源未找到' };
    }
});

app.use(async ctx => {
    ctx.body = await fetchData(); // 核心业务处理
});

3.2 异步操作最佳实践

// 数据库事务中间件
app.use(async (ctx, next) => {
    const connection = await getConnection();
    ctx.state.connection = connection;
    
    try {
        await next(); // 业务处理
        await connection.commit();
    } catch (err) {
        await connection.rollback();
        ctx.throw(500, '事务操作失败');
    } finally {
        connection.release();
    }
});

核心技术优势：

• 基于Async/Await的异步控制
• 双向处理请求/响应周期
• 上下文对象集中管理状态
• 错误处理更加符合直觉

四、打造定制化中间件

（技术栈：Node.js原生）

4.1 请求频率限制中间件

const rateLimiter = (options = { windowMs: 60000, max: 100 }) => {
    const hits = new Map();
    
    // 中间件工厂函数
    return function(req, res, next) {
        const ip = req.headers['x-forwarded-for'] || req.socket.remoteAddress;
        const record = hits.get(ip) || { count: 0, resetTime: Date.now() + options.windowMs };
        
        if (Date.now() > record.resetTime) {
            hits.delete(ip);
            return next();
        }
        
        if (record.count >= options.max) {
            return res.status(429).send('请求过于频繁');
        }
        
        record.count++;
        hits.set(ip, record);
        res.set('X-RateLimit-Limit', options.max);
        res.set('X-RateLimit-Remaining', options.max - record.count);
        next();
    };
};

// 使用示例
app.use(rateLimiter({ windowMs: 30000, max: 50 }));

4.2 动态路由代理中间件

function createProxyMiddleware(target) {
    const httpProxy = require('http-proxy').createProxyServer();
    
    return async function(ctx, next) {
        return new Promise((resolve, reject) => {
            ctx.req.on('close', () => reject(new Error('请求被中断')));
            
            httpProxy.web(ctx.req, ctx.res, { target }, err => {
                ctx.status = 500;
                ctx.body = '代理服务异常';
                reject(err);
            });
            
            resolve(next());
        });
    };
}

// Koa使用场景示例
app.use(createProxyMiddleware('http://api.example.com'));

五、多维对比与选型指南

5.1 应用场景矩阵

5.2 技术决策树

是否需要深度控制流 → 是 → 选择Koa
              ↓否
是否需要丰富插件 → 是 → 选择Express
              ↓否
是否需要特殊功能 → 是 → 开发自定义中间件
              ↓否
使用原生HTTP模块

六、实战开发警示录

1. 中间件地狱预防

// 错误示例：过多嵌套中间件
app.use((req, res, next) => {
    checkAuth(req, (err) => {
        if (err) return next(err);
        logRequest(req, () => {
            validateParams(req, () => {
                // 业务处理...
            });
        });
    });
});

// 正确姿势：使用异步分解
app.use(asyncMiddleware(async (req, res, next) => {
    await checkAuth(req);
    await logRequest(req);
    await validateParams(req);
    next();
}));

2. 异常处理黄金法则

// Express错误中间件必须包含四个参数
app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('服务异常，请稍后重试');
});

// Koa统一错误捕获
app.on('error', (err, ctx) => {
    sentry.captureException(err);
    ctx.status = err.status || 500;
});

七、面向未来的中间件演进

1. Serverless环境适配

// 适配云函数的中间件包装器
export const wrapper = (app) => {
    return async (event, context) => {
        const res = new ServerlessResponse();
        const req = new ServerlessRequest(event);
        
        app.handle(req, res);
        
        return new Promise(resolve => {
            res.on('finish', () => {
                resolve({
                    statusCode: res.statusCode,
                    headers: res.getHeaders(),
                    body: res.body
                });
            });
        });
    };
};

2. 中间件性能监测

// 性能追踪中间件
function createTraceMiddleware() {
    const stats = new Map();
    
    return {
        middleware: (ctx, next) => {
            const traceId = crypto.randomUUID();
            performance.mark(`start_${traceId}`);
            
            return next().finally(() => {
                performance.mark(`end_${traceId}`);
                const measure = performance.measure(traceId, 
                    `start_${traceId}`, 
                    `end_${traceId}`);
                
                stats.set(traceId, measure.duration);
            });
        },
        getMetrics: () => stats
    };
}