大型项目的性能优化

大型项目性能优化是提升用户体验的关键环节，尤其在Express框架中，合理的优化策略能显著降低服务器负载、缩短响应时间。从代码层面到架构设计，性能优化需要系统性思考，结合具体场景选择合适方案。

代码级优化

减少同步操作

Express默认启用异步I/O处理，但开发中仍可能意外引入同步阻塞。例如文件读取时：

// 错误示例：同步读取
const data = fs.readFileSync('large-file.json')

// 正确做法：异步读取
fs.readFile('large-file.json', (err, data) => {
  if (err) throw err
  app.use('/data', (req, res) => res.send(data))
})

路由懒加载

对于大型路由系统，采用动态导入降低启动时内存消耗：

// 动态路由加载示例
app.get('/admin', async (req, res) => {
  const adminRoutes = await import('./routes/admin.js')
  adminRoutes.handler(req, res)
})

中间件优化

审查中间件执行顺序，移除不必要的全局中间件：

// 优化前：所有请求都经过验证
app.use(verifyToken)

// 优化后：仅API路由需要验证
app.use('/api', verifyToken)

数据库交互优化

批量查询替代循环查询

典型N+1查询问题的解决方案：

// 低效做法
const users = await User.find()
users.forEach(async user => {
  const posts = await Post.find({ author: user.id }) // 每次循环都查询数据库
})

// 高效方案
const users = await User.find().populate('posts') // 单次查询完成关联数据获取

索引优化

为高频查询字段添加索引：

// Mongoose示例
const productSchema = new Schema({
  sku: { type: String, index: true }, // 单独索引
  category: { type: String, index: true }
})

// 复合索引
productSchema.index({ category: 1, price: -1 })

缓存策略实施

多级缓存架构

构建内存+Redis的二级缓存：

const memoryCache = new Map()

async function getProduct(id) {
  // 第一层：内存缓存
  if (memoryCache.has(id)) return memoryCache.get(id)
  
  // 第二层：Redis缓存
  const redisData = await redis.get(`product:${id}`)
  if (redisData) {
    memoryCache.set(id, redisData)
    return redisData
  }

  // 最终回源
  const dbData = await Product.findById(id)
  redis.set(`product:${id}`, dbData, 'EX', 3600)
  return dbData
}

缓存击穿防护

使用互斥锁防止缓存失效时大量请求穿透：

async function getWithMutex(key, fetchFn, ttl = 60) {
  const value = await redis.get(key)
  if (value) return JSON.parse(value)

  const lockKey = `lock:${key}`
  const locked = await redis.set(lockKey, '1', 'NX', 'EX', 5)
  if (!locked) {
    await new Promise(resolve => setTimeout(resolve, 100))
    return getWithMutex(key, fetchFn, ttl)
  }

  try {
    const data = await fetchFn()
    await redis.set(key, JSON.stringify(data), 'EX', ttl)
    return data
  } finally {
    await redis.del(lockKey)
  }
}

并发处理优化

连接池配置

数据库连接池的合理设置：

// MySQL连接池配置示例
const pool = mysql.createPool({
  connectionLimit: 50, // 根据服务器CPU核心数调整
  queueLimit: 1000,    // 等待队列长度
  acquireTimeout: 3000 // 获取连接超时
})

集群模式部署

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

const cluster = require('cluster')
const os = require('os')

if (cluster.isMaster) {
  const cpuCount = os.cpus().length
  for (let i = 0; i < cpuCount; i++) {
    cluster.fork()
  }
} else {
  const app = require('./app')
  app.listen(3000)
}

前端资源优化

静态资源处理

Express静态文件服务的最佳实践：

// 生产环境配置
app.use(express.static('public', {
  maxAge: '365d',      // 长期缓存
  immutable: true,     // 不可变资源
  setHeaders: (res, path) => {
    if (path.endsWith('.br')) {
      res.setHeader('Content-Encoding', 'br')
    }
  }
}))

智能压缩策略

根据客户端支持选择最优压缩算法：

const compression = require('compression')
const zlib = require('zlib')

app.use(compression({
  threshold: 1024,
  filter: (req) => !req.headers['x-no-compression'],
  level: zlib.constants.Z_BEST_COMPRESSION,
  strategy: zlib.constants.Z_RLE
}))

监控与调优

性能埋点

关键路径添加性能监控：

app.use((req, res, next) => {
  const start = process.hrtime()
  
  res.on('finish', () => {
    const diff = process.hrtime(start)
    const duration = diff[0] * 1e3 + diff[1] * 1e-6
    metrics.track('response_time', duration)
  })

  next()
})

内存泄漏检测

使用heapdump进行内存分析：

const heapdump = require('heapdump')

// 定时生成堆快照
setInterval(() => {
  if (process.memoryUsage().heapUsed > 500 * 1024 * 1024) {
    heapdump.writeSnapshot()
  }
}, 60000)

架构层面的优化

微服务拆分

将单体应用拆分为独立服务：

// 商品服务独立部署
const productGateway = express()

productGateway.get('/api/products/:id', async (req, res) => {
  const response = await fetch(`http://product-service/${req.params.id}`)
  res.json(await response.json())
})

读写分离

数据库读写分离配置示例：

// Sequelize配置
const sequelize = new Sequelize('database', null, null, {
  replication: {
    read: [
      { host: 'read1.example.com' },
      { host: 'read2.example.com' }
    ],
    write: { host: 'write.example.com' }
  }
})

异常情况处理

熔断机制实现

接口级熔断保护：

const CircuitBreaker = require('opossum')

const breaker = new CircuitBreaker(async (url) => {
  const response = await fetch(url)
  return response.json()
}, {
  timeout: 3000,
  errorThresholdPercentage: 50,
  resetTimeout: 30000
})

app.get('/proxy', async (req, res) => {
  try {
    const data = await breaker.fire('http://external-service')
    res.json(data)
  } catch (err) {
    res.status(503).send('Service unavailable')
  }
})

优雅降级

核心接口降级方案：

app.get('/recommend', async (req, res) => {
  try {
    const data = await recommendationService.get()
    res.json(data)
  } catch (err) {
    // 降级返回缓存数据
    const cached = await redis.get('fallback:recommend')
    res.json(cached || defaultRecommendations)
  }
})