# GraphQL 性能应用 GraphQL 性能优化技术来创建高效、可扩展的 API。该技能涵盖查询复杂性分析、深度限制、批处理和缓存策略、DataLoader 优化、监控、跟踪和数据库查询优化。 ## 查询复杂度分析查询复杂性分析通过计算和限制计算成本来防止昂贵的查询压垮您的服务器。从'graphql'导入{GraphQLError}；从 '@apollo/server' 导入 { ApolloServer }； // 复杂度计算器 const getComplexity = (字段, childComplexity, args) => { // 字段的基本复杂度令复杂度 = 1； // 基于限制参数的列表乘数 if (args.limit) { 复杂性= args.limit； } else if (args.first) { 复杂性= args.first； } // 添加子复杂度返回复杂度+子复杂度； }; // 基于指令的复杂性常量架构 = ` 指令@complexity( 值：整数！乘数：[字符串！] ) 在 FIELD_DEFINITION 上类型查询{ 用户（id：ID！）：用户@complexity（值：1）用户（限制：Int）：[用户！]！ @复杂性（值：1，乘数：[“限制”] ）帖子（第一个：Int）：[帖子！]！ @复杂性（值：5，乘数：[“第一个”] ） } 类型用户{ 身份证：身份证！帖子：[帖子！]！ @复杂度（值：10） } `; // 复杂性验证插件 const 复杂度插件 = { requestDidStart: () => ({ 异步 didResolveOperation({ 请求, 文档, 操作名称 }) { 常量复杂度=计算复杂度（{ 文件，操作名称, 变量：请求.变量 }); 常量最大复杂度 = 1000; 如果（复杂度 > 最大复杂度）{ 抛出新的 GraphQLError( `查询太复杂：${complexity}。 ` + `允许的最大值：${maxComplexity}`, { 扩展名：{ 代码：'QUERY_TOO_COMPLEX'，复杂性，最大复杂度 } } ）； } } }) }; // 手动复杂度计算 constcalculateComplexity = ({ 文档, 操作名称, 变量 }) => { 让总复杂度= 0； const 访问 = (节点, 乘数 = 1) => { if (node.kind === '字段') { // 从指令或默认值获取字段复杂度 const 复杂度 = getFieldComplexity(node); // 处理来自参数的乘数 const args = getArguments(节点，变量); const fieldMultiplier = getMultiplier(args); 总复杂度 += 复杂度 * 乘数 * 字段乘数； // 访问子字段 if (node.selectionSet) { node.selectionSet.selections.forEach(child => 访问（子项，乘数 * 字段乘数））； } } }; 访问（文档）；返回总复杂度； }; ## 深度限制防止可能导致性能问题和潜在的拒绝服务攻击的深度嵌套查询。从 'graphql' 导入 { ValidationContext, GraphQLError }; const 深度限制 = (maxDepth: 数字) => { 返回（validationContext：ValidationContext）=> { 返回{ 字段（节点，键，父级，路径，祖先）{ const 深度=祖先.filter( 祖先 => 祖先.kind === 'Field' ).长度；如果（深度>最大深度）{ 验证上下文.reportError( 新的 GraphQLError( `查询超出了 ${maxDepth} 的最大深度。 ` + `发现深度为 ${深度}。`, { 节点：[节点]，扩展名：{ 代码：'DEPTH_LIMIT_EXCEEDED'，深度，最大深度 } } ））； } } }; }; }; // 与 Apollo 服务器一起使用 const 服务器 = 新 ApolloServer({ 类型定义，解析器，验证规则：[深度限制（7）] }); // 示例查询 // ✅ 允许（深度：4）查询{ 用户{ 帖子{ 评论{ 作者{ 用户名 } } } } } // ❌ 拒绝（深度：8）查询{ 用户{ 朋友{ 朋友{ 朋友{ 朋友{ 朋友{ 朋友{ 朋友{ 用户名 } } } } } } } } } ## 查询成本分析实施基于成本的速率限制以防止昂贵的查询。接口成本配置{ 对象成本：数量；标量成本：数字；默认列表大小：数字； } const 计算查询成本 = ( 文件，变量，配置：成本配置 ) => { 让总成本= 0； const 访问 = (节点, 乘数 = 1) => { if (node.kind === '字段') { const fieldType = getFieldType(节点); // 列出成本 if (isListType(fieldType)) { const listSize = getListSize(节点, 变量) || config.defaultListSize; 乘数*=列表大小； } // 字段成本 if (isObjectType(fieldType)) { 总成本 += config.objectCost * 乘数； } 否则{ 总成本 += config.scalarCost * 乘数； } // 拜访孩子 if (node.selectionSet) { node.selectionSet.selections.forEach(child => 访问（子级，乘数））； } } }; 访问（文档）；返回总成本； }; // 基于成本的速率限制常量成本限制插件 = { requestDidStart: () => ({ 异步 didResolveOperation({ 请求, 文档, contextValue }) { const 成本 = 计算查询成本( 文件，请求变量， { objectCost: 1, scalarCost: 0.1, defaultListSize: 10 } ）； // 检查用户的速率限制 const limit =等待 getRateLimit(contextValue.user); constused=awaitgetCostUsed(contextValue.user); if (已使用 + 成本 > 限制) { throw new GraphQLError('超出速率限制', { 扩展名：{ 代码：'RATE_LIMIT_EXCEEDED'，成本，使用过，限制 } }); } // 跟踪成本使用情况等待incrementCostUsed(contextValue.user, cost); } }) }; ## 使用 DataLoader 进行批处理通过将多个请求批处理为单个数据库查询来优化数据获取。从“数据加载器”导入数据加载器； // 基本数据加载器设置 const createUserLoader = (db) => { 返回新的 DataLoader<字符串，用户>( 异步（用户ID）=> { // 单一查询所有用户 const users = wait db.users.findByIds(userIds); // 维持秩序的地图 const userMap = new Map(users.map(u => [u.id, u])); return userIds.map(id => userMap.get(id) || null); }, { // 请求期间缓存缓存：真， // 一次最多批量100个最大批量大小：100， // 批处理前等待 10ms batchScheduleFn：回调=> setTimeout（回调，10） } ）； }; // 使用连接进行高级批处理 const createPostsLoader = (db) => { 返回新的 DataLoader( 异步（authorIds）=> { // 包含所有作者 ID 的单个查询 const posts =等待db.posts.query() .whereIn('authorId',authorIds) .select(); // 按作者 ID 分组 const postsByAuthor =authorIds.map(authorId => posts.filter(post => post.authorId ===authorId) ）；返回作者的帖子； } ）； }; // 多键加载器接口 PostKey { 作者 ID：字符串；状态：字符串； } const createFilteredPostsLoader = (db) => { 返回新的 DataLoader( 异步（键）=> { // 提取唯一的作者 ID 和状态 constauthorIds = [...new Set(keys.map(k => k.authorId))]; const statuses = [...new Set(keys.map(k => k.status))]; // 单一查询所有组合 const posts =等待db.posts.query() .whereIn('authorId',authorIds) .whereIn('状态', 状态) .select(); // 映射回原始键返回keys.map(key => posts.filter（帖子=> post.authorId === key.authorId && post.status === key.status ））； }, { cacheKeyFn: (key) => `${key.authorId}:${key.status}` } ）； }; // 带有自定义缓存的加载器从“lru-cache”导入{LRUCache}； const createCachedLoader = (db) => { const 缓存 = 新 LRUCache<字符串，用户>({ 最大：500， ttl: 1000 * 60 * 5 // 5 分钟 }); 返回新的 DataLoader<字符串，用户>( 异步（用户ID）=> { const users = wait db.users.findByIds(userIds); const userMap = new Map(users.map(u => [u.id, u])); return userIds.map(id => userMap.get(id) || null); }, { 缓存映射：缓存 } ）； }; ## 响应缓存策略实施多级缓存以获得最佳性能。从“加密货币”导入{createHash}； // 字段级缓存常量缓存控制 = { 用户：{ __cacheControl: { maxAge: 3600 }, // 1 小时帖子：{ __cacheControl: { maxAge: 300 } // 5 分钟 } }, 帖子：{ __cacheControl: { maxAge: 600, 范围: 'PUBLIC' } } }; // Redis缓存从 'ioredis' 导入 Redis； const redis = new Redis(); const cacheQuery = async (key: string, ttl: number, fn: () => any) => { // 尝试缓存 const 缓存 = 等待 redis.get(key); 如果（缓存）{ 返回 JSON.parse(缓存); } // 执行并缓存常量结果 = 等待 fn(); 等待 redis.setex(key, ttl, JSON.stringify(结果)); 返回结果； }; 常量解析器 = { 查询：{ 帖子： async (_, args) => { const cacheKey = `posts:${JSON.stringify(args)}`; 返回cacheQuery(cacheKey, 300, async () => { 返回 db.posts.find(args); }); }, // 带hash的自动缓存用户：异步（_，{id}）=>{ const cacheKey = `用户：${id}`; 返回cacheQuery(cacheKey, 3600, async () => { 返回 db.users.findById(id); }); } } }; // 使用 APQ 进行 CDN 缓存 // 自动持久查询减少带宽并启用 CDN 缓存 const 服务器 = 新 ApolloServer({ 类型定义，解析器，插件：[ { 异步 requestDidStart() { 返回{ 异步responseForOperation({ 请求, 操作 }) { // 仅当 APQ 哈希值存在时才缓存 if (!request.extensions?.persistedQuery?.sha256Hash) { 返回空值； } // 在 CDN 缓存 GET 请求返回{ http: { 标题：新地图（[ ['缓存控制'，'公共，最大年龄=300'] ]） } }; } }; } } ] }); ## 持久查询和 APQ 实施自动持久查询以减少负载大小并实现更好的缓存。从 '@apollo/server' 导入 { ApolloServer }；从'@apollo/utils.keyvadapter'导入{KeyvAdapter}；从 'keyv' 导入 Keyv； // 带有 Redis 后端的 APQ const 服务器 = 新 ApolloServer({ 类型定义，解析器，持久查询：{ 缓存： new KeyvAdapter(new Keyv('redis://localhost:6379')) } }); // 客户端发送哈希而不是完整查询 // 第一个请求： // 发布 /graphql // { // "query": "query GetUser { user(id: \"1\") { id name } }", //“扩展”：{ //“持久查询”：{ //“版本”：1， //“sha256Hash”：“abc123...” // } // } // } // 后续请求（小 99%）： // GET /graphql?extensions={"persistedQuery":{"version":1,"sha256Hash":"abc123..."}} // 查询白名单 const allowedQueries = new Map([ ['getUser', '查询 GetUser($id: ID!) { user(id: $id) { id 名称 } }'], ['getPosts', '查询 GetPosts { posts { id title } }'] ]); const 白名单插件 = { requestDidStart: () => ({ 异步 didResolveSource({ 源 }) { const hash = source.extensions?.persistedQuery?.sha256Hash; if (!hash || !allowedQueries.has(hash)) { throw new GraphQLError('查询未列入白名单', { 扩展：{ 代码：'FORBIDDEN' } }); } } }) }; ## 数据库查询优化优化数据库查询以高效支持 GraphQL。 // 使用 info 参数进行选择性字段加载从'graphql'导入{GraphQLResolveInfo}；从'graphql-parse-resolve-info'导入{parseResolveInfo}；常量解析器 = { 查询：{ 用户：异步（_，args，{ db }，信息：GraphQLResolveInfo）=> { // 解析请求字段 const parsedInfo = parseResolveInfo(info); const fields = Object.keys(parsedInfo.fields); // 只选择请求的字段返回 db.users.query().select(fields); }, // 基于请求字段的条件连接帖子： async (_, args, { db }, 信息: GraphQLResolveInfo) => { const parsedInfo = parseResolveInfo(info); 让查询 = db.posts.query(); // 仅在需要时加入作者如果（parsedInfo.fields.author）{ 查询 = query.withGraphFetched('作者'); } // 仅在需要时加入评论如果（parsedInfo.fields.comments）{ 查询 = query.withGraphFetched('comments'); } 返回查询； } } }; // 优化关系加载常量优化解析器 = { 查询：{ 用户： async (_, { limit, offset }, { db }) => { // 使用连接代替 N 次查询返回 db.user.query() .limit(限制) .offset(偏移量) .withGraphFetched('[帖子，个人资料]'); } }, 用户：{ 帖子： async (parent, _, { db }) => { // 如果已经通过 join 获取，则返回它 if (parent.posts) { 返回父帖子； } // 否则，单独获取 return db.posts.query().where('authorId',parent.id); } } }; // GraphQL 查询的数据库索引 // 在帖子上创建索引 idx_posts_author_id(author_id); // 创建索引 idx_posts_status ON posts(status); // 创建索引 idx_posts_created_at ON posts(created_at DESC); // 创建索引 idx_posts_author_status ON posts(author_id, status); ## 监控和分析实施全面监控以识别性能瓶颈。从 '@apollo/server' 导入 { ApolloServer }； // 计时插件 const 计时插件 = { 请求DidStart() { const start = Date.now(); 返回{ 异步 willSendResponse({ 响应 }) { const 持续时间 = Date.now() - 开始； // 添加响应时间响应.扩展= { ...响应.扩展，时间：{持续时间} }; } }; } }; // 详细的解析器时序 const 详细计时插件 = { 请求DidStart() { 常量resolverTimings = {}; 返回{ 异步执行DidStart() { 返回{ willResolveField({ 信息 }) { const start = Date.now(); 返回（）=> { const 持续时间 = Date.now() - 开始； const 路径 = info.path.key; solverTimings[路径] = 持续时间； }; } }; }, 异步 willSendResponse({ 响应 }) { 响应.扩展= { ...响应.扩展，解析器计时 }; } }; } }; // 性能跟踪 const 性能插件 = { 请求DidStart() { 返回{ 异步 didResolveOperation({ 请求, 操作 }) { // 跟踪操作指标 trackMetric('graphql.操作', 1, { 操作：操作.操作，名称：操作.名称？.值|| “匿名” }); }, 异步 didEncounterErrors({ 错误 }) { 错误.forEach（错误=> { trackMetric('graphql.error', 1, { 代码: error.extensions?.code || “未知” }); }); }, 异步 willSendResponse({ 响应 }) { const responseSize = JSON.stringify(response).length; trackMetric('graphql.response_size', responseSize); } }; } }; ## 追踪和可观察性为 GraphQL 操作实现分布式跟踪。从'@opentelemetry/api'导入{trace，SpanStatusCode}； // OpenTelemetry 跟踪插件常量跟踪插件 = { 请求DidStart() { const tracer =trace.getTracer('graphql-server'); 返回{ 异步 didResolveOperation({ 请求, 操作 }) { const span = tracer.startSpan('graphql.operation', { 属性：{ 'graphql.操作.类型'：操作.操作， 'graphql.操作.名称': 操作.名称?.值 } }); 返回{ 异步执行DidStart() { 返回{ willResolveField({ 信息 }) { const fieldSpan = 跟踪器.startSpan( `graphql.resolve.${info.fieldName}`, { 属性: { 'graphql.field': info.fieldName } } ）；返回（）=> { fieldSpan.end(); }; } }; }, 异步 willSendResponse({ 错误 }) { 如果（错误）{ span.setStatus({ 代码：SpanStatusCode.ERROR，消息：错误[0].消息 }); } 跨度结束（）； } }; } }; } }; // Apollo Studio 追踪 const 服务器 = 新 ApolloServer({ 类型定义，解析器，插件：[ require('apollo-server-plugin-response-cache')(), { 请求DidStart() { 返回{ 异步 willSendResponse({ 响应, 指标 }) { // 发送到 Apollo Studio 如果（process.env.APOLLO_KEY）{ 发送到ApolloStudio({ 操作：metrics.操作名称，持续时间：指标.持续时间，错误：响应.错误 }); } } }; } } ] }); ## 分页优化为大型数据集实施高效的分页策略。 // 基于游标的分页和数据库优化常量解析器 = { 查询：{ 帖子： async (_, { 首先, 之后 }, { db }) => { 常量限制=第一个|| 10；让查询 = db.posts.query() .orderBy('createdAt', 'desc') .limit(限制+1); // 获取一个额外的值来确定 hasNextPage 如果（之后）{ const 光标=decodeCursor(之后); 查询= query.where('createdAt','<',cursor.createdAt); } const posts = 等待查询； const hasNextPage = posts.length > 限制； const Edge = posts.slice(0, limit).map(post => ({ 光标:encodeCursor({createdAt:post.createdAt}), 节点：帖子 })); 返回{ 边缘，页面信息：{ 有下一页， endCursor: 边缘[edges.length - 1]?.cursor } }; } } }; // 键集分页以获得更好的性能 const keysetPagination = async (表, { 之后, 限制 }) => { 让查询 = db(表) .orderBy([ { 列：'createdAt'，顺序：'desc' }, { 列：'id'，顺序：'desc' } ]） .limit(限制+1); 如果（之后）{ const 游标 = JSON.parse(Buffer.from(after, 'base64').toString()); 查询 = 查询.where(函数() { this.where('createdAt', '<', 光标.createdAt) .orWhere(函数() { this.where('createdAt', '=', 光标.createdAt) .andWhere('id', '<', 光标.id); }); }); } 返回查询； }; ## 最佳实践 1. **实施查询复杂性限制**：通过复杂性分析防止昂贵的查询压垮您的服务器 2. **使用深度限制** ：设置最大查询深度，防止深度嵌套查询导致性能问题 3. **Batch with DataLoader** ：相关数据始终使用DataLoader，避免N+1查询问题 4. **策略性缓存**：根据数据波动性实现多级缓存（DataLoader、Redis、CDN） 5. **监控性能**：跟踪解析器时间、查询复杂性和错误率以识别瓶颈 6. **优化数据库查询** ：根据请求的字段使用选择性字段加载和条件连接 7. **实施 APQ** ：使用自动持久查询来减少负载大小并启用 CDN 缓存 8. **使用游标分页**：对于大型数据集，首选基于游标的分页而不是偏移量 9. **添加适当的索引**：为常见查询模式和过滤字段创建数据库索引 10. **启用跟踪** ：使用 OpenTelemetry 或 Apollo Studio 进行分布式跟踪和调试 ## 常见陷阱 1. **无查询限制**：允许可能导致拒绝服务的无限制查询 2. **效率低下的解析器**：编写不使用批处理或缓存的解析器，导致N+1问题 3. **缺少索引**：不为 GraphQL 查询模式创建数据库索引 4. **过度缓存**：过于积极地缓存数据，导致提供的数据过时 5. **忽略 info 参数** ：不使用 GraphQLResolveInfo 来优化字段选择 6. **无监控**：部署时无性能监控，无法发现问题 7. **阻塞操作**：在解析器中使用同步操作来阻塞事件循环 8. **低效分页**：对大型数据集使用基于偏移量的分页 9. **无速率限制**：允许每个用户进行无限制的查询，没有基于成本的限制 10. **缓存踩踏**：没有正确处理缓存过期，导致所有请求同时命中数据库 ## 何时使用此技能在以下情况下使用 GraphQL 性能优化技巧： * 构建一个需要扩展的新 GraphQL API * 查询响应时间缓慢 * 调试生产中的N+1查询问题 * 实施速率限制和查询成本分析 * 添加缓存层以提高性能 * 优化 GraphQL 模式的数据库查询 * 设置监控和可观察性 * 防止恶意或昂贵的查询 * 迁移到生产并需要性能调整 * 识别并修复性能瓶颈 ## 资源 * [GraphQL 最佳实践]() \- 官方性能指导 * [DataLoader 文档]() \- 批处理和缓存模式 * [Apollo性能指南]()性能优化指南 * [GraphQL 查询复杂度]() 查询复杂度分析 * [OpenTelemetry for GraphQL]() \- 分布式跟踪实现

图形性能

包含技能