Spring WebFlux: Refactoring blocking API with Reactive API, or should I?

user_1660256 0
Viewed 263

I have a legacy Spring Boot REST app that interacts with downstream services that block. I'm new to reactive programming, and am unsure how to handle these blocking requests. Most Webflux examples I've seen are pretty trivial. Here's the flow-of-control of my app:

  1. User queries MyApp at http://myapp.com
  2. MyApp then queries partner REST API, which is BLOCKING.
  3. Depending on account type, data from the blocking app needs to be queried to make another call to another blocking REST application.
  4. All data is enriched and rendered by MyApp to the browser.

Where to start? I'm using WebClient currently, so that part's done. I know I should perform the blocking steps on a different scheduler (parallel or boundedElastic?) Should I use a Flux or Mono, since the partner APIs return the data all at once?

Both apps return thousands of rows of data, and the user just waits... Steps 1-2 take about 4 secs; add in step 3, and we're looking at over 30 seconds due to the inefficiency of the API. Can Flux help my users' wait time at all?

EDIT Below is a (long) example of what my application is doing. Notice that I block my first call to the API to get a count of what's being returned, then I fetch the rest in batches of TASK_QUERY_LIMIT.

@Bean
public WebClient authWebClient(WebClient.Builder builder) {
    MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
    map.set(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);

    final int size = 48 * 1024 * 1024;
    final ExchangeStrategies strategies = ExchangeStrategies.builder()
            .codecs(codecs -> codecs.defaultCodecs().maxInMemorySize(size))
            .build();

    return builder.baseUrl(configProperties.getUrl())
            .exchangeStrategies(strategies)
            .defaultHeaders(httpHeaders -> httpHeaders.addAll(map))
            .filters(exchangeFilterFunctions -> {
                exchangeFilterFunctions.add(logResponseStatus());
                exchangeFilterFunctions.add(logRequest());
            })
            .build();
}

public Mono<Task> getTasksMono() {
    return getAuthWebClient()
            .baseUrl("http://MyApp.com")
            .accept(MediaType.APPLICATION_JSON)
            .retrieve()
            .onStatus(HttpStatus::isError, this::onHttpStatusError)
            .bodyToMono(new ParameterizedTypeReference<Response<Task>>() {}));
}
            
// Service method
public List<Task> getTasksMono() {
    Mono<Response<Task>> monoTasks = getTasksMono();
    Task tasks = monoTasks.block();
    int taskCount = tasks.getCount();
    List<Task> returnTasks = new ArrayList<>(tasks.getData());

    List<Mono<<Task>> tasksMonoList = new ArrayList<>();
    // query API-ONE for all remaining tasks
    if (taskCount > TASK_QUERY_LIMIT) {
        retrieveAdditionalTasks(key, taskCount, tasksMonoList);
    }

    // Send out all of the calls at once, and subscribe to their results.
    Flux.mergeSequential(tasksMonoList)
            .map(Response::getData)
            .doOnNext(returnTasks::addAll)
            .blockLast();

    return returnTasks.stream()
            .map(this::transform) // This method performs business logic on the data before returning to user
            .collect(Collectors.toList());
    
}

private void retrieveAdditionalTasks(String key, int taskCount,
                                     List<Mono<Response<Task>>> tasksMonoList) {

    int offset = TASK_QUERY_LIMIT;
    int numRequests = (taskCount - offset) / TASK_QUERY_LIMIT + 1;

    for (int i = 0; i < numRequests; i++) {
        tasksMonoList.add(getTasksMono(processDefinitionKey, encryptedIacToken,
                TASK_QUERY_LIMIT, offset));
        offset += TASK_QUERY_LIMIT;
    }
}
project-reactor spring-webflux spring-boot
1 Answers

There are multiple questions here. Will try to highlight main points

1. Does it make sense refactoring to Reactive API?


From the first look your application is IO bound and typically reactive applications are much more efficient because all IO operations are async and non-blocking. Reactive application will not be faster but you will need less resources to The only caveat is that in order to get all benefits from the reactive API, your app should be reactive end-to-end (reactive drivers for DB, reactive WebClient, …). All reactive logic is executed on Schedulers.parallel() and you need small number of threads (by default, number of CPU cores) to execute non-blocking logic. It’s still possible use blocking API by “offloading” them to Schedulers.boundedElastic() but it should be an exception (not the rule) to make your app efficient. For more details, check Flight of the Flux 3 - Hopping Threads and Schedulers.

2. Blocking vs non-blocking.


It looks like there is some misunderstanding of the blocking API. It’s not about response time but about underlining API. By default, Spring WebFlux uses Reactor Netty as underlying Http Client library which itself is a reactive implementation of Netty client that uses Event Loop instead of Thread Per Request model. Even if request takes 30-60 sec to get response, thread will not be blocked because all IO operations are async. For such API reactive applications will behave much better because for non-reactive (thread per request) you would need large number of threads and as result much more memory to handle the same workload.

To quantify efficiency we could apply Little's Law to calculate required number of threads in a ”traditional” thread per request model

workers >= throughput x latency, where workers - number of threads

For example, to handle 100 QPS with 30 sec latency we would need 100 x 30 = 3000 threads. In reactive app the same workload could be handled by several threads only and, as result, much less memory. For scalability it means that for IO bound reactive apps you would typically scale by CPU usage and for “traditional” most probably by memory.

Sometimes it's not obvious what code is blocking. One very useful tool while testing reactive code is BlockHound that you could integrate into unit tests.

3. How to refactor?

I would migrate layer by layer but block only once. Moving remote calls to WebClient could be a first step to refactor app to reactive API. I would create all request/response logic using reactive API and then block (if required) at the very top level (e.g. in controller). Do’s and Don’ts: Avoiding First-Time Reactive Programmer Mines is a great overview of the common pitfalls and possible migration strategy.

4. Flux vs Mono.

Flux will not help you to improve performance. It’s more about downstream logic. If you process record-by-record - use Flux<T> but if you process data in batches - use Mono<List<T>>.

Your current code is not really reactive and very hard to understand mixing reactive API, stream API and blocking multiple times. As a first step try to rewrite it as a single flow using reactive API and block only once.

Not really sure about your internal types but here is some skeleton that could give you an idea about the flow.

// Service method
public Flux<Task> getTasks() {
    return getTasksMono()
            .flatMapMany(response -> {
                List<Mono<Response<Task>>> taskRequests = new ArrayList<>();
                taskRequests.add(Mono.just(response));

                if (response.getCount() > TASK_QUERY_LIMIT) {
                    retrieveAdditionalTasks(key, response.getCount(), taskRequests);
                }

                return Flux.mergeSequential(taskRequests);
            })
            .flatMapIterable(Response::getData)
            .map(this::transform); // use flatMap in case transform is async
}

As I mentioned before, try to keep internal API reactive returning Mono or Flux and block only once in the upper layer.

user_90688950
Related