1. Overview

In this tutorial, we are going to show how to customize Spring’s WebClient – a reactive HTTP client – to log requests and responses.

2. WebClient

WebClient is a reactive and non-blocking interface for HTTP requests, based on Spring WebFlux. It has a functional, fluent API with reactive types for declarative composition.

Behind the scenes, WebClient calls an HTTP client. Reactor Netty is the default and reactive HttpClient of Jetty is also supported. Moreover, it’s possible to plug other implementations of HTTP client by setting up a ClientConnector for WebClient.

3. Logging Requests and Responses

The default HttpClient used by WebClient is the Netty implementation, so after we change the reactor.netty.http.client logging level to DEBUG, we can see some request logging, but if we need a customized log, we can configure our loggers via WebClient#filters:

  .filters(exchangeFilterFunctions -> {

In this code snippet, we’ve added two separate filters to log the request and the response.

Let’s implement logRequest by using ExchangeFilterFunction#ofRequestProcessor:

ExchangeFilterFunction logRequest() {
    return ExchangeFilterFunction.ofRequestProcessor(clientRequest -> {
        if (log.isDebugEnabled()) {
            StringBuilder sb = new StringBuilder("Request: \n");
            //append clientRequest method and url
              .forEach((name, values) -> values.forEach(value -> /* append header key/value */));
        return Mono.just(clientRequest);

logResponse is the same, but we have to use ExchangeFilterFunction#ofResponseProcessor instead.

Now we can change the reactor.netty.http.client log level to INFO or ERROR to have a cleaner output.

4. Logging Request and Response with Body

HTTP clients have features to log the bodies of requests and responses. Thus, to achieve the goal, we are going to use a log-enabled HTTP client with our WebClient.

We can do this by manually setting WebClient.Builder#clientConnector – let’s see with Jetty and Netty HTTP clients.

4.1. Logging with Jetty HttpClient

First, let’s add the Maven dependency for jetty-reactive-httpclient to our pom:


Then we’re going to create a customized Jetty HttpClient:

SslContextFactory.Client sslContextFactory = new SslContextFactory.Client();
HttpClient httpClient = new HttpClient(sslContextFactory) {
    public Request newRequest(URI uri) {
        Request request = super.newRequest(uri);
        return enhance(request);

Here, we’ve overridden HttpClient#newRequest, then wrapped the Request in a log enhancer.

Next, we need to register events with the request so that we can log as each part of the request becomes available:

Request enhance(Request request) {
    StringBuilder group = new StringBuilder();
    request.onRequestBegin(theRequest -> {
        // append request url and method to group
    request.onRequestHeaders(theRequest -> {
        for (HttpField header : theRequest.getHeaders()) {
            // append request headers to group
    request.onRequestContent((theRequest, content) -> {
        // append content to group
    request.onRequestSuccess(theRequest -> {
        group.delete(0, group.length());
    request.onResponseBegin(theResponse -> {
        // append response status to group
    request.onResponseHeaders(theResponse -> {
        for (HttpField header : theResponse.getHeaders()) {
            // append response headers to group
    request.onResponseContent((theResponse, content) -> {
        // append content to group
    request.onResponseSuccess(theResponse -> {
    return request;

Finally, we have to build the WebClient instance:

  .clientConnector(new JettyClientHttpConnector(httpClient))

Of course, as we did before, we’ll need to set the log level of RequestLogEnhancer to DEBUG.

4.2. Logging with Netty HttpClient

First, let’s create a Netty HttpClient:

HttpClient httpClient = HttpClient

Having enabled the wiretap, each request and response will be logged in full detail.

Next, we have to set the log level of Netty’s client package reactor.netty.http.client to DEBUG:


Now, let’s build the WebClient:

  .clientConnector(new ReactorClientHttpConnector(httpClient))

Our WebClient will log every request and response in full detail, but the default format of Netty built-in logger contains both Hex and Text representation of bodies and also a lot of data about request and response events.

So, if we need only the text logger for Netty, we can configure the HttpClient:

HttpClient httpClient = HttpClient
    LogLevel.DEBUG, AdvancedByteBufFormat.TEXTUAL);

5. Conclusion

In this tutorial, we’ve used several techniques for logging request and response data while using Spring WebClient.

As always the code is available over on GitHub.

Course – LS (cat=Spring)

Get started with Spring and Spring Boot, through the Learn Spring course:

res – Junit (guide) (cat=Reactive)
Inline Feedbacks
View all comments
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.