微服务架构下API网关的核心作用与Spring Cloud Gateway实践

1. 为什么需要API网关？从单体到微服务的演进

在传统单体架构中，应用通常作为一个整体部署运行，所有功能模块共享同一个代码库和数据库。这种架构下，客户端直接与单体应用通信，路由逻辑相对简单。但随着业务复杂度提升，单体架构逐渐暴露出扩展性差、技术栈单一、部署效率低等问题。

微服务架构通过将系统拆分为多个小型服务解决了这些问题，但同时也引入了新的挑战。想象一个电商系统被拆分为用户服务、商品服务、订单服务等独立模块后：

java复制// 客户端需要直接调用各个服务
String userServiceUrl = "http://user-service:8081";
String productServiceUrl = "http://product-service:8082";
String orderServiceUrl = "http://order-service:8083";

// 登录请求
Response loginResp = httpClient.post(userServiceUrl + "/login", credentials);

// 查询商品
Response productsResp = httpClient.get(productServiceUrl + "/products?category=electronics");

// 创建订单
Response orderResp = httpClient.post(orderServiceUrl + "/orders", orderData);

这种架构下至少存在六个显著问题：

1. 客户端复杂度高：需要维护所有服务的地址和调用逻辑
2. 重复的横切关注点：每个服务都需要独立实现认证、限流、日志等功能
3. 协议转换困难：不同服务可能使用不同协议（HTTP/gRPC/WebSocket）
4. 监控分散：难以统一收集和分析请求数据
5. 安全风险：每个服务都需要暴露公网访问
6. 客户端耦合：服务地址变更需要客户端同步更新

API网关正是为解决这些问题而生的架构模式。它作为系统的唯一入口，承担了以下核心职责：

• 路由转发：将请求智能路由到后端服务
• 协议转换：统一外部HTTP协议与内部各种协议
• 安全防护：集中处理认证、授权、防爬等
• 流量治理：实现限流、熔断、降级等策略
• 监控统计：统一收集请求指标和日志
• 缓存加速：对静态资源或查询结果进行缓存

实际案例：某电商平台在引入网关后，客户端代码量减少40%，认证逻辑维护成本降低70%，全局限流使系统稳定性提升90%

2. Spring Cloud Gateway核心架构解析

2.1 三大核心组件

Spring Cloud Gateway基于Reactor编程模型构建，其核心架构围绕以下三个概念展开：

1. 路由(Route)：定义请求如何转发的基本单元，包含：

   • 目标URI（可以是具体地址或服务名）
   • 断言条件集合（匹配规则）
   • 过滤器链（请求/响应处理）

2. 断言(Predicate)：Java 8的Predicate接口实现，决定请求是否匹配当前路由。支持：

   • 路径匹配（Path）
   • 方法匹配（Method）
   • 头部匹配（Header）
   • 时间窗口（Between/After/Before）
   • 自定义逻辑

3. 过滤器(Filter)：修改请求和响应的处理单元，分为：

   • 全局过滤器（GlobalFilter）：作用于所有路由
   • 路由过滤器（GatewayFilter）：作用于特定路由

java复制// 典型路由配置示例
spring:
  cloud:
    gateway:
      routes:
      - id: user-service
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        filters:
        - StripPrefix=1
        - AddRequestHeader=X-User-Type, member

2.2 核心工作原理

当请求到达网关时，处理流程如下：

1. 网关接收请求：通过Netty服务器接收HTTP请求
2. 路由匹配：遍历所有Route的Predicate，找到第一个匹配的路由
3. 过滤器链执行：
   • 前置过滤器处理请求（修改header、参数等）
   • 代理请求到目标服务
   • 后置过滤器处理响应
4. 返回响应：将处理后的响应返回客户端

mermaid复制sequenceDiagram
    participant C as Client
    participant G as Gateway
    participant S as Service
    
    C->>G: HTTP Request
    G->>G: Route Matching
    G->>G: Pre Filters
    G->>S: Forward Request
    S->>G: Service Response
    G->>G: Post Filters
    G->>C: HTTP Response

2.3 性能优化设计

Spring Cloud Gateway在性能方面做了多项优化：

1. 异步非阻塞：基于Netty和Reactor实现，单机可支持数万并发
2. 短路评估：路由断言采用短路逻辑，匹配即停止
3. 过滤器优化：过滤器链采用责任链模式，避免不必要的处理
4. 连接池：内置HTTP客户端连接池，减少TCP握手开销

实测对比（相同硬件环境）：

3. 生产级网关配置实战

3.1 基础项目搭建

使用Spring Initializr创建项目时，需选择以下依赖：

• Spring Boot 2.7.x
• Spring Cloud 2021.0.x
• Gateway
• LoadBalancer
• Nacos Discovery（或其他服务发现）

关键pom.xml配置：

xml复制<dependencies>
    <!-- 网关核心 -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    
    <!-- 服务发现 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    
    <!-- 健康检查 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
</dependencies>

3.2 路由配置详解

静态路由配置

yaml复制spring:
  cloud:
    gateway:
      routes:
      - id: legacy-system
        uri: http://old.example.com
        predicates:
        - Path=/legacy/**
        filters:
        - RewritePath=/legacy/(?<segment>.*), /v1/$\{segment}
        
      - id: websocket-route  
        uri: ws://chat-service:8080
        predicates:
        - Path=/ws/**

动态服务发现

yaml复制spring:
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          lower-case-service-id: true
          
      routes:
      - id: product-service
        uri: lb://product-service
        predicates:
        - Path=/api/products/**
        filters:
        - CircuitBreaker(name: productCB, fallbackUri: forward:/fallback/product)

权重路由

yaml复制      - id: canary-release
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        - Weight=user-service-canary, 10
      - id: user-service-primary  
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        - Weight=user-service-canary, 90

3.3 安全配置最佳实践

yaml复制spring:
  cloud:
    gateway:
      default-filters:
      - RemoveRequestHeader=Cookie,Set-Cookie  # 移除敏感头
      
      routes:
      - id: auth-service
        uri: lb://auth-service
        predicates:
        - Path=/oauth2/**
        filters:
        - TokenRelay  # OAuth2令牌中继

4. 高级过滤器开发实战

4.1 自定义全局过滤器

java复制@Slf4j
@Component
public class RateLimitFilter implements GlobalFilter, Ordered {
    
    private final RateLimiter rateLimiter;
    
    public RateLimitFilter() {
        this.rateLimiter = RateLimiter.create(1000); // 1000请求/秒
    }
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        if (!rateLimiter.tryAcquire()) {
            log.warn("Rate limit exceeded for {}", exchange.getRequest().getURI());
            exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }
    
    @Override
    public int getOrder() {
        return HIGHEST_PRECEDENCE + 100;
    }
}

4.2 JWT认证过滤器

java复制@Slf4j
@Component
public class JwtAuthFilter implements GlobalFilter {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getPath().value();
        
        // 跳过登录和公开接口
        if (path.startsWith("/auth/login") || path.startsWith("/public")) {
            return chain.filter(exchange);
        }
        
        // 获取并验证Token
        String token = extractToken(exchange.getRequest());
        if (token == null || !JwtUtil.validateToken(token)) {
            return unauthorized(exchange);
        }
        
        // 添加用户信息到请求
        String userId = JwtUtil.extractUserId(token);
        ServerHttpRequest mutatedRequest = exchange.getRequest().mutate()
                .header("X-User-Id", userId)
                .build();
                
        return chain.filter(exchange.mutate().request(mutatedRequest).build());
    }
    
    private String extractToken(ServerHttpRequest request) {
        // 从Header或Cookie提取token
    }
    
    private Mono<Void> unauthorized(ServerWebExchange exchange) {
        exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
        return exchange.getResponse().setComplete();
    }
}

5. 生产环境运维要点

5.1 监控指标配置

yaml复制management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,gateway
  metrics:
    tags:
      application: ${spring.application.name}

关键监控指标：

• http.server.requests：请求量统计
• gateway.requests：路由请求计数
• system.cpu.usage：CPU使用率
• jvm.memory.used：内存使用

5.2 高可用部署方案

推荐部署架构：

code复制                   +-----------------+
                   |   Load Balancer |
                   +--------+--------+
                            |
           +----------------+----------------+
           |                |                |
     +-----+------+   +-----+------+   +-----+------+
     | Gateway 1  |   | Gateway 2  |   | Gateway N  |
     +------------+   +------------+   +------------+

配置建议：

1. 至少部署3个网关实例
2. 使用Kubernetes Deployment或VM集群
3. 配置健康检查路径：/actuator/health
4. 设置合理的资源限制：

   yaml复制resources:
     limits:
       cpu: "2"
       memory: 2Gi
     requests:
       cpu: "0.5"
       memory: 1Gi
   

5.3 常见问题排查

问题1：路由不生效

检查步骤：

1. 确认网关已正确加载路由配置

   bash复制curl http://localhost:8888/actuator/gateway/routes
   

2. 检查断言条件是否过于严格
3. 验证目标服务是否健康

问题2：性能瓶颈

优化建议：

1. 增加过滤器order值，提前终止不必要处理
2. 限制路由数量（建议不超过100个）
3. 启用响应缓存：

   yaml复制spring:
     cloud:
       gateway:
         filter:
           cache:
             enabled: true
             size: 1000
             ttl: 60s
   

问题3：跨域配置无效

正确配置示例：

yaml复制spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':
            allowed-origins: "https://example.com"
            allowed-methods: "GET,POST"
            allowed-headers: "*"
            max-age: 3600

6. 性能调优实战

6.1 基准测试准备

使用wrk进行压力测试：

bash复制wrk -t12 -c400 -d30s http://gateway:8888/api/products

6.2 关键调优参数

配置示例：

yaml复制server:
  netty:
    max-initial-line-length: 8192
    
reactor:
  netty:
    io-worker-count: 8
    pool:
      max-connections: 1000
      
spring:
  cloud:
    gateway:
      metrics:
        enabled: true

6.3 实战调优案例

某金融系统网关调优前后对比：

关键优化措施：

1. 增加Netty工作线程数
2. 调整连接池大小
3. 优化路由匹配顺序（高频路由前置）
4. 添加响应缓存

7. 扩展开发与定制

7.1 自定义断言工厂

java复制@Component
public class MobilePredicateFactory extends AbstractRoutePredicateFactory<MobilePredicateFactory.Config> {
    
    public MobilePredicateFactory() {
        super(Config.class);
    }
    
    @Override
    public Predicate<ServerWebExchange> apply(Config config) {
        return exchange -> {
            String userAgent = exchange.getRequest()
                .getHeaders()
                .getFirst("User-Agent");
            return userAgent != null && 
                   userAgent.toLowerCase().contains("mobile");
        };
    }
    
    public static class Config {
        // 可配置参数
    }
}

使用方式：

yaml复制predicates:
- name: Mobile

7.2 自定义过滤器工厂

java复制@Component
public class LoggingFilterFactory extends AbstractGatewayFilterFactory<LoggingFilterFactory.Config> {
    
    @Override
    public GatewayFilter apply(Config config) {
        return (exchange, chain) -> {
            long start = System.currentTimeMillis();
            return chain.filter(exchange)
                .then(Mono.fromRunnable(() -> {
                    long duration = System.currentTimeMillis() - start;
                    log.info("{} {} - {}ms", 
                        exchange.getRequest().getMethod(),
                        exchange.getRequest().getURI(),
                        duration);
                }));
        };
    }
    
    public static class Config {
        // 可配置参数
    }
}

7.3 集成Sentinel限流

1. 添加依赖：

xml复制<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
</dependency>

2. 配置规则：

java复制@PostConstruct
public void initRules() {
    List<FlowRule> rules = new ArrayList<>();
    
    FlowRule rule = new FlowRule();
    rule.setResource("user-service");
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    rule.setCount(100);
    
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

8. 版本升级与迁移指南

8.1 从Spring Cloud Gateway 2.x升级到3.x

主要变更点：

1. 最低要求：

   • Spring Boot 2.6+
   • Java 17+

2. 废弃配置：

   yaml复制# 旧版
   spring.cloud.gateway.discovery.locator.enabled: true
   
   # 新版
   spring.cloud.gateway.discovery.locator.enabled: true
   spring.cloud.discovery.reactive.enabled: true
   

3. 新特性：

   • 支持gRPC路由
   • 改进的断路器集成
   • 增强的指标收集

8.2 从Zuul迁移

迁移步骤：

1. 替换依赖：

   xml复制<!-- 移除 -->
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-netflix-zuul</artifactId>
   </dependency>
   
   <!-- 添加 -->
   <dependency>
       <groupId>org.springframework.cloud</groupId>
       <artifactId>spring-cloud-starter-gateway</artifactId>
   </dependency>
   

2. 配置转换示例：

   yaml复制# Zuul配置
   zuul:
     routes:
       user-service:
         path: /users/**
         serviceId: user-service
   
   # Gateway等效配置
   spring:
     cloud:
       gateway:
         routes:
         - id: user-service
           uri: lb://user-service
           predicates:
           - Path=/users/**
   

3. 过滤器迁移：

   • Zuul的ZuulFilter → Gateway的GlobalFilter
   • 注意线程模型差异（Zuul阻塞 vs Gateway非阻塞）

9. 最佳实践总结

经过多个生产项目验证的黄金法则：

1. 路由设计原则

   • 按业务域划分路由，避免过度碎片化
   • 高频路由前置，提升匹配效率
   • 为每个路由添加明确ID和描述

2. 安全防护要点

   • 始终移除敏感请求头（Cookie, Authorization等）
   • 限制暴露的actuator端点
   • 启用HTTPS并配置HSTS

3. 性能优化清单

   • 合理设置连接池大小
   • 启用响应压缩

   yaml复制server:
     compression:
       enabled: true
       mime-types: text/html,text/xml,text/plain,application/json
   

   • 定期检查路由缓存命中率

4. 监控告警关键指标

   • 错误率（5xx响应占比）
   • 平均响应时间
   • 系统资源使用率
   • 限流触发次数

5. 灾难恢复策略

   • 配置多活网关集群
   • 准备静态降级路由

   yaml复制- id: fallback
     uri: http://fallback-service
     predicates:
     - Path=/fallback/**
     filters:
     - SetStatus=503
   

   • 定期演练故障切换

10. 常见问题深度解析

10.1 如何实现灰度发布？

方案一：基于Header的路由

yaml复制spring:
  cloud:
    gateway:
      routes:
      - id: canary-user-service
        uri: lb://user-service-v2
        predicates:
        - Path=/api/users/**
        - Header=X-Canary, true
      - id: primary-user-service  
        uri: lb://user-service-v1
        predicates:
        - Path=/api/users/**

方案二：基于权重的路由

yaml复制      - id: canary-20%
        uri: lb://user-service-v2
        predicates:
        - Path=/api/users/**
        - Weight=user-service, 20
      - id: primary-80%
        uri: lb://user-service-v1  
        predicates:
        - Path=/api/users/**
        - Weight=user-service, 80

10.2 大文件上传优化

问题：文件上传可能占用大量内存

解决方案：

1. 增加缓冲区大小

yaml复制spring:
  webflux:
    max-in-memory-size: 10MB  # 默认256KB

2. 使用磁盘缓存

java复制@Bean
public ServerCodecConfigurer serverCodecConfigurer() {
    return ServerCodecConfigurer.create()
            .defaultCodecs()
            .maxInMemorySize(10 * 1024 * 1024);
}

3. 添加超时配置

yaml复制spring:
  cloud:
    gateway:
      httpclient:
        connect-timeout: 5000
        response-timeout: 30s

10.3 WebSocket长连接管理

配置示例：

yaml复制spring:
  cloud:
    gateway:
      routes:
      - id: websocket-route
        uri: ws://chat-service:8080
        predicates:
        - Path=/ws/**
        filters:
        - StripPrefix=1

优化建议：

1. 调整心跳间隔

yaml复制spring:
  cloud:
    gateway:
      httpclient:
        websocket:
          ping-interval: 30s

2. 监控连接数

java复制@Bean
public MeterRegistryCustomizer<MeterRegistry> metrics() {
    return registry -> registry.config().commonTags("application", "gateway");
}

11. 未来演进方向

1. 服务网格集成：与Istio等Service Mesh方案协同工作
2. 云原生支持：更深度集成Kubernetes Ingress
3. 智能路由：基于ML的流量预测和动态路由
4. 协议扩展：增强gRPC、RSocket等协议支持
5. 边缘计算：支持边缘节点的网关部署模式

实际项目中的演进路径示例：

code复制Year 1: 基础路由 + 安全防护
Year 2: 全链路监控 + 智能限流  
Year 3: 多云架构支持 + 服务网格集成
Year 4: AI驱动的动态路由优化

12. 资源推荐与工具链

12.1 官方资源

• Spring Cloud Gateway文档
• GitHub仓库
• Samples项目

12.2 监控工具

1. Prometheus + Grafana监控看板
2. ELK日志分析系统
3. SkyWalking全链路追踪

12.3 测试工具

1. wrk：HTTP基准测试
2. JMeter：综合压力测试
3. Gatling：场景化负载测试

12.4 开发辅助

1. Postman：API调试
2. IntelliJ IDEA HTTP Client：集成测试
3. WireMock：后端服务模拟

13. 典型业务场景实现

13.1 电商系统网关设计

yaml复制spring:
  cloud:
    gateway:
      routes:
      # 用户服务
      - id: user-service
        uri: lb://user-service
        predicates:
        - Path=/api/users/**
        filters:
        - StripPrefix=1
        - CircuitBreaker(name: userCB, fallbackUri: forward:/fallback/user)
        
      # 商品服务  
      - id: product-service
        uri: lb://product-service
        predicates:
        - Path=/api/products/**
        filters:
        - StripPrefix=1
        - RequestRateLimiter(redis-rate-limiter.replenishRate=100)
        
      # 订单服务
      - id: order-service
        uri: lb://order-service
        predicates:
        - Path=/api/orders/**
        - Method=POST,PUT,DELETE
        filters:
        - StripPrefix=1
        - JwtAuth
        
      # 支付服务
      - id: payment-service
        uri: lb://payment-service
        predicates:
        - Path=/api/payments/**
        filters:
        - StripPrefix=1
        - SecureHeaders

13.2 物联网平台网关设计

yaml复制routes:
# 设备接入
- id: device-ingress
  uri: lb://device-service
  predicates:
  - Path=/device/telemetry/**
  filters:
  - DeviceAuth
  - MessageCompression
  
# 命令下发  
- id: command-delivery
  uri: lb://command-service
  predicates:
  - Path=/device/command/**
  filters:
  - JwtAuth
  - CommandValidation

# 规则引擎
- id: rule-engine
  uri: lb://rule-engine-service
  predicates:
  - Path=/rules/**
  filters:
  - StripPrefix=1

13.3 金融系统安全网关

java复制@Bean
public SecurityWebFilterChain securityFilterChain(ServerHttpSecurity http) {
    return http
        .authorizeExchange()
            .pathMatchers("/public/**").permitAll()
            .pathMatchers("/api/**").authenticated()
            .anyExchange().denyAll()
        .and()
        .oauth2ResourceServer()
            .jwt()
            .jwtAuthenticationConverter(jwtAuthConverter())
        .and()
        .csrf().disable()
        .build();
}

private Converter<Jwt, ? extends Mono<? extends AbstractAuthenticationToken>> jwtAuthConverter() {
    // 自定义JWT转换逻辑
}

14. 性能优化深度实践

14.1 线程模型调优

默认配置可能不匹配生产需求，建议调整：

yaml复制reactor:
  netty:
    io-worker-count: 16           # IO线程数 (通常CPU核心数*2)
    pool:
      max-connections: 1024       # 最大连接数
      acquire-timeout: 5000       # 连接获取超时(ms)
      
server:
  netty:
    max-initial-line-length: 8192 # 最大初始行长度
    max-header-size: 16KB         # 最大header大小

14.2 路由缓存优化

启用路由缓存提升性能：

yaml复制spring:
  cloud:
    gateway:
      route-definition-locator:
        cache:
          enabled: true
          initial-capacity: 50
          maximum-size: 100
          expire-after-write: 5m

14.3 响应式编程最佳实践

避免阻塞操作：

java复制// 错误示例 - 阻塞调用
Mono<String> result = Mono.fromCallable(() -> {
    return blockingHttpCall(); // 阻塞IO
}).subscribeOn(Schedulers.boundedElastic());

// 正确做法 - 使用非阻塞客户端
WebClient client = WebClient.create();
Mono<String> result = client.get()
    .uri("http://service/api")
    .retrieve()
    .bodyToMono(String.class);

14.4 内存泄漏防护

常见泄漏场景及解决方案：

1. 未释放网络资源：

   java复制// 确保所有Flux/Mono都有终止条件
   Flux.interval(Duration.ofSeconds(1))
       .take(10) // 必须有终止条件
       .subscribe();
   

2. 大对象缓存：

   java复制// 使用软引用缓存
   Cache<String, Object> cache = CacheBuilder.newBuilder()
       .softValues()
       .build();
   

3. 线程局部变量：

   java复制// 使用Context代替ThreadLocal
   Mono.deferContextual(ctx -> {
       String value = ctx.get("key");
       return Mono.just(value);
   });
   

15. 安全加固全方案

15.1 基础安全配置

yaml复制spring:
  cloud:
    gateway:
      httpclient:
        secure:
          ssl:
            use-insecure-trust-manager: false
            handshake-timeout: 10000
            close-notify-flush-timeout: 3000
            close-notify-read-timeout: 0

15.2 防注入攻击

java复制@Bean
public GlobalFilter sqlInjectionFilter() {
    return (exchange, chain) -> {
        String query = exchange.getRequest().getURI().getQuery();
        if (query != null && containsSqlInjection(query)) {
            exchange.getResponse().setStatusCode(HttpStatus.BAD_REQUEST);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    };
}

15.3 DDoS防护

集成Alibaba Anti-DDoS方案：

java复制@Bean
public GlobalFilter antiDDoSFilter() {
    return new GlobalFilter() {
        private final ConcurrentHashMap<String, AtomicInteger> counters = new ConcurrentHashMap<>();
        
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            String ip = getClientIp(exchange.getRequest());
            AtomicInteger counter = counters.computeIfAbsent(ip, k -> new AtomicInteger(0));
            
            if (counter.incrementAndGet() > 100) { // 100请求/秒
                exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
                return exchange.getResponse().setComplete();
            }
            
            return chain.filter(exchange)
                .doFinally(signal -> counter.decrementAndGet());
        }
    };
}

16. 微服务全链路设计

16.1 统一认证架构

code复制           +---------+       +---------+
           |  Client |       |   API   |
           +----+----+       +----+----+
                |                 |
                | 1. 请求(无token) |
                +----------------->
                |                 |
                | 2. 重定向到登录  |
                <-----------------+
                |                 |
+-------+ 3. 登录  +---------+     |
|  Auth +<-------->|  User   |     |
+---+---+          +---------+     |
    |                              |
    | 4. 颁发token                |
    +----------------------------->
                |                 |
                | 5. 携带token访问 |
                +----------------->
                |                 |
                | 6. 验证token    |
                |    +--------+   |
                +--->|  Gateway   |
                     +--------+

16.2 分布式追踪集成

1. 添加依赖：

xml复制<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

2. 配置示例：

yaml复制spring:
  sleuth:
    sampler:
      probability: 1.0
  zipkin:
    base-url: http://zipkin:9411

3. 日志增强：

java复制@Slf4j
@Component
public class TraceLogFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        Span span = exchange.getAttribute(Span.class.getName());
        log.info("TraceID: {}", span.context().traceId());
        return chain.filter(exchange);
    }
}

17. 异常处理艺术

17.1 统一异常处理

java复制@Bean
public ErrorWebExceptionHandler customExceptionHandler() {
    return new JsonExceptionHandler();
}

public class JsonExceptionHandler extends DefaultErrorWebExceptionHandler {
    
    @Override
    protected Mono<ServerResponse> renderErrorResponse(ServerRequest request) {
        Throwable error = getError(request);
        
        HttpStatus status = determineHttpStatus(error);
        String code = determineErrorCode(error);
        String message = determineMessage(error);
        
        Map<String, Object> body = Map.of(
            "timestamp", Instant.now(),
            "status", status.value(),
            "code", code,
            "message", message,
            "path", request.path()
        );
        
        return ServerResponse.status(status)
            .contentType(MediaType.APPLICATION_JSON)
            .bodyValue(body);
    }
    
    private HttpStatus determineHttpStatus(Throwable error) {
        if (error instanceof RateLimiterException) {
            return HttpStatus.TOO_MANY_REQUESTS;
        }
        // 其他异常处理...
        return HttpStatus.INTERNAL_SERVER_ERROR;
    }
}

17.2 熔断降级策略

yaml复制spring:
  cloud:
    gateway:
      routes:
      - id: product-service
        uri: lb://product-service
        predicates:
        - Path=/api/products/**
        filters:
        - name: CircuitBreaker
          args:
            name: productCB
            fallbackUri: forward:/fallback/product
            statusCodes: 500,502,503,504

降级控制器示例：

java复制@RestController
public class FallbackController {
    
    @GetMapping("/fallback/product")
    public Mono<Map<String, Object>> productFallback() {
        return Mono.just(Map.of(
            "status", 503,
            "message", "服务暂时不可用，请稍后重试",
            "timestamp", Instant.now()
        ));
    }
}

18. 自动化部署方案

18.1 Kubernetes部署文件

yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
  name: gateway
spec:
  replicas: 3
  selector:
    matchLabels:
      app: gateway
  template:
    metadata:
      labels:
        app: gateway
    spec:
      containers:
      - name: gateway
        image: registry.example.com/gateway:1.0.0
        ports:
        - containerPort: 8888
        resources:
          limits:
            cpu: "2"
            memory: 2Gi
          requests:
            cpu: "0.5"
            memory: 1Gi
        livenessProbe:
          httpGet:
            path: /actuator/health
            port: 8888
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /actuator/health
            port: 8888
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: gateway
spec:
  selector:
    app: gateway
  ports:
  - protocol: TCP
    port: 80
    targetPort: 8888
  type: LoadBalancer

18.2 CI/CD流水线示例

yaml复制# .gitlab-ci.yml
stages:
  - build
  - test
  - deploy

build:
  stage: build
  image: maven:3.8.4-jdk-11
  script:
    - mvn clean package -DskipTests
  artifacts:
    paths:
      - target/*.jar

test:
  stage: test
  image: maven:3.8.4-jdk-11
  script:
    - mvn test
    - mvn sonar:sonar -Dsonar.host.url=$SONAR_URL

deploy:
  stage: deploy
  image: kubectl:1.22
  script:
    - kubectl set image deployment/gateway gateway=$CI_REGISTRY_IMAGE:$CI_COMMIT_SHA
    - kubectl rollout status deployment/gate