비동기 답은?

				System.out.println(webClient.get() //1
                .uri("/mail/test")
                .retrieve()
                .bodyToMono(String.class)
                .subscribe(s -> System.out.println("s = " + s))); //2
        System.out.println("\"HI!!\" = " + "HI!!"); //3
Java
복사

출력 순서는?

1 → 3 → 2!

Mono vs Flux

•

Mono 는 0~1 개의 데이터를 전달하고 Flux 는 0~N 개의 데이터를 전달한다.

@Test
public void givenFluxPublisher_whenSubscribeThenReturnMultipleValuesWithError() {
    Flux<String> stringFlux = Flux.just("Hello", "Baeldung", "Error")
      .map(str -> {
          if (str.equals("Error"))
              throw new RuntimeException("Throwing Error");
          return str;
      });
    StepVerifier.create(stringFlux)
      .expectNext("Hello")
      .expectNext("Baeldung")
      .expectError()
      .verify();
}
Java
복사

•

이에 대해서는 추후에 더 공부해보자

block vs subscribe

•

Mono 나 Flux 로 바꾼 다음 요청을 보낼 때 사용한다.

•

block 은 블로킹, subscribe 는 논블로킹이다.

•

subscribe 는 논블로킹으로 처리되어 응답이 오면 응답에 대해 추후 처리가 가능하다.

block 이 가능하다면 feign 과의 차이는 무엇일까?

The key difference between the Feign client's blocking approach and the WebClient's block() method is in their underlying mechanisms and programming models:

Programming Model:

•

Feign: Feign is a declarative HTTP client that allows you to define interfaces with annotated methods representing remote service endpoints. It uses a blocking I/O model, where each request is executed synchronously, blocking the calling thread until the response is received or an error occurs.

•

WebClient: WebClient is a non-blocking, reactive HTTP client that provides a functional and fluent API for making HTTP requests. By default, it operates in a non-blocking manner using reactive programming, but you can use the block() method to temporarily switch to a blocking mode.

Thread Model:

•

Feign: Feign uses a blocking I/O model, where the calling thread is blocked until the response is received. This means that the thread is occupied and cannot perform other tasks during the blocking period.

•

WebClient with block(): The block() method in WebClient allows you to temporarily switch to a blocking mode and block the calling thread until the response is received. However, the underlying WebClient itself still operates in a non-blocking manner and does not block threads outside of the block() call.

Reactiveness:

•

Feign: Feign does not natively support reactive programming. It operates synchronously and is not designed for reactive applications.

•

WebClient with block(): WebClient, when used with the block() method, can be used in reactive applications with a mix of reactive and blocking code. However, it's important to note that using block() introduces blocking behavior, which can impact the responsiveness and scalability of reactive systems. It should be used judiciously and with caution.

In summary, Feign is a blocking HTTP client with a synchronous programming model, while WebClient is a non-blocking, reactive HTTP client by default. The block() method in WebClient allows you to temporarily switch to a blocking mode, but it does not fundamentally change the non-blocking nature of WebClient itself.

When working in a reactive environment, it's generally recommended to embrace the non-blocking nature of WebClient and utilize reactive programming constructs instead of relying heavily on the block() method. However, there may be scenarios where using block() is necessary, such as when integrating with legacy code or when dealing with specific blocking dependencies.