验证您的操作

身份验证不包括在GraphQL规范中。本页旨在提供一些常见场景的指导，但并非详尽无遗。

使用 OkHttp 验证您的 HTTP 请求

OkHttp 拦截器是一种简单的方法，可以将"Authorization"头添加到您的 HTTP 请求中。

OkHttp 拦截器已经存在很长时间，并且工作良好，但只在 Android 和 JVM 上工作。

使用 Apollo HttpInterceptor 验证您的 HTTP 请求

为了以多平台的方式验证您的 HTTP 请求，您可以使用 ApolloHttpInterceptor。

HttpInterceptor 是跨平台的，并使用与 OkHttp 非常相似的 API

1
class AuthorizationInterceptor() : HttpInterceptor {
2
  private val mutex = Mutex()
3

4
  override suspend fun intercept(request: HttpRequest, chain: HttpInterceptorChain): HttpResponse {
5
    var token = mutex.withLock {
6
      // get current token
7
    }
8

9
    val response = chain.proceed(request.newBuilder().addHeader("Authorization", "Bearer $token").build())
10

11
    return if (response.statusCode == 401) {
12
      token = mutex.withLock {
13
        // get new token
14
      }
15
      chain.proceed(request.newBuilder().addHeader("Authorization", "Bearer $token").build())
16
    } else {
17
      response
18
    }
19
  }
20
}

更高级的例子中，您可以查看 AuthorizationInterceptor 集成测试

验证您的 WebSocket

验证 WebSocket 通常使用特定的连接有效荷载处理

1
val apolloClient = ApolloClient.Builder()
2
    .httpServerUrl("https://127.0.0.1:8080/graphql")
3
    .webSocketServerUrl("https://127.0.0.1:8080/subscriptions")
4
    .wsProtocol(
5
        SubscriptionWsProtocol.Factory(
6
            connectionPayload = {
7
              // some servers use "authorization" directly
8
              mapOf("authorization" to token)   
9
              // others require to wrap in a "headers" map
10
              mapOf("headers" to mapOf("authorization" to token))
11
              // others will expect different maps
12
              // refer to your backend docs for the actual map to use
13
            }
14
        )
15
    )
16
    .build()

或者，您也可以在初始 WebSocket 握手请求中发送头部信息

1
val apolloClient = ApolloClient.Builder()
2
    .httpServerUrl("https://127.0.0.1:8080/graphql")
3
    .subscriptionNetworkTransport(
4
        WebSocketNetworkTransport.Builder()
5
            .serverUrl("https://127.0.0.1:8080/subscriptions")
6
            .addHeader("Authorization", authorization) 
7
            .build()
8
    )
9
    .build()

更新您的 WebSocket 令牌

当使用经过验证的订阅通过 WebSocket 时，您可能需要刷新您的验证令牌，因为它已被无效化或简单地过期了。

注意：如果您的用户注销，您可能需要考虑创建一个新的 ApolloClient。这将确保除了 WebSocket 之外的所有其他状态，例如缓存示例，都是新的，并且不会在不同用户之间共享。

有时 WebSocket 将会发出一个错误，这可以在 webSocketReopenWhen 中使用来创建一个新的 WebSocket。其他时候，这些信息将来自您的应用程序的其它地方，您将不得不强制断开 WebSocket 连接。

首先定义自己的异常

1
class WebSocketReconnectException: Exception("The WebSocket needs to be reopened")

1
val apolloClient = ApolloClient.Builder()
2
        .httpServerUrl("https://127.0.0.1:8080/graphql")
3
        .webSocketServerUrl("https://127.0.0.1:8080/subscriptions")
4
        .wsProtocol(
5
            SubscriptionWsProtocol.Factory(
6
                connectionPayload = {
7
                  // the connection_init payload
8
                  // This is an example. You will most likely have to tweak it for your backend
9
                  mapOf("Authorization" to token)
10
                }
11
            )
12
        )
13
        .webSocketReopenWhen { e, attempt ->
14
          if (e is WebSocketReconnectException) {
15
            true
16
          } else {
17
            // Another WebSocket error happened, decide what to do with it
18
            // Here we're trying to reconnect at most 3 times
19
            attempt < 3
20
          }
21
        }
22
        .build()

当您需要重新打开 WebSocket 时，请调用 closeConnection：

1
apolloClient.subscriptionNetworkTransport.closeConnection(WebSocketReconnectException())`

WebSocket 将会关闭，然后使用一个新的 connectionPayload重新打开。

使用模型而不使用 apollo-runtime

WebSocket 错误