20.3 数据库与 I/O 优化

在典型的 Node.js 应用中，最耗时的操作往往不是业务逻辑运算，而是数据库查询和外部 I/O 调用。即使事件循环本身保持高效，一次慢查询或一个未优化的外部请求，也足以让整个请求的响应时间从几十毫秒变成几秒，进而拖垮并发处理能力。因此，数据库和 I/O 层面的优化是 Node.js 性能调优的重中之重。

20.3.1 数据库索引优化

索引是关系型数据库（MySQL、PostgreSQL）和某些 NoSQL（如 MongoDB）中提升查询性能的最高杠杆工具。在 Node.js 应用中，有几种典型的索引问题值得关注：

1. 确保高频查询走索引

每一条 SELECT、UPDATE、DELETE 语句，如果 WHERE 条件中的字段没有索引，数据库就会执行全表扫描。对于数据量较大的表，这几乎是不可接受的。使用 EXPLAIN（MySQL）或 EXPLAIN ANALYZE（PostgreSQL）可以查看查询是否使用了索引。

在 Node.js ORM 或查询构造器中，可以开启慢查询日志来捕获执行时间超过阈值的 SQL：

// 以 mysql2 为例，可以通过连接配置直接开启
const mysql = require('mysql2/promise');
const pool = mysql.createPool({
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'myapp',
  connectionLimit: 10,
  // 开启慢查询日志（也可在数据库配置层面设置）
  // 这里仅示例，实际需要配合 MySQL 本身的配置
});

在 MySQL 中，设置 long_query_time 并打开 slow_query_log，然后分析慢查询日志，对涉及不恰当索引的查询进行优化。

2. 联合索引的最左前缀原则

当业务经常按 WHERE status = ? AND created_at > ? 查询时，创建 (status, created_at) 的联合索引会远比两个单独的索引高效。同时要注意，如果查询条件中不包含最左列，联合索引可能失效。

对于 Mongoose（MongoDB）的应用，也可以创建复合索引来提高查询效率：

const OrderSchema = new mongoose.Schema({
  userId: String,
  status: String,
  createdAt: Date,
});
OrderSchema.index({ userId: 1, status: 1, createdAt: -1 });

3. 避免索引函数化

在 SQL 中的 WHERE YEAR(created_at) = 2025 会导致索引失效，因为数据库无法直接使用 created_at 列的索引。应该在代码中计算范围边界，写成：

SELECT * FROM orders WHERE created_at >= '2025-01-01' AND created_at < '2026-01-01';

在 Node.js 中，使用查询构造器时要注意传递给 SQL 的参数形式。

4. 覆盖索引减少回表

如果查询频繁读取某些字段，可以建立包含这些字段的联合索引，使查询完全通过索引返回数据，避免回表。但这需要权衡索引大小和维护成本，一般用于极高频的查询。

20.3.2 数据库连接池优化

Node.js 作为单线程事件循环模型，无法像 Java 那样为每个请求分配线程再管理数据库连接，因此连接池是必须使用的组件。连接池内部维持多个长连接复用，避免频繁建立/销毁连接的开销。

1. 合理设置连接池大小

连接池不是越大越好。每个连接都会在数据库服务器上占用内存和线程资源，过大的连接池反而会导致操作系统调度加重，甚至被数据库拒绝连接。

一个经验公式：对于普通的 Web 应用，连接池大小可以在 最大并发请求数 和 数据库能接受的最大连接数 之间折中。通常设置为核心数 * 2 再加几个备用连接即可，例如 4 核服务器可以设置连接池为 10。

在 mysql2 或 pg 的连接配置中：

const pool = mysql.createPool({
  connectionLimit: 20,  // 根据压测结果调整
  host: 'localhost',
  user: 'root',
  password: 'password',
  database: 'myapp',
});

2. 连接超时与自动回收

连接池中的连接可能因为网络波动或数据库重启而变成无效连接。Node.js 的数据库驱动一般会提供 acquireTimeout（获取连接超时）和 idleTimeout（空闲连接销毁）配置。

const { Pool } = require('pg');
const pool = new Pool({
  max: 20,
  idleTimeoutMillis: 30000,  // 空闲连接超过 30s 释放
  connectionTimeoutMillis: 2000,  // 获取连接超时 2s
});

此外，可以定期（比如每 60 秒）执行一条轻量查询（如 SELECT 1）来探测连接是否存活性，但这通常由连接池库内部处理（如 pool.validate() 功能），在使用时应参考具体文档。

3. 避免连接泄露

当使用回调模式或 async/await 时，一定要确保释放从连接池获取的连接。如果采用手动获取连接的方式，应该在 finally 块中释放，否则会导致连接池被耗尽。

const conn = await pool.getConnection();
try {
  const [rows] = await conn.query('SELECT * FROM users');
  return rows;
} finally {
  conn.release(); // 确保释放
}

使用 ORM 时通常由框架自动管理连接，但也要注意事务中是否及时提交或回滚，避免长事务占用连接。

20.3.3 查询优化与 ORM 使用策略

许多 Node.js 项目使用 Sequelize、TypeORM、Prisma 等 ORM 工具，它们在提高生产力的同时，也可能生成低效的 SQL 查询。优化查询需要注意以下几点：

1. 避免 N+1 查询

这是最常见的性能陷阱。例如查询用户列表后，对每个用户再单独查询其订单：

// 错误：N+1
const users = await User.findAll();
for (const user of users) {
  const orders = await Order.findAll({ where: { userId: user.id } });
}

应该使用 include（Sequelize）、relations（TypeORM）或 include（Prisma）进行预加载，甚至手动用 JOIN 一次性取出所有数据。

2. 只查询需要的字段

不要为了省事每个查询都用 SELECT *，尤其在表宽且包含长文本或 BLOB 字段时。ORM 中可以指定 attributes 或 select：

// 只拿 id 和 name
const users = await User.findAll({
  attributes: ['id', 'name'],
});

3. 批量操作

当需要插入或更新大量数据时，不要逐条执行，应使用数据库的批量操作功能。例如 MySQL 的 INSERT ... VALUES 可以一次性插入多行，Sequelize 提供的 bulkCreate 也能合并语句。

await User.bulkCreate([
  { name: 'Alice' },
  { name: 'Bob' },
  // ...
]);

4. 预处理与查询分析

定期使用数据库的查询分析工具（MySQL 的 Performance Schema、PostgreSQL 的 pg_stat_statements）统计最耗时的 SQL，并在 Node.js 应用日志中加入慢查询警告，持续优化。

20.3.4 多级缓存策略

当数据库优化到一定程度仍然无法满足性能需求时，必须引入缓存。合理使用缓存可以极大降低数据库负载和响应延迟。Node.js 应用最适合采用多级缓存架构：本地内存缓存 + 分布式缓存（如 Redis）。

1. 本地内存缓存

对于变化频率极低且数据量小的数据（如配置项、字典、国家列表），可以直接缓存在 Node.js 进程内存中，避免任何网络 I/O。可以使用 ES6 Map 或成熟的库如 lru-cache 实现自动过期和内存控制。

const LRU = require('lru-cache');
const options = { max: 500, ttl: 1000 * 60 * 5 }; // 最大 500 项，5 分钟过期
const cache = new LRU(options);

async function getConfig(key) {
  if (cache.has(key)) {
    return cache.get(key);
  }
  const config = await Config.findOne({ where: { key } });
  cache.set(key, config);
  return config;
}

不过要避免内存无限增长，必须设置最大数量和过期时间，否则可能引起内存泄漏。同时要注意多进程部署时，每个进程维护自己的内存缓存，数据不一致可能会成为问题，适用于对一致性要求不极端严格的热点数据。

2. Redis 分布式缓存

当应用跨多个进程或多台服务器时，必须使用中心化的缓存如 Redis。Redis 的高性能和丰富的数据结构使其成为 Node.js 应用缓存层的标配。

缓存读取模式（Cache-Aside）：

const redis = require('ioredis');
const client = new redis();

async function getUser(userId) {
  const cacheKey = `user:${userId}`;
  const cached = await client.get(cacheKey);
  if (cached) {
    return JSON.parse(cached);
  }
  const user = await User.findByPk(userId);
  if (user) {
    await client.set(cacheKey, JSON.stringify(user), 'EX', 600); // 10分钟过期
  }
  return user;
}

缓存策略选择：

• Cache-Aside（旁路缓存）：适用于大部分读多写少场景，应用直接管理缓存的读取和回写。
• Write-Through / Write-Behind：在更新数据库的同时更新缓存，可以简化逻辑，但需要考虑一致性。
• Redis 发布订阅 可以在数据更新时通知所有 Node.js 进程清空本地缓存，保持整体数据新鲜度。

3. 防止缓存雪崩与缓存击穿

• 缓存雪崩：大量缓存在同一时间过期，导致请求直接倾斜到数据库。解决方案是给过期时间加随机偏移量（如 EX, 600 + Math.random() * 60）。
• 缓存击穿：热点数据在过期瞬间被大量请求冲击数据库。可以使用互斥锁（redis setnx 或分布式锁）保证只有一个请求去加载数据并回写缓存。
• 缓存穿透：查询不存在的数据，导致缓存和数据库都空转。可以缓存空值（短过期时间），或使用布隆过滤器过滤无效 key。

20.3.5 I/O 调度优化

除了数据库，应用程序还可能与其他服务（API 网关、消息队列、第三方接口）进行大量网络 I/O。优化这些 I/O 同样可以显著提升吞吐量。

1. 合理控制并发与超时

Node.js 可以对多个异步 I/O 操作进行并发控制，避免无限制地同时发起请求：

const pLimit = require('p-limit');
const limit = pLimit(10); // 最大并发 10

const tasks = ids.map(id =>
  limit(() => fetchDataFromExternal(id))
);
const results = await Promise.all(tasks);

必须为每一个外部调用设置合适的超时时间，防止慢响应或僵死的连接无限期占用资源：

const axios = require('axios');
try {
  const response = await axios.get('/api/external', { timeout: 5000 });
} catch (err) {
  // 超时或网络错误处理
}

2. 批量请求与数据聚合

如果多个下游服务提供的是可合并的数据，可以使用 Promise.all 并发调用，避免串行等待。在 BFF 层中，可以并发请求多个微服务，然后组装响应。

const [user, orders, products] = await Promise.all([
  getUser(id),
  getOrders(id),
  getProducts(),
]);

3. 使用连接池管理 HTTP 客户端

Node.js 的原生 http.Agent 会对同一个主机保持长连接，复用底层 socket，减少 TCP 握手开销。使用 axios 或 node-fetch 时，确保配置 keepAlive。在高负载下，还可以将 maxSockets 调整为更大的值以提高并行度：

const https = require('https');
const agent = new https.Agent({
  keepAlive: true,
  maxSockets: 50,
});
axios.get('/api', { httpsAgent: agent });

20.3.6 监控与持续调优

数据库和 I/O 优化不是一次性的工作，而是需要持续观测的长期过程。在生产环境中，应该集成以下指标的可视化：

• 数据库连接池状态：活跃连接数、等待获取连接的请求数（积压）等，及时发现连接泄漏或不足。
• 缓存命中率：本地缓存和 Redis 缓存的命中/未命中比率，判断缓存策略是否有效。
• 接口响应时间百分比：尤其关注 P95、P99 延迟，定位最慢的调用。
• 数据库慢查询数：设置告警阈值，一旦慢查询数量异常上升立即分析。

结合 APM 工具（如 DataDog、New Relic、OpenTelemetry + Jaeger）可以追踪每一个请求在数据库、缓存、下游服务上的耗时分布，从而精准找到瓶颈所在。

数据库与 I/O 的优化是 Node.js 性能从“能用”走向“好用”的必经之路。通过索引、连接池、高效查询、多级缓存和完善的监控，可以使应用在高并发下保持低延迟、高吞吐，充分发挥 Node.js 事件驱动模型的价值。