需要帮助理解反应式 Mono/Flux 类

Question

I am writing a Java application and attempting to use a Spring WebFlux WebClient to make calls to a REST API. I just started using this library and have practically no experience with "reactive" programming. I'm having a hard time understanding how the Mono and Flux classes work and are used. What little I understand at this point, these classes allow asynchronous operations with some sort of data source (eg a remote web service). Everything in WebFlux seems to deal with either a Mono or Flux object.

My biggest question/confusion at this point is, if they allow for async processing, how do we bridge between the async process and the process that kicked it off? My most recent experience (about 10 years ago) with this type of processing involved Executor s and Future s. It took me some time to get the hang of those as well. (I've also forgotten much of it.)

Here's some of the code I've written, to try to help illustrate what I'm getting at.

@Service
public class GitLabService2 {
  @Autowired
  private WebClient     webClient;
    
  public Flux<String> getGroupByName(String name) {
    Flux<String> result = webClient.get()
      .uri("/groups?search=" + name)
      .accept(MediaType.APPLICATION_JSON)
      .exchangeToFlux(resp -> {
        if (!resp.statusCode().isError()) {
          return resp.bodyToFlux(String.class);
        } else {
          return resp.createException().flatMapMany(Flux::error);
        }
      });
    
    return result;
  }

  public Flux<String> getAllProjectsForGroup(String name) {
    Flux<String> gf = getGroupByName(name);
    int groupID = 0;
    
    gf.subscribe(json -> {
      if (JacksonJsonConverter.isList(json)) {
        List<JsonNode> list = JacksonJsonConverter.convertToObjectList(json);
        // This is the ID of the group I need to use below. However, I can't get it out of this lambda.
        // (Getting info out of lambdas is a separate topic that keeps causing me pain.)
        int groupID = list.get(0).get("id").asInt(); 
      }
    });
    
    Flux<String> result = webClient.get()
      // This is where I need to use the groupID I get above, but can't access it.
      .uri("/groups/" + groupID + "/projects")
      .accept(MediaType.APPLICATION_JSON)
      .exchangeToFlux(resp -> {
        if (!resp.statusCode().isError()) {
          return resp.bodyToFlux(String.class);
        } else {
          return resp.createException().flatMapMany(Flux::error);
        }
      });
    
    return result;
  }
    
}

Here is code that uses the code above.

  private void getAllProjectsForGroup() {
    Flux<String> result = service.getAllProjectsForGroup("test");

    result.subscribe(jsonStr -> {
      // Do things with the JSON data ...
    });
  }

I'm not seeing the asynchronicity in these mechanisms. Won't this still block while waiting for the Mono or Flux object to "do its thing"? Wouldn't I need to involve a thread or executor or some similar mechanism? I don't understand how this works, or how to properly use it.

I would think that "subscribing" to the Mono or Flux means that I may receive a response at some future time (granted, it could be just a few milliseconds). Does that mean that the subscribe() call does not block?

I've searched and read from a lot of what I've found, but it's still not clear to me. It seems like there is a critical piece of information that's missing.

I think I'm also having a hard time understanding how to properly deal with the situation (like in the service getAllProjectsForGroup() method above) where I get a piece of information within a lambda expression (I think anonymous classes also suffer from this issue) and need to use it "outside". Perhaps this needs to be asked as a separate topic.

Answer 1

Basically reactive/future like objects such as these, including standard java objects like CompletableFuture, force you to use them in the entire chain from controller to service. They are a task running in some other thread. So your controller returns a Mono, and calls your service which returns a mono... and you get it. Each task completion starts the next.

So you have two options afaik, either refactor getAllProjectsForGroup to return a Mono/Flux too, or use a blocking operation (big no for me), such as Mono.block(), to convert it to synchronous code, but wasting a thread, and basically make reactive code pointless