Join us from October 8-10 in New York City to learn the latest tips, trends, and news about GraphQL federation and API platform engineering.Join us for GraphQL Summit 2024 in NYC
Docs
Start for Free

Using a custom HTTP client


By default, uses the following HTTP clients for different platforms/languages:

PlatformHTTP Client
Android/JVMOkHttp
JavaScript/Wasmfetch() / Node Fetch for HTTP, Ktor for WebSockets
iOS/MacOSNSURLSesssion

Ktor engine

Additionally, an optional implementation based on Ktor for all targets is available in the apollo-engine-ktor module. To use it, add the following dependency to your project:

build.gradle[.kts]
dependencies {
// ...
implementation("com.apollographql.apollo3:apollo-engine-ktor:4.0.0-beta.7")
}

And configure your ApolloClient to use the Ktor engine:

val client = ApolloClient.Builder()
.serverUrl("https://example.com/graphql")
// Create a new Ktor engine
.httpEngine(KtorHttpEngine())
// Or, if you want to reuse an existing Ktor client
.ktorClient(myKtorClient)
.build()

Implement your own HTTP engine

You can use a different HTTP client with Apollo Kotlin by creating a custom class that implements the HttpEngine interface.

The HttpEngine interface defines two functions: execute and close. Here's an example implementation that also includes a couple of helper methods:

class MyHttpEngine(val wrappedClient: MyClient) : HttpEngine {
/**
* Helper function to map the Apollo requests to MyClient requests
*/
private fun HttpMethod.toMyClientRequest(): MyClientRequest {
...
}
/**
* And the other way around
*/
private fun MyClientResponse.toApolloResponse(): HttpResponse {
...
}
override suspend fun execute(request: HttpRequest) = suspendCancellableCoroutine { continuation ->
val call = wrappedClient.newCall(request.toMyClientRequest())
continuation.invokeOnCancellation {
// If the coroutine is cancelled, also cancel the HTTP call
call.cancel()
}
wrappedClient.enqueue(
call,
success = { myResponse ->
// Success! report the response
continuation.resume(myResponse.toApolloResponse())
},
error = { throwable ->
// Error. Wrap in an ApolloException and report the error
continuation.resumeWithException(ApolloNetworkException(throwable))
}
)
}
override fun close() {
// Dispose any resources here
}
}

This example uses an asynchronous wrappedClient that runs the network request in a separate thread. Note that because HttpEngine.execute itself is called from a background thread, you can safely block in execute().

Using your HttpEngine

After you create your HttpEngine implementation, you can register it with your ApolloClient instance using ApolloClient.Builder.httpEngine:

// Use your HttpEngine
val client = ApolloClient.Builder()
.serverUrl(serverUrl = "https://example.com/graphql")
.httpEngine(httpEngine = MyHttpEngine(wrappedClient))
.build()

With this configuration, Apollo Kotlin sends all of its requests with MyHttpEngine.

Other HTTP customizations

Besides implementing HttpEngine, Apollo Kotlin also supports other methods for customizing HTTP behavior:

  • No runtime: You can opt out of the Apollo Kotlin runtime completely and only use generated models and parsers. Use this option if you don't need any of the runtime features (caching, batching, , etc.).
  • HTTP interceptors: If you want to add HTTP headers and/or logging to your requests, HTTP interceptors enable you to do this with minimal code.
Previous
Interceptors
Next
Using the models without apollo-runtime
Rate articleRateEdit on GitHubEditForumsDiscord

© 2024 Apollo Graph Inc.

Privacy Policy

Company