Java.lang.illegalstateexception: block()/blockfirst()/blocklast() are blocking, which is not supported in thread reactor-http-nio-3

When you encounter the “java.lang.IllegalStateException: block()/blockFirst()/blockLast() are blocking, which is not supported in thread reactor-http-nio-3” exception, it generally means that you are using a blocking operation in a non-blocking environment.

In reactive programming, the reactor-http-nio-3 thread is part of the Reactor Netty framework, which is designed to work in a non-blocking manner. The thread is responsible for handling HTTP requests and responses. However, certain methods like block(), blockFirst(), and blockLast() are blocking operations that go against the non-blocking nature of Reactor Netty, hence the exception.

To resolve this issue, you need to refactor your code to use non-blocking alternatives provided by Reactor Netty. Instead of blocking operations, you should embrace the reactive programming model and utilize the asynchronous capabilities of Reactor Netty, such as using Mono or Flux with operators like map, flatMap, or subscribe.

Here is an example to help illustrate the concept. Suppose you have a blocking operation like retrieving data from a remote service, represented by a hypothetical getRemoteData() method. You might be tempted to block the thread to wait for the response:

    // Blocking operation example
    public String fetchRemoteData() {
        String result = WebClient.create().get().uri("http://example.com/data").exchange()
                .flatMap(response -> response.bodyToMono(String.class))
                .block(); // blocking operation

        return result;
    }
  

However, this is not the recommended approach. Instead, you should rewrite the code using the non-blocking nature of Reactor Netty. For example, you can return a Mono to represent the reactive result:

    // Non-blocking operation example
    public Mono fetchRemoteDataNonBlocking() {
        return WebClient.create().get().uri("http://example.com/data").exchange()
                .flatMap(response -> response.bodyToMono(String.class));
    }

    // Usage example
    fetchRemoteDataNonBlocking().subscribe(result -> {
        // Process the result asynchronously
    });
  

By returning a Mono and subscribing to it, you allow the Reactor Netty framework to handle the operation asynchronously without blocking the reactor-http-nio-3 thread.

Remember, always check the API documentation of the specific library or framework you’re using to understand the recommended non-blocking approaches and available asynchronous alternatives that suit your needs.