SpringCloud Alibaba 核心组件解析：服务网关

客户端请求
    │
    ▼
┌─────────────────────────────┐
│  Gateway (9528)              │
│  ┌─────────────────────────┐ │
│  │ SentinelGatewayFilter    │ │ ← 在这里拦截！超阈值直接拒绝
│  │ (网关层限流 QPS=2)       │ │
│  └─────────┬───────────────┘ │
│            │ 通过限流         │
└────────────┼────────────────┘
             ▼
┌─────────────────────────────┐
│  Provider (9001)             │
│  ┌─────────────────────────┐ │
│  │ @SentinelResource        │ │ ← 服务层精细化限流
│  └─────────────────────────┘ │
└─────────────────────────────┘

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<!-- Sentinel 适配 Gateway 的桥接包 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
</dependency>

server:
  port: 9528
spring:
  application:
    name: cloudalibaba-sentinel-gateway
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    gateway:
      routes:
        - id: pay_routh1
          uri: http://localhost:9001        # 直接转发到 Provider
          predicates:
            - Path=/pay/**
    sentinel:
      log:
        dir: D:/yangnan/Documents/SpringCloud/sentinel-log

// clooudalibaba-sentinel-gateway9528/.../config/GatewayConfiguration.java
@Configuration
public class GatewayConfiguration {
    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;
    public GatewayConfiguration(
            ObjectProvider<List<ViewResolver>> viewResolversProvider,
            ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }
    // ① 注册 Sentinel 异常处理器（最高优先级）
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(
            viewResolvers, serverCodecConfigurer);
    }
    // ② 注册 Sentinel 全局过滤器（Order=-1，低于上方的处理器，但高于其他过滤器）
    @Bean
    @Order(-1)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
    // ③ 应用启动后初始化规则
    @PostConstruct
    public void doInit() {
        initBlockHandler();
    }
    private void initBlockHandler() {
        // 网关流控规则：对路由 pay_routh1 限制每秒最多 2 个请求
        Set<GatewayFlowRule> rules = new HashSet<>();
        rules.add(new GatewayFlowRule("pay_routh1")
            .setCount(2)           // QPS 阈值
            .setIntervalSec(1));   // 统计间隔 1 秒
        GatewayRuleManager.loadRules(rules);
        // 自定义限流响应（返回 JSON 而不是默认 HTML）
        BlockRequestHandler handler = (exchange, t) -> {
            Map<String, String> map = new HashMap<>();
            map.put("errorCode",
                HttpStatus.TOO_MANY_REQUESTS.getReasonPhrase());
            map.put("errorMessage",
                "请求太过频繁，系统忙不过来，触发限流(sentinel+gateway整合Case)");
            return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS)
                .contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue(map));
        };
        GatewayCallbackManager.setBlockHandler(handler);
    }
}

{
    "errorCode": "Too Many Requests",
    "errorMessage": "请求太过频繁，系统忙不过来，触发限流(sentinel+gateway整合Case)"
}

请求到达 Gateway
    │
    ▼
SentinelGatewayFilter.doFilter()
    │
    ├→ 提取 routeId（如 "pay_routh1"）
    ├→ 匹配 GatewayFlowRule（QPS=2）
    ├→ 判断是否超阈值
    │
    ├→ 未超：chain.filter() → 转发到 Provider ✅
    └→ 超了：throw BlockException → BlockRequestHandler → 返回 JSON ❌