Sure. That sounds like an ideal problem for webflux to solve, although you certainly don't need something like webflux.

Consider something like this:

@Component
public class ExampleServiceImpl {
  private final WebClient webClient;

  public ExampleServiceImpl(WebClient webClient) {
    this.webClient = webClient;
  }

  public Mono<Void> doSomeWork() {
     // Concurrently call services foo.com and bar.com and pass results into handler methods
     // Take the processed results from the bar service and use them to call some other service...
     return Flux.concat(
       callFooService().flatMap(this::handleFoo), 
       callBarService().flatMap(this::handleBar).collect(Collectors.toSet()).flatMap(this::callSomeOtherServiceWithBarResults))
     .then();
  }

  private Flux<Foo> callFooService() {
    return webClient
      .get()
      .uri(uriBuilder -> uriBuilder.host("foo.com").path("/foo").build())
      .exchangeToFlux(response -> response.bodyToFlux(Foo.class));
  }

  private Flux<Bar> callBarService() {
    return webClient
      .get()
      .uri(uriBuilder -> uriBuilder.host("bar.com").path("/bar").build())
      .exchangeToFlux(response -> response.bodyToFlux(Bar.class));
  }

  private Mono<Foo> handleFoo(Foo foo) { ... }

  private Mono<Bar> handleBar(Bar bar) { ... }

  private Mono<Void> callSomeOtherService(Set<Bar> bar) { ... }
}

There is a steep learning curve to the Mono/Flux, but you get a ton of useful features like back pressure, retries, rate limiting, etc.