Right way to use Spring WebClient in multi-thread environment

Question

I have one question regarding Spring Framework WebClient

In my application I need to do many similar API calls, sometimes I need to change headers in the calls (Authentication token). So the question arises, what would be better of the two options:

1. To create one WebClient for all incoming requests to MyService.class, by making it private final field, like code below:

private final WebClient webClient = WebClient.builder()
        .baseUrl("https://another_host.com/api/get_inf")
        .defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
        .defaultHeader(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE)
        .build();

Here arises another question: is WebClient thread-safe? (because service is used by many threads)

2. To create new WebClient for each new request incoming to service class.

---

I want to provide maximum performance and to use it in the right way, but I don't know how WebClient works inside it, and how it expects to be used.

Thank you.

Answer 1

Two key things here about WebClient:

1. Its HTTP resources (connections, caches, etc) are managed by the underlying library, referenced by the ClientHttpConnector that you can configure on the WebClient
2. WebClient is immutable

With that in mind, you should try to reuse the same ClientHttpConnector across your application, because this will share the connection pool - this is arguably the most important thing for performance. This means you should try to derive all WebClient instances from the same WebClient.create() call. Spring Boot helps you with that by creating and configuring for you a WebClient.Builder bean that you can inject anywhere in your app.

Because WebClient is immutable it is thread-safe. WebClient is meant to be used in a reactive environment, where nothing is tied to a particular thread (this doesn't mean you cannot use in a traditional Servlet application).

If you'd like to change the way requests are made, there are several ways to achieve that:

configure things in the builder phase

WebClient baseClient = WebClient.create()
                                .baseUrl("https://example.org");

configure things on a per-request basis

Mono<ClientResponse> response = baseClient.get()
                                          .uri("/resource")
                                          .header("token", "secret")
                                          .exchange();

create a new client instance out of an existing one

// mutate() will *copy* the builder state and create a new one out of it
WebClient authClient = baseClient.mutate()
                                 .defaultHeaders(hdrs -> {hdrs.add("token", "secret");})
                                 .build();

Answer 2

From my experience, if you are calling an external API on a server you have no control over, don't use WebClient at all, or use it with the pooling mechanism turned off. Any performance gains from connection pooling are greatly overweighed by the assumptions built into the (default reactor-netty) library that will cause random errors on one API call when another was abruptly terminated by the remote host, etc. In some cases, you don't even know where the error occurred because the calls are all made from a shared worker thread.

I made the mistake of using WebClient because the doc for RestTemplate said it would be deprecated in the future. In hindsight, I would go with regular HttpClient or Apache Commons HttpClient, but if you are like me and already implemented with WebClient, you can turn off the pooling by creating your WebClient as follows:

private WebClient createWebClient(int timeout) {
    TcpClient tcpClient = TcpClient.newConnection();
    HttpClient httpClient = HttpClient.from(tcpClient)
        .tcpConfiguration(client -> client.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, timeout * 1000)
            .doOnConnected(conn -> conn.addHandlerLast(new ReadTimeoutHandler(timeout))));

    return WebClient.builder()
        .clientConnector(new ReactorClientHttpConnector(httpClient))
        .build();
}

---

*** Creating a separate WebClient does not mean that WebClient will have a separate connection pool. Just look at the code for HttpClient.create - it calls HttpResources.get() to get the global resources. You could provide the pool settings manually but considering the errors that occur even with the default setup, I don't consider it worth the risk.