大型项目的性能优化

性能瓶颈分析与定位

大型Express项目性能优化的第一步是准确识别瓶颈。常见的性能问题通常集中在数据库查询、中间件链、静态资源处理和响应时间等方面。使用Node.js内置的性能分析工具可以快速定位问题：

const express = require('express');
const app = express();
const inspector = require('inspector');
const session = new inspector.Session();

// 启动CPU性能分析
session.connect();
session.post('Profiler.enable', () => {
  session.post('Profiler.start', () => {
    // 业务代码执行区域
    app.get('/heavy-route', (req, res) => {
      // 模拟CPU密集型操作
      for(let i = 0; i < 1e7; i++) Math.random();
      res.send('Completed');
    });
  });
});

结合Chrome DevTools的Performance面板，可以生成火焰图直观展示函数调用堆栈和时间消耗。对于I/O密集型操作，使用Async Hooks跟踪异步操作：

const async_hooks = require('async_hooks');
const fs = require('fs');

const hook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    fs.writeSync(1, `Init ${type} asyncId: ${asyncId}\n`);
  }
});
hook.enable();

中间件优化策略

Express中间件的执行顺序直接影响性能。避免在全局中间件中进行不必要的计算，采用按需加载策略：

// 反模式：所有请求都执行验证
app.use((req, res, next) => {
  verifyToken(req.headers.authorization); // 同步验证
  next();
});

// 优化方案：路由级中间件
const authMiddleware = async (req, res, next) => {
  try {
    req.user = await verifyTokenAsync(req.headers.authorization);
    next();
  } catch(err) {
    next(err);
  }
};

app.get('/protected', authMiddleware, (req, res) => {
  res.json({ data: '敏感数据' });
});

使用express-basic-auth替代自定义认证中间件时，注意启用缓存：

const basicAuth = require('express-basic-auth');
const authCache = new Map();

app.use(basicAuth({
  authorizer: (username, password) => {
    const cacheKey = `${username}:${password}`;
    if(authCache.has(cacheKey)) return authCache.get(cacheKey);
    
    const result = customAuthCheck(username, password);
    authCache.set(cacheKey, result);
    return result;
  },
  authorizeAsync: true
}));

数据库查询优化

数据库通常是性能瓶颈的核心。针对MongoDB的优化示例：

// 低效查询
app.get('/products', async (req, res) => {
  const products = await Product.find({})
    .select('name price') // 只获取必要字段
    .lean(); // 返回纯JS对象而非Mongoose文档
  res.json(products);
});

// 优化版本
app.get('/products/optimized', async (req, res) => {
  const { page = 1, limit = 100 } = req.query;
  const skip = (page - 1) * limit;
  
  const [products, count] = await Promise.all([
    Product.find({})
      .select('name price')
      .skip(skip)
      .limit(Number(limit))
      .lean(),
    Product.countDocuments()
  ]);

  res.set('X-Total-Count', count);
  res.json(products);
});

对于关系型数据库，使用连接池并优化事务：

const { Pool } = require('pg');
const pool = new Pool({
  max: 20, // 最大连接数
  idleTimeoutMillis: 30000,
  connectionTimeoutMillis: 2000
});

app.get('/user-orders', async (req, res) => {
  const client = await pool.connect();
  try {
    await client.query('BEGIN');
    const user = await client.query(
      'SELECT * FROM users WHERE id = $1', 
      [req.userId]
    );
    const orders = await client.query(
      `SELECT * FROM orders 
       WHERE user_id = $1
       ORDER BY created_at DESC
       LIMIT 10`,
      [req.userId]
    );
    await client.query('COMMIT');
    res.json({ user: user.rows[0], orders: orders.rows });
  } catch (err) {
    await client.query('ROLLBACK');
    throw err;
  } finally {
    client.release();
  }
});

缓存机制实施

多级缓存策略能显著提升性能：

const redis = require('redis');
const { promisify } = require('util');
const client = redis.createClient();
const getAsync = promisify(client.get).bind(client);
const setexAsync = promisify(client.setex).bind(client);

// 内存缓存层
const memoryCache = new Map();

app.get('/cached-data', async (req, res) => {
  const cacheKey = `data_${req.query.key}`;
  
  // 1. 检查内存缓存
  if(memoryCache.has(cacheKey)) {
    return res.json(memoryCache.get(cacheKey));
  }
  
  // 2. 检查Redis缓存
  const cached = await getAsync(cacheKey);
  if(cached) {
    memoryCache.set(cacheKey, JSON.parse(cached));
    return res.json(JSON.parse(cached));
  }
  
  // 3. 数据库查询
  const freshData = await fetchFromDatabase(req.query.key);
  
  // 设置缓存
  memoryCache.set(cacheKey, freshData);
  await setexAsync(cacheKey, 3600, JSON.stringify(freshData));
  
  res.json(freshData);
});

对于内容不变的静态资源，设置强缓存：

app.use('/static', express.static('public', {
  maxAge: '1y',
  immutable: true,
  setHeaders: (res, path) => {
    if (path.endsWith('.js')) {
      res.set('Content-Encoding', 'gzip');
    }
  }
}));

集群与进程管理

利用Node.js集群模块充分利用多核CPU：

const cluster = require('cluster');
const numCPUs = require('os').cpus().length;

if (cluster.isMaster) {
  // 主进程
  for (let i = 0; i < numCPUs; i++) {
    cluster.fork();
  }
  
  cluster.on('exit', (worker) => {
    console.log(`Worker ${worker.process.pid} died`);
    cluster.fork();
  });
} else {
  // 工作进程
  const app = require('./app');
  app.listen(3000, () => {
    console.log(`Worker ${process.pid} started`);
  });
}

使用PM2进行高级进程管理：

# 启动集群
pm2 start app.js -i max --name "api-server"

# 零停机重启
pm2 reload api-server

# 监控
pm2 monit

请求处理优化

流式处理大文件避免内存溢出：

const fs = require('fs');
const zlib = require('zlib');

app.get('/large-file', (req, res) => {
  const fileStream = fs.createReadStream('./large-data.json');
  const gzip = zlib.createGzip();
  
  res.set('Content-Type', 'application/json');
  res.set('Content-Encoding', 'gzip');
  
  fileStream
    .pipe(gzip)
    .pipe(res)
    .on('error', (err) => {
      console.error('Stream error:', err);
      res.status(500).end();
    });
});

使用ETag实现条件请求：

const crypto = require('crypto');

app.get('/dynamic-content', async (req, res) => {
  const content = await generateDynamicContent();
  const etag = crypto.createHash('md5').update(content).digest('hex');
  
  if (req.headers['if-none-match'] === etag) {
    return res.status(304).end();
  }
  
  res.set('ETag', etag);
  res.send(content);
});

前端资源交付优化

实现智能资源加载策略：

const accepts = require('accepts');

app.get('/optimized-assets', (req, res) => {
  const accept = accepts(req);
  
  // 根据客户端支持的类型返回不同资源
  switch(accept.type(['image/webp', 'image/jpeg'])) {
    case 'image/webp':
      return res.sendFile('/assets/image.webp');
    default:
      return res.sendFile('/assets/image.jpg');
  }
});

使用HTTP/2服务器推送：

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

app.get('/', (req, res) => {
  const stream = res.push('/critical.css', {
    status: 200,
    method: 'GET',
    request: { accept: '*/*' },
    response: { 'content-type': 'text/css' }
  });
  
  stream.on('error', () => {});
  stream.end('body { font-family: sans-serif; }');
  
  res.send('<link rel="stylesheet" href="/critical.css">');
});

spdy.createServer(options, app).listen(443);

监控与持续优化

实现自定义性能指标收集：

const prometheus = require('prom-client');
const collectDefaultMetrics = prometheus.collectDefaultMetrics;
collectDefaultMetrics({ timeout: 5000 });

app.get('/metrics', async (req, res) => {
  res.set('Content-Type', prometheus.register.contentType);
  res.end(await prometheus.register.metrics());
});

// 自定义指标
const httpRequestDuration = new prometheus.Histogram({
  name: 'http_request_duration_seconds',
  help: 'Duration of HTTP requests in seconds',
  labelNames: ['method', 'route', 'code'],
  buckets: [0.1, 0.3, 0.5, 0.7, 1, 3, 5, 7, 10]
});

// 中间件记录指标
app.use((req, res, next) => {
  const end = httpRequestDuration.startTimer();
  res.on('finish', () => {
    end({ 
      method: req.method,
      route: req.route.path,
      code: res.statusCode
    });
  });
  next();
});

分布式追踪实现：

const { NodeTracerProvider } = require('@opentelemetry/node');
const { SimpleSpanProcessor } = require('@opentelemetry/tracing');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');

const provider = new NodeTracerProvider();
provider.register();

const exporter = new JaegerExporter({
  serviceName: 'express-app',
  host: 'jaeger-agent'
});

provider.addSpanProcessor(new SimpleSpanProcessor(exporter));

// 在路由中使用
app.get('/traced', async (req, res) => {
  const tracer = require('@opentelemetry/api').trace.getTracer('express-tracer');
  const span = tracer.startSpan('custom-operation');
  
  try {
    // 业务逻辑
    await performOperation();
    span.setStatus({ code: 0 }); // OK
  } catch (err) {
    span.setStatus({ code: 2, message: err.message }); // Error
    span.recordException(err);
    throw err;
  } finally {
    span.end();
  }
  
  res.send('Traced operation completed');
});