客戶端 → Spring Cloud Gateway → 微服務(wù)A
                             → 微服務(wù)B  
                             → 微服務(wù)C

客戶端 → 網(wǎng)關(guān)層（Authentication） → 業(yè)務(wù)服務(wù)層（Authorization）
         ↓                          ↓
    驗證"你是誰"                驗證"你能做什么"
    Token有效性驗證             業(yè)務(wù)權(quán)限驗證
    基礎(chǔ)安全防護(hù)               數(shù)據(jù)權(quán)限控制

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
        <relativePath/>
    </parent>
    <groupId>com.example</groupId>
    <artifactId>spring-cloud-gateway-demo</artifactId>
    <version>1.0.0</version>
    <name>spring-cloud-gateway-demo</name>
    <properties>
        <java.version>11</java.version>
        <spring-cloud.version>2021.0.3</spring-cloud.version>
    </properties>
    <dependencies>
        <!-- Spring Cloud Gateway 核心依賴 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!-- 服務(wù)發(fā)現(xiàn)客戶端（用于集成注冊中心） -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-loadbalancer</artifactId>
        </dependency>
        <!-- Actuator 監(jiān)控端點(diǎn) -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!-- Redis 依賴（用于限流） -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

server:
  port: 9000  # 網(wǎng)關(guān)服務(wù)端口
spring:
  application:
    name: api-gateway  # 應(yīng)用名稱
  cloud:
    gateway:
      # 全局跨域配置
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "*"      # 允許所有源
            allowedMethods: "*"      # 允許所有HTTP方法
            allowedHeaders: "*"      # 允許所有請求頭
            allowCredentials: true   # 允許攜帶憑證
      # 路由配置
      routes:
        # 用戶服務(wù)路由 - 網(wǎng)關(guān)只負(fù)責(zé)路由和基礎(chǔ)認(rèn)證
        - id: user-service-route
          uri: http://localhost:8081
          predicates:
            - Path=/api/users/**     # 匹配用戶相關(guān)路徑
          filters:
            - StripPrefix=2          # 去掉 /api/users 前綴，實際轉(zhuǎn)發(fā)到 /**
        # 訂單服務(wù)路由
        - id: order-service-route
          uri: http://localhost:8082
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=2
# Actuator 監(jiān)控配置
management:
  endpoints:
    web:
      exposure:
        include: '*'               # 暴露所有監(jiān)控端點(diǎn)
  endpoint:
    gateway:
      enabled: true                # 啟用網(wǎng)關(guān)管理端點(diǎn)

package com.example.gateway.config;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 網(wǎng)關(guān)路由配置類
 * 使用 Java 代碼方式配置路由，相比配置文件更加靈活
 * 注意：這里只配置路由規(guī)則，不包含業(yè)務(wù)權(quán)限邏輯
 */
@Configuration
public class GatewayRouteConfig {
    /**
     * 配置自定義路由規(guī)則
     * @param builder RouteLocatorBuilder 用于構(gòu)建路由
     * @return RouteLocator 路由定位器
     */
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 用戶服務(wù)路由
                .route("user-service", r -> r
                        .path("/api/users/**")           // 匹配路徑
                        .uri("http://localhost:8081")    // 目標(biāo)服務(wù)地址
                        .filters(f -> f.stripPrefix(2))  // 去掉前兩個路徑段 (/api/users)
                )
                // 訂單服務(wù)路由
                .route("order-service", r -> r
                        .path("/api/orders/**")
                        .uri("http://localhost:8082")
                        .filters(f -> f.stripPrefix(2))
                )
                // 公開API路由（無需認(rèn)證）
                .route("public-api", r -> r
                        .path("/api/public/**")
                        .uri("http://localhost:8083")
                        .filters(f -> f.stripPrefix(2))
                )
                .build();
    }
}

package com.example.gateway.config;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 各種斷言使用示例
 * 斷言用于定義路由匹配條件，只有滿足條件的請求才會被路由
 * 這些都是基礎(chǔ)的路由條件，不涉及業(yè)務(wù)邏輯
 */
@Configuration
public class PredicateConfig {
    @Bean
    public RouteLocator predicateRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 1. Path 斷言：基于URL路徑匹配
                .route("path-route", r -> r
                        .path("/api/v1/**", "/api/v2/**")  // 支持多個路徑模式
                        .uri("http://localhost:8081")
                )
                // 2. Method 斷言：基于HTTP方法匹配
                .route("method-route", r -> r
                        .path("/api/method/**")
                        .and()
                        .method("GET", "POST")  // 只匹配GET和POST請求
                        .uri("http://localhost:8082")
                )
                // 3. Header 斷言：基于請求頭匹配
                .route("header-route", r -> r
                        .path("/api/header/**")
                        .and()
                        .header("X-API-Version", "v1")  // 必須包含指定請求頭
                        .uri("http://localhost:8083")
                )
                // 4. Query 斷言：基于查詢參數(shù)匹配
                .route("query-route", r -> r
                        .path("/api/query/**")
                        .and()
                        .query("version", "1.0")  // 查詢參數(shù) version=1.0
                        .uri("http://localhost:8084")
                )
                // 5. Host 斷言：基于Host頭匹配
                .route("host-route", r -> r
                        .host("api.example.com", "api.test.com")  // 匹配指定域名
                        .uri("http://localhost:8085")
                )
                .build();
    }
}

package com.example.gateway.config;
import org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * 內(nèi)置過濾器使用示例
 * 過濾器用于修改請求和響應(yīng)，但只做基礎(chǔ)處理，不涉及業(yè)務(wù)邏輯
 */
@Configuration
public class FilterConfig {
    @Bean
    public RouteLocator filterRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                // 1. 添加請求頭過濾器
                .route("add-header-route", r -> r
                        .path("/api/add-header/**")
                        .filters(f -> f
                                // 添加網(wǎng)關(guān)來源標(biāo)識
                                .addRequestHeader("X-Gateway-Source", "spring-cloud-gateway")
                                // 添加請求時間戳
                                .addRequestHeader("X-Request-Timestamp", 
                                    String.valueOf(System.currentTimeMillis()))
                        )
                        .uri("http://localhost:8081")
                )
                // 2. 添加響應(yīng)頭過濾器
                .route("add-response-header-route", r -> r
                        .path("/api/add-response-header/**")
                        .filters(f -> f
                                .addResponseHeader("X-Gateway-Processed", "true")
                        )
                        .uri("http://localhost:8082")
                )
                // 3. 路徑重寫過濾器
                .route("strip-prefix-route", r -> r
                        .path("/api/strip/**")
                        .filters(f -> f.stripPrefix(1))  // 去掉第一個路徑段
                        .uri("http://localhost:8083")
                )
                // 4. 限流過濾器（使用Redis）
                .route("rate-limiter-route", r -> r
                        .path("/api/rate-limiter/**")
                        .filters(f -> f
                                .requestRateLimiter()
                                .rateLimiter(RedisRateLimiter.class)
                                // 配置限流參數(shù)：每秒5個請求，突發(fā)容量10個
                                .configure(c -> c.setBurstCapacity(10).setReplenishRate(5))
                        )
                        .uri("http://localhost:8084")
                )
                // 5. 重試過濾器
                .route("retry-route", r -> r
                        .path("/api/retry/**")
                        .filters(f -> f.retry(3))  // 失敗時重試3次
                        .uri("http://localhost:8085")
                )
                .build();
    }
}

package com.example.gateway.filter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;
/**
 * 網(wǎng)關(guān)認(rèn)證過濾器 - 只負(fù)責(zé)身份認(rèn)證，不負(fù)責(zé)權(quán)限授權(quán)
 * 
 * 職責(zé)范圍：
 * ? 驗證JWT Token的有效性（簽名、過期時間）
 * ? 驗證Token的基本格式
 * ? 將用戶信息傳遞給下游服務(wù)
 * ? 不進(jìn)行業(yè)務(wù)權(quán)限驗證
 * ? 不調(diào)用業(yè)務(wù)數(shù)據(jù)庫
 * ? 不處理復(fù)雜的業(yè)務(wù)邏輯
 */
@Component
public class AuthenticationGlobalFilter implements GlobalFilter, Ordered {
    // 公開路徑列表（無需認(rèn)證的路徑）
    private static final List<String> PUBLIC_PATHS = Arrays.asList(
        "/api/public/**",
        "/api/auth/login",
        "/api/auth/register",
        "/actuator/**"
    );
    /**
     * 全局過濾器執(zhí)行邏輯
     * @param exchange 當(dāng)前請求交換對象
     * @param chain 過濾器鏈
     * @return Mono<Void> 響應(yīng)式返回
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String requestPath = exchange.getRequest().getURI().getPath();
        // 1. 檢查是否為公開路徑，如果是則直接放行
        if (isPublicPath(requestPath)) {
            return chain.filter(exchange);
        }
        // 2. 從請求頭中提取認(rèn)證令牌
        String token = extractToken(exchange);
        if (token == null || token.isEmpty()) {
            return handleUnauthorized(exchange, "Missing authentication token");
        }
        try {
            // 3. 驗證令牌有效性（只驗證簽名和過期時間，不驗證業(yè)務(wù)權(quán)限）
            if (!validateTokenSignatureAndExpiry(token)) {
                return handleUnauthorized(exchange, "Invalid or expired token");
            }
            // 4. 從令牌中提取用戶基本信息
            String userId = extractUserIdFromToken(token);
            String userRoles = extractUserRolesFromToken(token);
            // 5. 將用戶信息添加到請求頭，傳遞給下游業(yè)務(wù)服務(wù)
            // 下游服務(wù)將基于這些信息進(jìn)行具體的權(quán)限驗證
            ServerHttpRequest modifiedRequest = exchange.getRequest().mutate()
                    .header("X-User-Id", userId)
                    .header("X-User-Roles", userRoles)
                    .header("X-Authenticated", "true")
                    .build();
            return chain.filter(exchange.mutate().request(modifiedRequest).build());
        } catch (Exception e) {
            return handleUnauthorized(exchange, "Authentication processing failed: " + e.getMessage());
        }
    }
    /**
     * 判斷路徑是否為公開路徑
     * @param path 請求路徑
     * @return 是否為公開路徑
     */
    private boolean isPublicPath(String path) {
        return PUBLIC_PATHS.stream()
                .anyMatch(publicPath -> path.matches(publicPath.replace("**", ".*")));
    }
    /**
     * 從請求中提取認(rèn)證令牌
     * 支持 Bearer Token 和自定義 Header
     */
    private String extractToken(ServerWebExchange exchange) {
        // 優(yōu)先從 Authorization 頭獲取
        String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            return authHeader.substring(7); // 去掉 "Bearer " 前綴
        }
        // 也可以從自定義頭或查詢參數(shù)獲取
        String tokenHeader = exchange.getRequest().getHeaders().getFirst("X-API-Token");
        if (tokenHeader != null) {
            return tokenHeader;
        }
        return null;
    }
    /**
     * 驗證令牌簽名和過期時間
     * 注意：這里只做基礎(chǔ)驗證，不做業(yè)務(wù)權(quán)限驗證
     */
    private boolean validateTokenSignatureAndExpiry(String token) {
        // 實際項目中應(yīng)該使用 JWT 庫進(jìn)行驗證
        // 這里簡化處理，實際應(yīng)該驗證簽名、過期時間等
        try {
            // 偽代碼：驗證 JWT 簽名和過期時間
            // Jwts.parser().setSigningKey(secret).parseClaimsJws(token);
            return token.length() > 20; // 簡單驗證
        } catch (Exception e) {
            return false;
        }
    }
    /**
     * 從令牌中提取用戶ID
     * 實際項目中應(yīng)該解析 JWT payload
     */
    private String extractUserIdFromToken(String token) {
        // 偽代碼：從 JWT 中提取用戶ID
        return "user123"; // 簡化處理
    }
    /**
     * 從令牌中提取用戶角色
     * 實際項目中應(yīng)該解析 JWT payload 中的角色信息
     */
    private String extractUserRolesFromToken(String token) {
        // 偽代碼：從 JWT 中提取角色
        return "USER,PREMIUM"; // 簡化處理
    }
    /**
     * 處理未授權(quán)請求
     */
    private Mono<Void> handleUnauthorized(ServerWebExchange exchange, String message) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        exchange.getResponse().getHeaders().add("Content-Type", "application/json");
        String response = "{\"error\":\"Unauthorized\",\"message\":\"" + message + "\"}";
        return exchange.getResponse().writeWith(
            Mono.just(exchange.getResponse().bufferFactory().wrap(response.getBytes()))
        );
    }
    /**
     * 設(shè)置過濾器執(zhí)行順序
     * 數(shù)值越小，優(yōu)先級越高
     */
    @Override
    public int getOrder() {
        return -100; // 在很早的階段執(zhí)行認(rèn)證
    }
}

// 用戶服務(wù)中的權(quán)限控制示例
package com.example.userservice.controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.server.ResponseStatusException;
import org.springframework.http.HttpStatus;
/**
 * 用戶控制器 - 在業(yè)務(wù)服務(wù)中進(jìn)行真正的權(quán)限驗證
 * 
 * 網(wǎng)關(guān)已經(jīng)完成了身份認(rèn)證，這里進(jìn)行業(yè)務(wù)級別的權(quán)限授權(quán)
 */
@RestController
@RequestMapping("/api")
public class UserController {
    /**
     * 獲取用戶詳情
     * 需要驗證當(dāng)前用戶是否有權(quán)限訪問目標(biāo)用戶
     */
    @GetMapping("/users/{userId}")
    public User getUser(@RequestHeader("X-User-Id") String currentUserId,
                       @RequestHeader("X-User-Roles") String userRoles,
                       @PathVariable String userId) {
        // 1. 驗證是否是訪問自己的信息（普通用戶只能訪問自己）
        if (!currentUserId.equals(userId)) {
            // 2. 如果不是訪問自己，檢查是否具有管理員角色
            if (!userRoles.contains("ADMIN")) {
                throw new ResponseStatusException(HttpStatus.FORBIDDEN, 
                    "Insufficient permissions to access this user data");
            }
        }
        // 3. 執(zhí)行業(yè)務(wù)邏輯
        return userService.findById(userId);
    }
    /**
     * 刪除用戶 - 需要管理員權(quán)限
     * 使用 Spring Security 注解進(jìn)行權(quán)限控制
     */
    @PreAuthorize("hasRole('ADMIN')")
    @DeleteMapping("/users/{userId}")
    public void deleteUser(@PathVariable String userId) {
        userService.delete(userId);
    }
}

package com.example.gateway.filter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.time.LocalDateTime;
/**
 * 訪問日志全局過濾器
 * 記錄請求的基本信息，用于監(jiān)控和審計
 * 注意：只記錄基礎(chǔ)信息，不記錄敏感業(yè)務(wù)數(shù)據(jù)
 */
@Component
public class AccessLogGlobalFilter implements GlobalFilter, Ordered {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 記錄請求開始時間
        long startTime = System.currentTimeMillis();
        String path = exchange.getRequest().getURI().getPath();
        String method = exchange.getRequest().getMethodValue();
        String clientIp = getClientIp(exchange);
        System.out.println(String.format(
            "[ACCESS-LOG] %s | %s | %s | %s", 
            LocalDateTime.now(), method, path, clientIp
        ));
        // 繼續(xù)處理請求，并記錄響應(yīng)時間
        return chain.filter(exchange).doOnTerminate(() -> {
            long duration = System.currentTimeMillis() - startTime;
            System.out.println(String.format(
                "[ACCESS-LOG] Response time: %d ms for %s", duration, path
            ));
        });
    }
    private String getClientIp(ServerWebExchange exchange) {
        String xForwardedFor = exchange.getRequest().getHeaders().getFirst("X-Forwarded-For");
        if (xForwardedFor != null && !xForwardedFor.isEmpty()) {
            return xForwardedFor.split(",")[0].trim();
        }
        return exchange.getRequest().getRemoteAddress() != null ? 
               exchange.getRequest().getRemoteAddress().getAddress().getHostAddress() : "unknown";
    }
    @Override
    public int getOrder() {
        return Ordered.LOWEST_PRECEDENCE - 1; // 在最后執(zhí)行，確保能獲取到完整信息
    }
}

package com.example.gateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
/**
 * Spring Cloud Gateway 網(wǎng)關(guān)啟動類
 * 
 * 設(shè)計原則：
 * ? 網(wǎng)關(guān)只負(fù)責(zé)：路由轉(zhuǎn)發(fā)、身份認(rèn)證、基礎(chǔ)安全、監(jiān)控日志
 * ? 網(wǎng)關(guān)不負(fù)責(zé)：業(yè)務(wù)權(quán)限、業(yè)務(wù)邏輯、數(shù)據(jù)驗證
 * 
 * 啟動后可用端點(diǎn)：
 * - 網(wǎng)關(guān)服務(wù)：http://localhost:9000
 * - 路由信息：http://localhost:9000/actuator/gateway/routes
 * - 健康檢查：http://localhost:9000/actuator/health
 */
@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
        System.out.println("=====================================");
        System.out.println("Spring Cloud Gateway 啟動成功！");
        System.out.println("網(wǎng)關(guān)地址: http://localhost:9000");
        System.out.println("路由管理: http://localhost:9000/actuator/gateway/routes");
        System.out.println("=====================================");
    }
}