Apollo Kotlin 中的程序化缓存 ID

在以下情况下声明式缓存 ID 不适用于您的用例时，您可以为 程序化 生成您标准化缓存中的对象类型缓存 ID。

您可以从以下两个来源之一生成给定对象类型' 的缓存在 ID：

来源	类	描述
从响应对象的字段（例如，`Book.id`)	`CacheKeyGenerator`	这会在网络请求之后发生，对于将查询结果与现有缓存数据合并至关重要。这是最常见的情况。
从GraphQL操作的参数（例如，`author(id: "au456")`）中	`缓存键解析器`	这会发生在一个网络请求之前，使你能够在缓存中已经存在所有请求的数据的情况下避免网络往返。这是一个可选的优化，可以避免一些缓存缺失。

Apollo Kotlin提供了一个类，可以从每个这些来源生成缓存ID。

`CacheKeyGenerator`

类CacheKeyGenerator允许您从对象的字段值中生成自定义缓存ID。以下是一个基本示例，从每个对象类型的id字段生成其缓存ID：

1
val cacheKeyGenerator = object : CacheKeyGenerator {
2
  override fun cacheKeyForObject(obj: Map<String, Any?>, context: CacheKeyGeneratorContext): CacheKey? {
3
    // Generate the cache ID based on the object's id field
4
    return CacheKey(obj["id"] as String)
5
  }
6
}

要使用您的自定义CacheKeyGenerator，将其包含在您的缓存初始化代码中，如下所示：

1
val apolloClient = ApolloClient.Builder()
2
  .serverUrl("https://example.com/graphql")
3
  .normalizedCache(
4
    normalizedCacheFactory = cacheFactory,
5
    cacheKeyGenerator = cacheKeyGenerator,
6
  )
7
  .build()

您可以从context对象中获取当前对象的typename并将其包含在生成的ID中，如下所示：

1
val cacheKeyGenerator = object : CacheKeyGenerator {
2
  override fun cacheKeyForObject(obj: Map<String, Any?>, context: CacheKeyGeneratorContext): CacheKey? {
3
    val typename = context.field.type.rawType().name
4
    val id = obj["id"] as String
5

6
    return CacheKey(typename, id)
7
  }
8
}

您还可以使用当前对象的typename来针对不同的对象类型使用不同的缓存ID生成逻辑。

请注意，为了使缓存ID生成有效，您的GraphQL操作的操作必须返回自定义代码所依赖的任何字段（如上例中的id）。如果查询没有返回所需字段，则缓存ID将不一致，导致数据重复。此外，对于接口和联合类型，使用context.field.type.rawType().name属性会返回与该类型在规范中声明时相同的typename，而不是响应中接收到的类型的运行时值。相反，查询typename会更安全。为了确保所有操作都包含__typename，设置以下addTypename gradle配置：

1
apollo {
2
  service("service") {
3
    addTypename.set("always")
4
  }
5
}

`缓存键解析器`

The CacheKeyResolver 类允许您从一个字段's 参数中生成自定义缓存 ID。这个基本示例从现有的 id 参数生成每种对象类型的缓存 ID：如果该参数存在。

1
val cacheKeyResolver = object: CacheKeyResolver() {
2
  override fun cacheKeyForField(field: CompiledField, variables: Executable.Variables): CacheKey? {
3
    // [field] contains compile-time information about what type of object is being resolved.
4
    // Even though we call rawType() here, we're guaranteed that the type is a composite type and not a list
5
    val typename = field.type.rawType().name
6

7
    // argumentValue returns the runtime value of the "id" argument
8
    // from either the variables or as a literal value
9
    val id = field.argumentValue("id", variables).getOrNull()
10

11
    if (id is String) {
12
      // This field has an id argument, so we can use it to compute a cache ID
13
      return CacheKey(typename, id)
14
    }
15

16
    // Return null to use the default handling
17
    return null
18
  }
19
}

要使用您自己的 CacheKeyResolver，请将其包含在您的缓存初始化代码中，如下所示：

1
val apolloClient = ApolloClient.Builder()
2
  .serverUrl("https://example.com/graphql")
3
  .normalizedCache(
4
    normalizedCacheFactory = cacheFactory,
5
    cacheKeyGenerator = cacheKeyGenerator,
6
    cacheResolver = cacheKeyResolver
7
  )
8
  .build()

请注意使用自定义 CacheKeyResolver的以下事项：

对于返回复合类型的操作中的每个字段，都会调用 cacheKeyForField 函数，因此如果您不想处理特定字段，则非常重要地返回 null。
对于返回复合类型列表的字段，不调用函数。

处理列表

让我们假设我们有一个这样的查询：

1
query GetBooks($ids: [String!]!) {
2
  books(ids: $ids) {
3
    id
4
    title
5
  }
6
}

要使缓存查找 ids 列表中的所有书籍，我们需要覆盖 listOfCacheKeysForField 在 CacheKeyResolver:

1
override fun listOfCacheKeysForField(field: CompiledField, variables: Executable.Variables): List<CacheKey?>? {
2
  // Note that the field *can* be a list type here
3
  val typename = field.type.rawType().name
4

5
  // argumentValue returns the runtime value of the "id" argument
6
  // from either the variables or as a literal value
7
  val ids = field.argumentValue("ids", variables).getOrNull()
8

9
  if (ids is List<*>) {
10
    // This field has an id argument, so we can use it to compute a cache ID
11
    return ids.map { CacheKey(typename, it as String) }
12
  }
13

14
  // Return null to use the default handling
15
  return null
16
}

为了简单起见，仅支持一个列表级别。要支持更多嵌套列表，可以实现 CacheResolver。 CacheResolver 是 CacheKeyResolver 的一般化，可以返回缓存中的任何值，甚至标量值：

1
val cacheResolver = object: CacheResolver {
2
  override fun resolveField(
3
      field: CompiledField,
4
      variables: Executable.Variables,
5
      parent: Map<String, @JvmSuppressWildcards Any?>,
6
      parentId: String,
7
  ): Any? {
8

9
    var type = field.type
10
    var listDepth = 0
11

12
    while (true) {
13
      when (type) {
14
        is CompiledNotNullType -> type = type.ofType
15
        is CompiledListType -> {
16
          listDepth++
17
          type = type.ofType
18
        }
19
        else -> break
20
      }
21
    }
22

23
    // Now type points to the leaf type and lestDepth is the nesting of lists required
24

25
    // Return a kotlin value for this field
26
    // No type checking is done here, so it must match the expected GraphQL type
27

28
    if (listDepth == 2) {
29
      return listOf(listOf("0", "1"))
30
    }
31

32
    // CacheResolver must always call DefaultCacheResolver last or all fields will be null else
33
    return DefaultCacheResolver.resolveField(field, variables, parent, parentId)
34
  }
35
}

声明式缓存 ID

监视缓存数据