API Gateway with Spring Cloud Gateway

//CatalogApp.java
package com.javabrahman.cloud.gateway.catalog;

import jakarta.servlet.http.HttpServletRequest;
import java.util.LinkedHashMap;
import java.util.Map;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class CatalogApp {

  @GetMapping("/books/{isbn}")
  Map<String, Object> book(@PathVariable String isbn, HttpServletRequest request) {
    Map<String, Object> book = new LinkedHashMap<>();
    book.put("isbn", isbn);
    book.put("title", "Effective Java");
    book.put("receivedPath", request.getRequestURI());
    book.put("receivedSourceHeader", request.getHeader("X-Request-Source"));
    return book;
  }

  @GetMapping("/authors/{id}")
  Map<String, Object> author(@PathVariable int id) {
    return Map.of("id", id, "name", "Joshua Bloch");
  }

  public static void main(String[] args) {
    SpringApplication.run(CatalogApp.class, args);
  }
}

//OrderApp.java
package com.javabrahman.cloud.gateway.order;

import java.util.Map;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class OrderApp {

  @GetMapping("/orders/{id}")
  Map<String, Object> order(@PathVariable int id) {
    return Map.of("id", id, "status", "SHIPPED");
  }

  public static void main(String[] args) {
    SpringApplication.run(OrderApp.class, args);
  }
}

server:
  port: 8080
spring:
  application:
    name: gateway
  cloud:
    gateway:
      server:
        webflux:
          routes:
            - id: catalog
              uri: http://localhost:8081
              predicates:
                - Path=/api/books/**
              filters:
                - StripPrefix=1
                - AddRequestHeader=X-Request-Source, gateway
                - AddResponseHeader=X-Served-By, catalog-service
            - id: orders
              uri: http://localhost:8082
              predicates:
                - Path=/api/orders/**
                - Method=GET
              filters:
                - RewritePath=/api/orders/(?<id>.*), /orders/$\{id}
            - id: reviews
              uri: http://localhost:8083
              predicates:
                - Path=/api/reviews/**
              filters:
                - StripPrefix=1
                - name: CircuitBreaker
                  args:
                    name: reviews
                    fallbackUri: forward:/fallback/reviews
logging:
  level:
    com.javabrahman: INFO

//GatewayApp.java
package com.javabrahman.cloud.gateway.edge;

import java.util.List;
import java.util.Map;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GatewayApp {

  @Bean
  RouteLocator javaRoutes(RouteLocatorBuilder builder) {
    return builder.routes()
        .route("authors", route -> route
            .path("/api/authors/**")
            .filters(filters -> filters
                .stripPrefix(1)
                .addResponseHeader("X-Route", "defined-in-java"))
            .uri("http://localhost:8081"))
        .build();
  }

  // where the reviews route is forwarded to when the review service fails
  @GetMapping("/fallback/reviews")
  Map<String, Object> reviewsFallback() {
    return Map.of("reviews", List.of(), "note", "Reviews are not available right now");
  }

  public static void main(String[] args) {
    SpringApplication.run(GatewayApp.class, args);
  }
}

//RequestLogFilter.java
package com.javabrahman.cloud.gateway.edge;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class RequestLogFilter implements GlobalFilter, Ordered {

  private static final Logger log = LoggerFactory.getLogger(RequestLogFilter.class);

  @Override
  public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    long start = System.nanoTime();
    String request = exchange.getRequest().getMethod() + " " + exchange.getRequest().getPath();
    // everything before chain.filter() runs before the request is forwarded ("pre"),
    // everything in then() runs after the response has come back ("post")
    return chain.filter(exchange).then(Mono.fromRunnable(() -> {
      Route route = exchange.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
      long millis = (System.nanoTime() - start) / 1_000_000;
      log.info("{} -> route {} -> status {} in {} ms", request,
          route != null ? route.getId() : "none", exchange.getResponse().getStatusCode().value(), millis);
    }));
  }

  @Override
  public int getOrder() {
    return Ordered.HIGHEST_PRECEDENCE;   // outermost: sees the request first and the response last
  }
}