Spring MVC와 WebFlux는 언제 다르게 선택해야 할까요?

package com.example.order;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping("/orders/{id}")
    public OrderResponse findOrder(@PathVariable long id) {
        return orderService.findOrder(id);
    }
}

package com.example.order;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Mono;

@RestController
public class ReactiveOrderController {

    private final ReactiveOrderService orderService;

    public ReactiveOrderController(ReactiveOrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping("/orders/{id}")
    public Mono<OrderResponse> findOrder(@PathVariable long id) {
        return orderService.findOrder(id);
    }
}

@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    public OrderResponse findOrder(long id) {
        Order order = orderRepository.findById(id)
                .orElseThrow(() -> new OrderNotFoundException(id));

        return new OrderResponse(order.id(), order.status(), order.createdAt());
    }
}

@Service
public class OrderViewService {

    private final OrderClient orderClient;
    private final DeliveryClient deliveryClient;
    private final PointClient pointClient;

    public OrderViewService(
            OrderClient orderClient,
            DeliveryClient deliveryClient,
            PointClient pointClient
    ) {
        this.orderClient = orderClient;
        this.deliveryClient = deliveryClient;
        this.pointClient = pointClient;
    }

    public Mono<OrderViewResponse> findOrderView(long orderId) {
        Mono<OrderResponse> order = orderClient.findOrder(orderId);
        Mono<DeliveryResponse> delivery = deliveryClient.findDelivery(orderId);
        Mono<PointResponse> points = pointClient.findPoints(orderId);

        return Mono.zip(order, delivery, points)
                .map(tuple -> new OrderViewResponse(
                        tuple.getT1(),
                        tuple.getT2(),
                        tuple.getT3()
                ));
    }
}

@GetMapping("/orders/{id}")
public Mono<OrderResponse> findOrder(@PathVariable long id) {
    return Mono.just(orderRepository.findById(id)
            .map(OrderResponse::from)
            .orElseThrow(() -> new OrderNotFoundException(id)));
}

@GetMapping("/orders/{id}")
public Mono<OrderResponse> findOrder(@PathVariable long id) {
    return Mono.fromCallable(() -> orderRepository.findById(id)
                    .map(OrderResponse::from)
                    .orElseThrow(() -> new OrderNotFoundException(id)))
            .subscribeOn(Schedulers.boundedElastic());
}

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-webmvc"
}

dependencies {
    implementation "org.springframework.boot:spring-boot-starter-webflux"
}

@Service
public class ShipmentLookupService {

    private final WebClient webClient;

    public ShipmentLookupService(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder
                .baseUrl("https://shipment.example")
                .build();
    }

    public ShipmentResponse findShipment(long orderId) {
        return webClient.get()
                .uri("/shipments/{orderId}", orderId)
                .retrieve()
                .bodyToMono(ShipmentResponse.class)
                .block();
    }
}

// WebFlux handler 안에서는 이런 모양을 피해야 해요.
ShipmentResponse shipment = webClient.get()
        .uri("/shipments/{orderId}", orderId)
        .retrieve()
        .bodyToMono(ShipmentResponse.class)
        .block();

public Mono<ShipmentResponse> findShipment(long orderId) {
    return webClient.get()
            .uri("/shipments/{orderId}", orderId)
            .retrieve()
            .bodyToMono(ShipmentResponse.class);
}

@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void findOrder() throws Exception {
        mockMvc.perform(get("/orders/1"))
                .andExpect(status().isOk())
                .andExpect(jsonPath("$.id").value(1));
    }
}

@WebFluxTest(ReactiveOrderController.class)
class ReactiveOrderControllerTest {

    @Autowired
    private WebTestClient webTestClient;

    @Test
    void findOrder() {
        webTestClient.get()
                .uri("/orders/1")
                .exchange()
                .expectStatus().isOk()
                .expectBody()
                .jsonPath("$.id").isEqualTo(1);
    }
}