三層微服務中的流量控制器：WebFlux 反向代理設計與 OpenFeign JWT 轉換

Web-Backend（Channel 層）
    ↓ OpenFeign
Traffic-Controller（流量控制層）
    ↓ WebClient (reactive)
Query-API（核心業務層）
    ↓
Oracle + Redis Cluster

# traffic-controller application.yml
rate-limit-proxy-webflux:
  proxy:
    host: localhost   # 同機 Query-API
    port: 8080

傳統 Spring MVC：
  一請求 → 一執行緒 → 等待下游回應（執行緒阻塞）
  400 並發請求 → 需要 400+ 執行緒

WebFlux (Netty)：
  請求到達 → 非阻塞發出，事件循環繼續接收下一個
  400 並發請求 → CPU 核心數 × 2 個工作執行緒

@RestController
@RequestMapping("/api")
public class RateLimitProxyController {

    @Value("${rate-limit-proxy-webflux.proxy.host}")
    private String proxyHost;

    @Value("${rate-limit-proxy-webflux.proxy.port}")
    private int proxyPort;

    @PostMapping(value = "**")  // 萬用路由，攔截所有 /api/** 路徑
    public Mono<Object> forwardRequestWithJwt(
            ServerWebExchange exchange,
            @RequestBody Flux<Map<String, Object>> requestBody) {

        HttpHeaders originalHeaders = exchange.getRequest().getHeaders();

        // Transaction ID：優先取 header，沒有就自動生成
        Mono<String> transactionIdMono = Mono
            .justOrEmpty(originalHeaders.getFirst("x-core-transactionid"))
            .switchIfEmpty(Mono.fromSupplier(() -> UUID.randomUUID().toString()));

        Mono<String> traceIdMono = Mono
            .justOrEmpty(originalHeaders.getFirst("x-core-traceid"))
            .switchIfEmpty(Mono.fromSupplier(() -> UUID.randomUUID().toString()));

        WebClient webClient = WebClient.builder()
            .baseUrl("http://" + proxyHost + ":" + proxyPort)
            .codecs(c -> c.defaultCodecs().maxInMemorySize(16 * 1024 * 1024))
            .build();

        return Mono.zip(transactionIdMono, traceIdMono)
            .flatMap(tuple -> {
                String txId = tuple.getT1();
                String traceId = tuple.getT2();

                return requestBody.collectList()
                    .flatMap(body -> {
                        // JWT 驗證（非阻塞，與轉發請求並行執行）
                        Mono<Void> jwtValidationMono = Mono
                            .justOrEmpty(exchange.getRequest().getHeaders()
                                .getFirst("Authorization"))
                            .flatMap(token -> Mono.zip(
                                reactiveJwtUtil.extractData(token)
                                    .onErrorResume(e -> Mono.empty()),
                                reactiveJwtUtil.extractProfile(token)
                                    .onErrorResume(e -> Mono.empty())
                            ))
                            .then();

                        // 轉發請求到 Query-API
                        Mono<Object> proxyMono = webClient
                            .post()
                            .uri(exchange.getRequest().getURI().getPath())  // 原路徑不變
                            .headers(h -> {
                                h.addAll(originalHeaders);
                                h.set("x-core-transactionid", txId);
                                h.set("x-core-traceid", traceId);
                            })
                            .bodyValue(body.get(0))
                            .retrieve()
                            .bodyToMono(Object.class);

                        // JWT 驗證與代理請求並行，返回代理結果
                        return Mono.zip(jwtValidationMono, proxyMono)
                            .map(Tuple2::getT2);
                    });
            });
    }
}

@Component
public class ReactiveJwtUtil {

    // ❌ 錯誤做法：直接在 Mono 裡做 CPU 密集工作
    public Mono<String> extractData_WRONG(String token) {
        return Mono.just(parseJwt(token));  // 會阻塞事件循環
    }

    // ✅ 正確做法：切換到彈性執行緒池
    public Mono<String> extractData(String token) {
        return Mono.fromCallable(() -> {
            String jwt = token.replace("Bearer ", "");
            Claims claims = Jwts.parserBuilder()
                .setSigningKey(jwtSecret.getBytes())
                .build()
                .parseClaimsJws(jwt)
                .getBody();
            return claims.get("data", String.class);
        }).subscribeOn(Schedulers.boundedElastic());  // 在獨立執行緒池執行
    }
}

Web-Backend Controller
    ↓ assetFeignClient.getAssetTrend(request)
FeignClientInterceptor.apply()
    ↓ Web-Backend JWT → Query-API JWT，補 Transaction ID
HTTP POST → localhost:8083/api/asset/query-api/...
    ↓
Traffic-Controller (WebFlux)
    ↓ 驗證 JWT，限流檢查，生成/透傳 Trace ID
WebClient POST → localhost:8080/api/asset/query-api/...
    ↓
Query-API (Spring MVC)
    ↓ 驗證 Query-API JWT
業務邏輯 → Caffeine 快取 → Redis/Oracle
    ↓
Response 沿原路返回

reactor.core.Exceptions$OverflowException: Could not emit tick

// 加上緩衝區
return requestBody
    .onBackpressureBuffer(1000)
    .collectList()
    .flatMap(body -> ...);

DataBufferLimitException: Exceeded limit on max bytes to buffer : 262144

webClient = WebClient.builder()
    .codecs(c -> c.defaultCodecs().maxInMemorySize(16 * 1024 * 1024))  // 16MB
    .build();

spring:
  codec:
    max-in-memory-size: 16MB