REST APIs with Spring MVC and WebFlux

@GetMapping("/{id}/items/{itemId}")
public OrderItem findItem(@PathVariable Long id, @PathVariable("itemId") Long itemId) {
    return orderService.findItem(id, itemId);
}

@GetMapping(produces = MediaType.APPLICATION_JSON_VALUE)
public List<OrderSummary> findAll(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "20") int size,
        @RequestHeader("X-Client-Id") String clientId) {
    return orderService.findPage(page, size, clientId);
}

@GetMapping
public List<OrderSummary> list(@RequestParam(required = false) String cursor,
                                @RequestParam(defaultValue = "20") int size) {
    return orderService.findAfter(cursor, size);
}

@RestControllerAdvice
public class ApiExceptionHandler {

    @ExceptionHandler(OrderNotFoundException.class)
    public ResponseEntity<ProblemDetail> handleNotFound(OrderNotFoundException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(HttpStatus.NOT_FOUND, ex.getMessage());
        problem.setTitle("Order not found");
        problem.setProperty("orderId", ex.getOrderId());
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(problem);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ProblemDetail> handleValidation(MethodArgumentNotValidException ex) {
        ProblemDetail problem = ProblemDetail.forStatus(HttpStatus.BAD_REQUEST);
        problem.setTitle("Validation failed");
        List<String> errors = ex.getBindingResult().getFieldErrors().stream()
                .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
                .toList();
        problem.setProperty("errors", errors);
        return ResponseEntity.badRequest().body(problem);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ProblemDetail> handleUnexpected(Exception ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.INTERNAL_SERVER_ERROR, "An unexpected error occurred");
        return ResponseEntity.internalServerError().body(problem);
    }
}

spring:
  mvc:
    problemdetails:
      enabled: true

@RestController
@RequestMapping("/api/orders")
public class ReactiveOrderController {

    private final ReactiveOrderService orderService;

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

    @GetMapping
    public Flux<OrderSummary> findAll() {
        return orderService.findAll();
    }

    @GetMapping("/{id}")
    public Mono<ResponseEntity<OrderDetail>> findOne(@PathVariable Long id) {
        return orderService.findById(id)
                .map(ResponseEntity::ok)
                .defaultIfEmpty(ResponseEntity.notFound().build());
    }

    @PostMapping
    public Mono<ResponseEntity<OrderDetail>> create(@Valid @RequestBody Mono<CreateOrderRequest> request) {
        return request
                .flatMap(orderService::create)
                .map(created -> ResponseEntity.created(URI.create("/api/orders/" + created.id())).body(created));
    }
}

@Configuration
public class OrderRoutes {

    @Bean
    public RouterFunction<ServerResponse> orderRoutes(OrderHandler handler) {
        return RouterFunctions.route()
                .GET("/api/orders", handler::findAll)
                .GET("/api/orders/{id}", handler::findOne)
                .POST("/api/orders", handler::create)
                .build();
    }
}

@Component
public class OrderHandler {

    private final ReactiveOrderService orderService;

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

    public Mono<ServerResponse> findAll(ServerRequest request) {
        return ServerResponse.ok().body(orderService.findAll(), OrderSummary.class);
    }

    public Mono<ServerResponse> findOne(ServerRequest request) {
        Long id = Long.valueOf(request.pathVariable("id"));
        return orderService.findById(id)
                .flatMap(order -> ServerResponse.ok().bodyValue(order))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    public Mono<ServerResponse> create(ServerRequest request) {
        return request.bodyToMono(CreateOrderRequest.class)
                .flatMap(orderService::create)
                .flatMap(created -> ServerResponse
                        .created(URI.create("/api/orders/" + created.id()))
                        .bodyValue(created));
    }
}

@RestController
@RequestMapping("/api/orders")
@CrossOrigin(origins = "https://app.example.com")            // applies to every handler below
public class OrderController {

    @GetMapping("/{id}")
    public OrderView get(@PathVariable Long id) { /* ... */ }

    @PostMapping
    @CrossOrigin(                                            // narrower override for one handler
            origins = { "https://app.example.com", "https://admin.example.com" },
            methods = RequestMethod.POST,
            allowedHeaders = { "Content-Type", "Authorization" },
            maxAge = 600)
    public ResponseEntity<Void> create(@Valid @RequestBody CreateOrder body) { /* ... */ }
}

@Configuration
public class CorsConfig implements WebMvcConfigurer {

    private final CorsProperties props;   // @ConfigurationProperties("app.cors")

    public CorsConfig(CorsProperties props) {
        this.props = props;
    }

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/api/**")
                .allowedOrigins(props.allowedOrigins().toArray(String[]::new))
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("Content-Type", "Authorization")
                .allowCredentials(true)
                .maxAge(600);
    }
}