GraphQL N+1 问题与 DataLoader 优化

N+1 查询问题是 GraphQL API 最常见的性能瓶颈。当 GraphQL 查询请求一个对象列表及其关联对象时，如果没有优化，解析器会对每个对象单独发起一次数据库查询，导致 1 次查询获取 N 个对象，然后 N 次查询获取每个对象的关联数据，总计 N+1 次数据库查询。DataLoader 是 Facebook 官方提供的解决 N+1 问题的方案，通过批量请求和缓存机制，将多次查询合并为一次。

N+1 问题演示

type Query {
  posts: [Post!]!
}
type Post {
  id: ID!
  title: String!
  author: User!   # 这里会触发 N+1
}
type User {
  id: ID!
  name: String!
}
客户端查询：
query {
  posts {
    title
    author {
      name
    }
  }
}
如果 posts 返回 10 条数据，没有 DataLoader 时：
SELECT * FROM posts;                           -- 1 次查询
SELECT * FROM users WHERE id = 1;              -- 第 1 个 author
SELECT * FROM users WHERE id = 2;              -- 第 2 个 author
SELECT * FROM users WHERE id = 3;              -- 第 3 个 author
... 共 11 次查询</code></pre>
DataLoader 原理
DataLoader 的核心思想是：在单个请求的上下文中，延迟所有数据请求到一个「批处理函数」中，收集所有需要加载的 ID，然后一次性从数据库取出所有数据，再分发回各个解析器。
请求流程（无 DataLoader）：
Resolver(Post.author) -> db.query("SELECT * FROM users WHERE id = ?", [id])
Resolver(Post.author) -> db.query("SELECT * FROM users WHERE id = ?", [id])
Resolver(Post.author) -> db.query("SELECT * FROM users WHERE id = ?", [id])
请求流程（有 DataLoader）：
Resolver(Post.author) -> loader.load(id)  # 收集到批处理队列
Resolver(Post.author) -> loader.load(id)  # 收集到批处理队列
Resolver(Post.author) -> loader.load(id)  # 收集到批处理队列
Tick/Next Tick：批量执行一次查询 SELECT * FROM users WHERE id IN (1,2,3)</code></pre>

DataLoader 实现
const DataLoader = require("dataloader");
const { db } = require("./db");
// 创建 batch 函数
const userBatchFn = async (ids) => {
  const users = await db.query(
    "SELECT * FROM users WHERE id IN (?)",
    [ids]
  );
  // DataLoader 要求结果顺序与输入 IDs 顺序一致
  const userMap = new Map(users.map((u) => [u.id, u]));
  return ids.map((id) => userMap.get(id) || null);
};
const createLoaders = () => ({
  userLoader: new DataLoader(userBatchFn),
});
// 在 context 中注入 loaders
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: () => ({
    loaders: createLoaders(),
  }),
});

Resolver 中使用 DataLoader
const resolvers = {
  Query: {
    posts: async (_, __, { loaders }) => {
      return loaders.postLoader.loadMany();
    },
  },
  Post: {
    author: (post, _, { loaders }) => {
      return loaders.userLoader.load(post.authorId);
    },
  },
};
支持关联查询的 DataLoader
// 批量加载用户的帖子列表
const postsByUsersBatchFn = async (userIds) => {
  const posts = await db.query(
    "SELECT * FROM posts WHERE user_id IN (?)",
    [userIds]
  );
  // 按 user_id 分组
  const grouped = {};
  for (const post of posts) {
    if (!grouped[post.user_id]) grouped[post.user_id] = [];
    grouped[post.user_id].push(post);
  }
  return userIds.map((uid) => grouped[uid] || []);
};
const createLoaders = () => ({
  userLoader: new DataLoader(userBatchFn),
  postsByUserLoader: new DataLoader(postsByUsersBatchFn),
});
const resolvers = {
  User: {
    posts: (user, _, { loaders }) => {
      return loaders.postsByUserLoader.load(user.id);
    },
  },
};

缓存与生命周期
DataLoader 缓存的作用域是单个请求。
const loader = new DataLoader(userBatchFn);
// 同一请求内，多次 load(1) 只有第一次会触发批处理
loader.load(1); // 触发批处理
loader.load(2); // 收集，触发批处理
loader.load(1); // 直接从缓存返回，不触发批处理
每个新的请求都应创建新的 DataLoader 实例，否则不同请求的数据会串门。

常见错误
错误：在模块级别创建 DataLoader（导致请求间数据串门）
const userLoader = new DataLoader(userBatchFn);  // 全局单例，危险！
正确：在每个请求的 context 中创建 DataLoader
context: () => ({
  loaders: {
    userLoader: new DataLoader(userBatchFn),
  },
});

注意事项

DataLoader 的批处理函数必须返回与输入数组顺序一致的结果，使用 Map 做映射转换
每个请求应创建新的 DataLoader 实例，请求结束后自动清空缓存
批处理函数中注意处理空 ID 和无效 ID 的情况
DataLoader 默认不支持深度关联的自动批处理，需要手动为每层关联创建 DataLoader
对于不会重复查询的简单场景，可以配置 cache: false 减少内存占用

DataLoader 是解决 GraphQL N+1 问题的标准方案，正确使用能显著降低数据库查询次数，提升 API 性能。