自定义中间件的开发方法

作者：陈川阅读数：23569人阅读分类： Node.js

理解中间件的基本概念

Express中间件本质上是函数，能够访问请求对象（req）、响应对象（res）和应用程序的请求-响应周期中的下一个中间件函数（next）。中间件可以执行以下操作：

执行任何代码
修改请求和响应对象
结束请求-响应周期
调用堆栈中的下一个中间件

function simpleMiddleware(req, res, next) {
  console.log('Request received at:', new Date());
  next(); // 必须调用next()才能继续执行后续中间件
}

中间件的类型

Express中间件主要分为以下几种类型：

应用级中间件：使用app.use()或app.METHOD()绑定到应用程序实例
路由器级中间件：与应用级中间件类似，但绑定到express.Router()实例
错误处理中间件：专门处理错误的中间件，接收四个参数(err, req, res, next)
内置中间件：Express自带的中间件，如express.static
第三方中间件：社区开发的中间件，如body-parser

创建自定义中间件的基本步骤

开发自定义中间件通常遵循以下步骤：

定义中间件函数，接收req, res, next参数
在函数体内实现所需功能
决定是否调用next()传递控制权
将中间件挂载到应用程序或路由

// 示例：记录请求信息的中间件
function requestLogger(req, res, next) {
  const { method, originalUrl, ip } = req;
  console.log(`[${new Date().toISOString()}] ${method} ${originalUrl} from ${ip}`);
  next();
}

// 使用中间件
app.use(requestLogger);

中间件的执行顺序

中间件的执行顺序非常重要，Express会按照中间件注册的顺序依次执行它们：

app.use(middleware1); // 最先执行
app.use(middleware2); // 其次执行
app.get('/path', middleware3, (req, res) => { // 最后执行
  res.send('Hello World');
});

错误处理中间件的开发

错误处理中间件有四个参数，必须放在其他中间件之后：

function errorHandler(err, req, res, next) {
  console.error(err.stack);
  
  // 根据错误类型返回不同响应
  if (err instanceof CustomError) {
    return res.status(400).json({ error: err.message });
  }
  
  res.status(500).send('Something broke!');
}

// 使用错误处理中间件（必须放在最后）
app.use(errorHandler);

异步中间件的处理

现代Express支持异步中间件，可以使用async/await：

async function asyncMiddleware(req, res, next) {
  try {
    const data = await fetchSomeData();
    req.data = data;
    next();
  } catch (err) {
    next(err); // 将错误传递给错误处理中间件
  }
}

// 或者更简洁的写法
const asyncMiddleware = async (req, res, next) => {
  req.user = await User.findById(req.params.id);
  next();
};

中间件的配置选项

可配置的中间件更加灵活，通常采用工厂函数模式：

function createLogger(options = {}) {
  // 默认配置
  const defaults = {
    logLevel: 'info',
    timestamp: true
  };
  
  // 合并配置
  const config = { ...defaults, ...options };
  
  // 返回中间件函数
  return function(req, res, next) {
    let message = `${req.method} ${req.url}`;
    if (config.timestamp) {
      message = `[${new Date().toISOString()}] ${message}`;
    }
    
    if (config.logLevel === 'debug') {
      console.debug(message, { headers: req.headers });
    } else {
      console.log(message);
    }
    
    next();
  };
}

// 使用可配置中间件
app.use(createLogger({ logLevel: 'debug' }));

中间件的组合使用

多个中间件可以组合成一个中间件链：

function validateAuth(req, res, next) {
  if (!req.headers.authorization) {
    return res.status(401).send('Unauthorized');
  }
  next();
}

function parseUser(req, res, next) {
  const token = req.headers.authorization.split(' ')[1];
  req.user = decodeToken(token);
  next();
}

// 组合使用
app.get('/profile', validateAuth, parseUser, (req, res) => {
  res.json(req.user.profile);
});

// 或者使用数组形式
const authMiddlewares = [validateAuth, parseUser];
app.get('/dashboard', authMiddlewares, (req, res) => {
  res.render('dashboard', { user: req.user });
});

中间件的性能优化

编写高性能中间件需要注意以下几点：

避免阻塞操作
合理使用缓存
尽早返回响应
减少不必要的处理

// 缓存中间件示例
function createCacheMiddleware(ttl = 60) {
  const cache = new Map();
  
  return function(req, res, next) {
    const key = req.originalUrl;
    
    // 检查缓存
    if (cache.has(key)) {
      const { data, expires } = cache.get(key);
      if (expires > Date.now()) {
        return res.send(data); // 直接返回缓存
      }
    }
    
    // 重写res.send以捕获响应数据
    const originalSend = res.send;
    res.send = function(body) {
      cache.set(key, {
        data: body,
        expires: Date.now() + ttl * 1000
      });
      originalSend.call(this, body);
    };
    
    next();
  };
}

中间件的测试方法

测试中间件可以使用supertest等测试库：

const request = require('supertest');
const express = require('express');

describe('Auth Middleware', () => {
  let app;
  
  beforeEach(() => {
    app = express();
    app.use(express.json());
    app.use(require('./authMiddleware'));
    app.get('/test', (req, res) => res.send('OK'));
  });
  
  it('should reject requests without token', async () => {
    const res = await request(app)
      .get('/test')
      .expect(401);
    
    expect(res.body.error).toBe('Unauthorized');
  });
  
  it('should allow requests with valid token', async () => {
    const res = await request(app)
      .get('/test')
      .set('Authorization', 'Bearer valid-token')
      .expect(200);
    
    expect(res.text).toBe('OK');
  });
});

中间件的实际应用案例

请求验证中间件：

function validateRequest(schema) {
  return function(req, res, next) {
    const { error } = schema.validate(req.body);
    if (error) {
      return res.status(400).json({
        error: error.details[0].message
      });
    }
    next();
  };
}

// 使用Joi定义schema
const Joi = require('joi');
const userSchema = Joi.object({
  username: Joi.string().alphanum().min(3).max(30).required(),
  password: Joi.string().pattern(new RegExp('^[a-zA-Z0-9]{3,30}$'))
});

// 应用中间件
app.post('/register', validateRequest(userSchema), (req, res) => {
  // 处理注册逻辑
});

响应时间中间件：

function responseTime() {
  return function(req, res, next) {
    const start = Date.now();
    
    res.on('finish', () => {
      const duration = Date.now() - start;
      res.setHeader('X-Response-Time', `${duration}ms`);
      console.log(`${req.method} ${req.url} - ${duration}ms`);
    });
    
    next();
  };
}

app.use(responseTime());

API版本控制中间件：

function apiVersion(version) {
  return function(req, res, next) {
    req.apiVersion = version;
    
    // 根据版本号加载不同的路由
    if (version === 'v1') {
      require('./routes/v1')(req, res, next);
    } else if (version === 'v2') {
      require('./routes/v2')(req, res, next);
    } else {
      next(); // 继续执行其他中间件
    }
  };
}

// 使用中间件
app.use('/api', apiVersion('v2'));

中间件的高级模式

条件中间件：

function conditionalMiddleware(condition, middleware) {
  return function(req, res, next) {
    if (condition(req)) {
      return middleware(req, res, next);
    }
    next();
  };
}

// 示例：仅在开发环境启用日志
app.use(conditionalMiddleware(
  req => process.env.NODE_ENV === 'development',
  require('morgan')('dev')
));

中间件管道：

function pipeMiddlewares(...middlewares) {
  return function(req, res, next) {
    let index = 0;
    
    function runMiddleware() {
      if (index < middlewares.length) {
        const middleware = middlewares[index++];
        middleware(req, res, runMiddleware);
      } else {
        next();
      }
    }
    
    runMiddleware();
  };
}

// 使用管道
app.use(pipeMiddlewares(
  middleware1,
  middleware2,
  middleware3
));

可终止的中间件：

function terminableMiddleware(options = {}) {
  return function(req, res, next) {
    let terminated = false;
    
    // 添加终止方法
    req.terminate = (error) => {
      terminated = true;
      next(error);
    };
    
    // 包装next方法
    const originalNext = next;
    next = function(err) {
      if (!terminated) {
        originalNext(err);
      }
    };
    
    // 执行中间件逻辑
    if (options.preCheck) {
      if (!options.preCheck(req)) {
        return req.terminate(new Error('Pre-check failed'));
      }
    }
    
    // 继续正常流程
    next();
  };
}

中间件与Express 5的新特性

Express 5引入了一些对中间件开发有用的改进：

异步错误处理：不再需要显式捕获异步错误
改进的路由系统：更灵活的路由匹配
更好的Promise支持：中间件可以返回Promise

// Express 5中的异步中间件示例
app.use(async (req, res, next) => {
  // 自动捕获异步错误
  const user = await User.findById(req.params.id);
  req.user = user;
  next();
});

// 错误处理更加简洁
app.use((err, req, res, next) => {
  // 自动处理异步错误
  res.status(500).send(err.message);
});

中间件开发的最佳实践

单一职责原则：每个中间件只做一件事
保持简洁：避免在中间件中包含过多逻辑
良好的错误处理：始终正确处理错误
性能考虑：避免阻塞操作
文档化：为中间件编写清晰的文档
可配置性：使中间件尽可能灵活
测试覆盖：为中间件编写全面的测试

// 良好实践的示例：API密钥验证中间件
function createApiKeyAuth(validKeys) {
  if (!Array.isArray(validKeys)) {
    throw new Error('validKeys must be an array');
  }
  
  return function(req, res, next) {
    const apiKey = req.get('X-API-Key');
    
    if (!apiKey) {
      return res.status(401).json({ error: 'API key missing' });
    }
    
    if (!validKeys.includes(apiKey)) {
      return res.status(403).json({ error: 'Invalid API key' });
    }
    
    next();
  };
}

// 使用示例
const API_KEYS = process.env.API_KEYS.split(',');
app.use(createApiKeyAuth(API_KEYS));

中间件与微服务架构

在微服务架构中，中间件可以用于：

服务间通信：处理服务间的请求转发
负载均衡：分配请求到不同服务实例
断路器模式：防止级联故障
服务发现：动态路由到可用服务

// 微服务网关中间件示例
function serviceProxy(serviceMap) {
  const httpProxy = require('http-proxy-middleware');
  
  return function(req, res, next) {
    const serviceName = req.path.split('/')[1];
    
    if (serviceMap[serviceName]) {
      return httpProxy({
        target: serviceMap[serviceName],
        pathRewrite: {
          [`^/${serviceName}`]: ''
        }
      })(req, res, next);
    }
    
    next();
  };
}

// 使用示例
app.use(serviceProxy({
  users: 'http://user-service:3000',
  products: 'http://product-service:3001'
}));

中间件的调试技巧

调试中间件时可以采用以下方法：

日志记录：详细记录中间件执行过程
断点调试：使用Node.js调试工具
隔离测试：单独测试中间件功能
性能分析：测量中间件执行时间

// 调试中间件示例
function debugMiddleware(label) {
  return function(req, res, next) {
    console.time(label);
    
    res.on('finish', () => {
      console.timeEnd(label);
      console.log('Request details:', {
        method: req.method,
        url: req.originalUrl,
        status: res.statusCode,
        headers: req.headers
      });
    });
    
    next();
  };
}

// 使用示例
app.use(debugMiddleware('request'));

中间件的安全考虑

开发中间件时需要注意以下安全问题：

输入验证：始终验证用户输入
敏感数据处理：谨慎处理敏感信息
依赖安全：保持依赖更新
错误信息：避免泄露敏感错误信息

// 安全中间件示例：防止敏感信息泄露
function securityHeaders() {
  return function(req, res, next) {
    res.set({
      'X-Content-Type-Options': 'nosniff',
      'X-Frame-Options': 'DENY',
      'X-XSS-Protection': '1; mode=block',
      'Strict-Transport-Security': 'max-age=63072000; includeSubDomains; preload',
      'Content-Security-Policy': "default-src 'self'"
    });
    
    // 移除可能泄露信息的头部
    res.removeHeader('X-Powered-By');
    
    next();
  };
}

// 使用示例
app.use(securityHeaders());

做个网站！

本站部分内容来自互联网,一切版权均归源网站或源作者所有。

如果侵犯了你的权益请来信告知我们删除。邮箱：cc@cccx.cn

上一篇：内置中间件与第三方中间件

下一篇：中间件的执行顺序与控制