三層微服務的 JWT 分層認證：每個邊界都用自己的 Token

Channel（Web-Backend）         ← 獨立服務，有自己的前端與業務邏輯
    ↓ 呼叫
Traffic-Controller             ┐
    ↓ 轉發                     ├── 強耦合，同機部署
Query-API                      ┘

其他上游系統 A ────────────────┐
其他上游系統 B ────────────────┤→ Traffic-Controller → Query-API
其他上游系統 C ────────────────┘

上游系統 A（用自己的 JWT）
    ↓ 轉換成 Query-API JWT
Query-API 驗 Query-API JWT ← 只要維護一套驗證邏輯

上游系統 B（用自己的 JWT）
    ↓ 轉換成 Query-API JWT
Query-API 驗 Query-API JWT ← 同一套，不需要改

前端 / 外部平台
      ↓ Channel JWT (HS512)
Channel（Web-Backend）  ← 獨立服務，自己管自己的認證
      ↓ FeignClientInterceptor 轉換成 Query-API JWT
Traffic-Controller      ← 透傳（不驗、只 log）
      ↓
Query-API ──── 來自各上游系統 → @JwtValidation（Query-API JWT）
         └──── 外部直接呼叫  → @ExternalJwtValidation（External JWT）

@Override
public void apply(RequestTemplate template) {
    Optional<RequestAttributes> attrs =
        Optional.ofNullable(RequestContextHolder.getRequestAttributes());

    attrs.ifPresent(a -> {
        HttpServletRequest request = (HttpServletRequest)
            a.resolveReference(RequestAttributes.REFERENCE_REQUEST);

        String authorization = request.getHeader("Authorization");

        String data, profile;
        if (authorization != null) {
            // 從 Channel JWT 解出業務身份
            data = channelJwtUtil.extractData(authorization);
            profile = channelJwtUtil.extractProfile(authorization);
        } else {
            data = "Invalid data";
            profile = "Invalid profile";
        }

        // 用 queryApiSecret 重新簽發
        String queryApiJwt = queryApiJwtUtil.generateToken(data, profile);

        template.header("Authorization", "Bearer " + queryApiJwt);
        template.header("x-core-transactionid", UUID.randomUUID().toString());
        template.header("x-core-traceid", UUID.randomUUID().toString());
    });
}

// ChannelJwtUtil.java（Channel 側）
public String generateToken(String data, String profile,
                             Boolean isDarkMode, String channelCode) {
    return Jwts.builder()
        .claim("data", data)
        .claim("profile", profile)
        .claim("isDarkMode", isDarkMode)
        .claim("channelCode", channelCode)
        .setIssuedAt(new Date())
        .setExpiration(new Date(System.currentTimeMillis() + channelExpiration))
        .signWith(Keys.hmacShaKeyFor(channelSecret.getBytes()), SignatureAlgorithm.HS512)
        .compact();
}

@Override
public boolean preHandle(HttpServletRequest request,
                          HttpServletResponse response,
                          Object handler) throws Exception {
    if (handler instanceof HandlerMethod method) {
        if (method.hasMethodAnnotation(JwtValidation.class)) {
            String token = request.getHeader("Authorization");
            if (!channelJwtUtil.isValid(token)) {
                response.sendError(HttpStatus.UNAUTHORIZED.value(), "Invalid token");
                return false;
            }
        }
    }
    return true;
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface JwtValidation {}        // 上游服務路徑（Query-API JWT）

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ExternalJwtValidation {}  // 外部直接呼叫路徑

@PostMapping("/get-asset-overview/v1")
@JwtValidation                            // ← 只接受 Query-API JWT
public RestInternalResponseWrapper<GetAssetOverviewResponse> getAssetOverview(...) { ... }

@PostMapping("/external/get-asset-summary/v1")
@ExternalJwtValidation                    // ← 只接受 External JWT
public RestInternalResponseWrapper<GetAssetSummaryResponse> getAssetSummaryExternal(...) { ... }

@Override
public boolean preHandle(HttpServletRequest request,
                          HttpServletResponse response,
                          Object handler) throws Exception {
    if (handler instanceof HandlerMethod method) {
        String token = request.getHeader("Authorization");

        if (method.hasMethodAnnotation(JwtValidation.class)) {
            if (!queryApiJwtUtil.isValid(token)) {
                response.sendError(401, "Invalid Query-API token");
                return false;
            }
        } else if (method.hasMethodAnnotation(ExternalJwtValidation.class)) {
            if (!externalApiJwtUtil.isValid(token)) {
                response.sendError(401, "Invalid External token");
                return false;
            }
        }

        enrichRequestAttributes(request, token, method);
    }
    return true;
}

前端請求 (Authorization: Bearer <channel-jwt>)
    ↓
Channel RequestInterceptor
    @JwtValidation → channelJwtUtil.isValid()
    ↓
FeignClientInterceptor（Channel 側的職責）
    channelJwtUtil.extractData/Profile()
    queryApiJwtUtil.generateToken()
    → Authorization: Bearer <query-api-jwt>
    ↓
Traffic-Controller (WebFlux)
    reactiveJwtUtil.extractData/Profile() → debug log only
    透傳 Authorization header
    ↓
Query-API RequestInterceptor
    @JwtValidation → queryApiJwtUtil.isValid()
    解析 claims → 補入 access log