GraphQL Resolver 性能与 N+1：从根因到根治的调优指南

query Feed {
  feed(first: 30) {
    edges {
      node {
        id
        title
        author {
          name
          email
        }
      }
    }
  }
}

import DataLoader from 'dataloader';
import { getUsersByIds } from './repos/users';

// 每个请求创建一个 loader，并将它挂在 context 上
function createLoaders() {
  return {
    userById: new DataLoader(async (ids: readonly string[]) => {
      const rows = await getUsersByIds(ids as string[]);
      // 注意：必须按传入 ids 的顺序返回，缺失项补 null
      const map = new Map(rows.map((r) => [r.id, r]));
      return ids.map((id) => map.get(id) ?? null);
    }),
  };
}

export const resolvers = {
  Post: {
    author: (post, _args, ctx) => ctx.loaders.userById.load(post.authorId),
  },
  Query: {
    feed: async (_root, args, ctx) => {
      const posts = await fetchFeed(ctx, args);
      // 预先触发 author 的批量加载，让批处理窗口更饱满
      posts.forEach((p) => ctx.loaders.userById.load(p.authorId));
      return posts;
    },
  },
};

async function fetchFeedWithAuthors(args) {
  const rows = await db.query(
    `SELECT p.*, u.id AS author_id, u.name AS author_name, u.email AS author_email
     FROM posts p
     JOIN users u ON u.id = p.author_id
     WHERE p.status = 'published'
     ORDER BY p.created_at DESC
     LIMIT $1`,
    [args.first],
  );
  return rows.map((r) => normalize(r));
}

CREATE MATERIALIZED VIEW user_stats AS
SELECT u.id,
       COUNT(o.id)     AS order_count,
       SUM(o.total)    AS order_total
FROM users u
LEFT JOIN orders o ON o.user_id = u.id
GROUP BY u.id;

REFRESH MATERIALIZED VIEW CONCURRENTLY user_stats; -- 定时/触发刷新

import { ApolloServer } from '@apollo/server';
import { ApolloServerPluginInlineTrace } from '@apollo/server/plugin/inlineTrace';

const server = new ApolloServer({
  typeDefs,
  resolvers,
  plugins: [
    ApolloServerPluginInlineTrace({ includeErrors: true, includeStack: true }),
  ],
});

import { ApolloServerPluginUsageReporting } from '@apollo/server/plugin/usageReporting';

plugins: [
  ApolloServerPluginUsageReporting({
    endpointUrl: 'http://apm-collector:4318',
    // 采样率，避免全量上报开销
    sendTraces: ({ requestContext }) => requestContext.operationName === 'Feed',
  }),
]

import depthLimit from 'graphql-depth-limit';

const server = new ApolloServer({
  typeDefs,
  resolvers,
  validationRules: [depthLimit(10)],
});

import queryComplexity, {
  simpleEstimator,
  fieldExtensionsEstimator,
} from 'graphql-query-complexity';

const rule = queryComplexity({
  estimators: [
    fieldExtensionsEstimator(),
    simpleEstimator({ defaultComplexity: 1 }),
  ],
  maximumComplexity: 1000,
  onComplete: (complexity) => console.log(`Query complexity: ${complexity}`),
});

const server = new ApolloServer({
  validationRules: [depthLimit(10), rule],
});

async function userInfo(_root, args, ctx) {
  const [user, stats, recentOrders] = await Promise.all([
    ctx.loaders.userById.load(args.id),
    fetchUserStats(ctx, args.id),
    fetchRecentOrders(ctx, args.id, 5),
  ]);
  return { ...user, stats, recentOrders };
}

// 坏：循环内 await
for (const id of ids) {
  rows.push(await client.get(`user:${id}`)); // 串行 N 次
}

// 好：mget 批量
const rows = await redisClient.mget(ids.map((id) => `user:${id}`));

import Redis from 'ioredis';
import DataLoader from 'dataloader';

const redis = new Redis(process.env.REDIS_URL!);

// 带 Redis 回源的 DataLoader：先查缓存，未命中批量回源，回源后写缓存
function cachedLoader(redisKey: (id: string) => string, fetchByIds: (ids: string[]) => Promise<Record<string, any>>) {
  return new DataLoader(async (ids: readonly string[]) => {
    const keys = ids.map((id) => redisKey(id));
    const hits = await redis.mget(keys);
    const missIds = ids.filter((_, i) => hits[i] == null);
    const fetched = missIds.length ? await fetchByIds(missIds) : {};

    const pipeline = redis.pipeline();
    for (const id of missIds) {
      const value = fetched[id];
      if (value) {
        pipeline.set(redisKey(id), JSON.stringify(value), 'EX', 300);
      }
    }
    await pipeline.exec();

    return ids.map((id, i) => {
      if (hits[i]) return JSON.parse(hits[i] as string);
      return fetched[id] ?? null;
    });
  });
}

# 安装与压测
npx autocannon -c 100 -d 30 \
  -m POST \
  -H 'content-type: application/json' \
  -b '{"query":"query Feed { feed(first: 30) { edges { node { id title author { name } } } } }"}' \
  http://localhost:4000/graphql

// 改造后：三层并行 + 批量 + 缓存
async function feed(_root, args, ctx) {
  const posts = await fetchPublishedPosts(ctx, args);            // 1 次
  const authors = await ctx.loaders.userById.loadMany(
    posts.map((p) => p.authorId));                               // 1 次（批量）
  const previews = await fetchCommentPreviews(
    ctx, posts.map((p) => p.id), 3);                             // 1 次（批量）
  return { posts, authors, previews };
}

export const resolvers = {
  FeedItem: {
    author: (item) => item.authors.get(item.post.authorId),
    commentPreview: (item) => item.previews.get(item.post.id),
  },
};