验证您的操作

验证并未包含在GraphQL 规范中。本页面旨在提供一些常见场景的指导，但并不全面。

使用OkHttp验证您的HTTP请求

OkHttp拦截器是添加"Authorization"头信息到您的HTTP请求的简单方法。

OkHttp拦截器已经存在很长时间，并且工作良好，但只能与Apollo Kotlin（适用于Android和JVM）一起使用。

使用Apollo HttpInterceptor验证您的HTTP请求

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

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://example.com/graphql")
3
    .subscriptionNetworkTransport(
4
        WebSocketNetworkTransport.Builder()
5
            .serverUrl("https://example.com/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错误