性能优化与缓存策略

性能优化与缓存策略

Express框架作为Node.js生态中最流行的Web应用框架之一，其性能直接影响用户体验。合理的缓存策略能显著减少服务器负载，加快响应速度。从内存缓存到分布式缓存，从静态资源到动态内容，缓存机制的选择与实现需要根据具体场景权衡。

内存缓存与中间件

内存缓存是最直接的优化手段，适合中小规模应用。memory-cache这类轻量级包可以快速集成：

const cache = require('memory-cache');
const express = require('express');
const app = express();

app.get('/api/data', (req, res) => {
  const cachedData = cache.get('expensiveData');
  if (cachedData) {
    return res.json(cachedData);
  }

  // 模拟耗时操作
  const data = expensiveDatabaseQuery();
  cache.put('expensiveData', data, 60000); // 缓存1分钟
  res.json(data);
});

注意内存缓存的局限性：进程重启导致数据丢失，多实例部署时缓存不一致。对于需要持久化的场景，Redis是更可靠的选择。

Redis缓存集成

Redis作为内存数据库，支持数据持久化和集群部署。通过ioredis客户端实现：

const Redis = require('ioredis');
const redis = new Redis();
const EXPIRE_TIME = 3600; // 1小时过期

app.get('/api/products/:id', async (req, res) => {
  const { id } = req.params;
  const cacheKey = `product:${id}`;
  
  try {
    const cachedProduct = await redis.get(cacheKey);
    if (cachedProduct) {
      return res.json(JSON.parse(cachedProduct));
    }

    const product = await Product.findById(id);
    await redis.setex(cacheKey, EXPIRE_TIME, JSON.stringify(product));
    res.json(product);
  } catch (err) {
    res.status(500).send('Server error');
  }
});

实际项目中需要考虑缓存雪崩问题，可以通过随机过期时间或互斥锁解决：

const EXPIRE_BASE = 3000; // 基础过期时间5分钟
const EXPIRE_RANDOM = 1000; // 随机1分钟范围

function setWithRandomExpire(key, value) {
  const expire = EXPIRE_BASE + Math.floor(Math.random() * EXPIRE_RANDOM);
  return redis.setex(key, expire, value);
}

静态资源缓存策略

Express内置的express.static中间件支持强缓存与协商缓存：

const oneDay = 86400000;
const oneYear = 31536000000;

// 强缓存配置
app.use('/static', express.static('public', {
  maxAge: oneYear,
  immutable: true // 适合带哈希的文件名
}));

// 协商缓存配置
app.use('/assets', express.static('assets', {
  etag: true,
  lastModified: true
}));

对于Webpack构建的前端资源，推荐使用内容哈希命名文件：

// webpack.config.js
output: {
  filename: '[name].[contenthash].js',
  path: path.resolve(__dirname, 'public/static')
}

数据库查询优化

结合ORM的缓存机制能减少数据库压力。以Sequelize为例：

const { Sequelize, Op } = require('sequelize');
const sequelize = new Sequelize(/* config */);

// 查询缓存
const result = await Product.findAll({
  where: { price: { [Op.gt]: 100 } },
  cache: true,
  cacheKey: 'expensive_products'
});

// 原始SQL缓存
const [results] = await sequelize.query('SELECT * FROM products WHERE stock > 0', {
  type: Sequelize.QueryTypes.SELECT,
  cache: true
});

注意缓存失效机制，当执行写操作时需要清除相关缓存：

Product.afterUpdate(async (product) => {
  await redis.del(`product:${product.id}`);
});

边缘缓存与CDN

对于全球化应用，利用CDN边缘节点缓存静态内容：

const helmet = require('helmet');
app.use(helmet({
  hsts: { maxAge: 31536000 },
  expectCt: { enforce: true, maxAge: 86400 }
}));

// 设置Cache-Control头部
app.get('/images/:file', (req, res) => {
  res.set('Cache-Control', 'public, max-age=604800');
  res.sendFile(`/images/${req.params.file}`);
});

动态内容可通过stale-while-revalidate策略实现软缓存：

app.get('/api/news', async (req, res) => {
  res.set('Cache-Control', 'max-age=60, stale-while-revalidate=300');
  const news = await fetchLatestNews();
  res.json(news);
});

缓存失效策略设计

常见的缓存失效模式包括：

1. 定时过期：适合数据更新频率固定的场景
2. 事件驱动：数据变更时主动清除缓存
3. 版本标记：通过版本号强制客户端更新

实现版本标记示例：

// 服务端设置版本头
app.use((req, res, next) => {
  res.set('X-API-Version', 'v1.2.3');
  next();
});

// 客户端缓存校验
fetch('/api/data', {
  headers: {
    'If-None-Match': localStorage.getItem('apiVersion')
  }
}).then(response => {
  if (response.status === 304) {
    // 使用本地缓存
  }
});

性能监控与调优

集成监控工具评估缓存效果：

const promBundle = require('express-prom-bundle');
const metricsMiddleware = promBundle({
  includeMethod: true,
  includePath: true,
  customLabels: { project: 'ecommerce' }
});

app.use(metricsMiddleware);

// 自定义缓存命中率指标
const cacheHitCounter = new promClient.Counter({
  name: 'cache_hit_total',
  help: 'Total cache hits',
  labelNames: ['route']
});

通过Grafana仪表盘监控关键指标：

• 缓存命中率
• 响应时间分位数
• 数据库查询频率

高级缓存模式

对于复杂场景，可考虑以下模式：

分层缓存：

async function getProductWithLayeredCache(id) {
  // 第一层：内存缓存
  const memoryCached = localCache.get(`product_${id}`);
  if (memoryCached) return memoryCached;

  // 第二层：Redis缓存
  const redisCached = await redis.get(`product:${id}`);
  if (redisCached) {
    localCache.put(`product_${id}`, redisCached, 60000);
    return redisCached;
  }

  // 第三层：数据库
  const product = await db.query('SELECT * FROM products WHERE id = ?', [id]);
  await redis.setex(`product:${id}`, 3600, JSON.stringify(product));
  localCache.put(`product_${id}`, product, 60000);
  return product;
}

预取缓存：

// 热门商品预加载
function prefetchHotProducts() {
  db.query('SELECT id FROM products WHERE views > 1000')
    .then(ids => {
      ids.forEach(id => {
        getProductWithLayeredCache(id); // 提前填充缓存
      });
    });
}

// 每小时执行一次
setInterval(prefetchHotProducts, 3600000);