如何在 GraphQL 中处理循环依赖的问题

什么是循环依赖

在前端开发中，循环依赖常常会出现。循环依赖指的是在几个模块之间互相引用。例如，模块 A 引用了模块 B，同时模块 B 也引用了模块 A。这种情况下，很容易出现死循环，导致应用卡顿或者崩溃。

在 GraphQL 中，如果类型之间存在循环依赖，那么会出现类似的问题。比如，类型 A 引用了类型 B，同时类型 B 也引用了类型 A。这种情况下，如果不加处理，GraphQL 解析器就会陷入死循环，导致应用不可用。

如何处理循环依赖

在 GraphQL 中，处理循环依赖的方法有很多种。这里介绍两种常用的方法。

方法一：延迟加载

延迟加载的处理方式，常常被用于解决循环依赖问题。在 GraphQL 中的具体实现方式，就是通过一些 Promise 或者 Thunk 对象，把字段的查询和解析推迟到最后执行。这样，当 GraphQL 解析器遇到循环依赖时，它就会暂时停止解析，并返回一个 Promise 或者 Thunk，等到调用该对象时，再重新启动解析。

// javascriptcn.com 代码示例
// 定义一个 User 类型
const UserType = new GraphQLObjectType({
  name: 'User',
  fields: {
    id: {
      type: GraphQLID,
    },
    name: {
      type: GraphQLString,
    },
    // 延迟加载 friends 字段
    friends: {
      type: new GraphQLList(() => UserType),
      resolve(user, args, context) {
        // 返回一个 Promise 或者 Thunk，等到调用该对象时，再重新启动解析
        return new Promise((resolve, reject) => {
          setTimeout(() => {
            resolve(getFriends(user.id));
          }, 1000);
        });
      },
    },
  },
});

方法二：提前加载

提前加载的处理方式，就是尽可能地避免循环依赖的情况。在 GraphQL 中的具体实现方式，就是通过把类型拆解成更小的类型，把共同的字段提取出来，从而避免循环依赖的出现。这种方法的好处是，在 GraphQL 解析器内部，它只需要一次性查询到所有需要的字段，不会出现 Deadlock 等问题。

// javascriptcn.com 代码示例
// 定义一个 User 类型
const UserType = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLID,
    },
    name: {
      type: GraphQLString,
    },
    friendIds: {
      // 把 friends 字段的 id 提取出来
      type: new GraphQLList(GraphQLID),
      resolve(user, args, context) {
        // 直接返回 friendIds，避免循环依赖的出现
        return user.friendIds;
      },
    },
  }),
});

// 定义一个 Friend 类型
const FriendType = new GraphQLObjectType({
  name: 'Friend',
  fields: () => ({
    id: {
      type: GraphQLID,
    },
    name: {
      type: GraphQLString,
    },
  }),
});

// 定义一个 RootQuery 类型
const RootQuery = new GraphQLObjectType({
  name: 'RootQuery',
  fields: {
    user: {
      type: UserType,
      args: { id: { type: GraphQLID } },
      resolve(parent, args, context) {
        return getUser(args.id);
      },
    },
    friend: {
      type: FriendType,
      args: { id: { type: GraphQLID } },
      resolve(parent, args, context) {
        return getFriend(args.id);
      },
    },
  },
});

总结

在 GraphQL 中，处理循环依赖的方法有很多种。无论采用何种方法，都应该充分考虑到类型之间的关系，避免出现死循环的情况。同时，合理利用延迟加载和提前加载的方式，可以大大提高 GraphQL 应用的性能和效率。

来源：JavaScript中文网 ，转载请注明来源 本文地址：https://www.javascriptcn.com/post/65468a637d4982a6eb0a14ba