// 流量治理的现实比喻
public class TrafficGovernanceAnalogy {
    
    /**
     * 城市交通系统 vs 流量治理系统
     */
    public class TrafficSystemComparison {
        // 交通信号灯 → 限流控制
        // 高速公路收费站 → 熔断降级
        // GPS导航系统 → 负载均衡
        // 交通警察 → 流量监控
        // 应急车道 → 服务降级
    }
    
    /**
     * 没有流量治理的后果
     */
    public class WithoutTrafficGovernance {
        // 1. 雪崩效应：一个服务故障导致整个系统崩溃
        // 2. 资源耗尽：突发流量耗尽系统资源
        // 3. 响应延迟：服务过载导致响应变慢
        // 4. 数据不一致：重试机制不当导致数据错乱
    }
}

<!-- pom.xml Sentinel依赖 -->
<dependencies>
    <!-- Sentinel Starter -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        <version>2022.0.0.0</version>
    </dependency>
    
    <!-- Sentinel Datasource Nacos -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
        <version>1.8.6</version>
    </dependency>
    
    <!-- Spring Boot Actuator -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    
    <!-- Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!-- AOP -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
</dependencies>

# application.yml Sentinel配置
spring:
  application:
    name: order-service
  cloud:
    sentinel:
      enabled: true
      eager: true
      transport:
        dashboard: 192.168.1.100:8080  # Sentinel控制台地址
        port: 8719                     # 本地启动HTTP Server端口
      datasource:
        # 流控规则数据源
        flow:
          nacos:
            server-addr: 192.168.1.100:8848
            dataId: ${spring.application.name}-flow-rules
            groupId: SENTINEL_GROUP
            rule-type: flow
        # 降级规则数据源
        degrade:
          nacos:
            server-addr: 192.168.1.100:8848
            dataId: ${spring.application.name}-degrade-rules
            groupId: SENTINEL_GROUP
            rule-type: degrade
        # 系统规则数据源
        system:
          nacos:
            server-addr: 192.168.1.100:8848
            dataId: ${spring.application.name}-system-rules
            groupId: SENTINEL_GROUP
            rule-type: system
        # 授权规则数据源
        authority:
          nacos:
            server-addr: 192.168.1.100:8848
            dataId: ${spring.application.name}-authority-rules
            groupId: SENTINEL_GROUP
            rule-type: authority
# 监控端点
management:
  endpoints:
    web:
      exposure:
        include: sentinel
  endpoint:
    sentinel:
      enabled: true
# 日志配置
logging:
  level:
    com.alibaba.csp.sentinel: DEBUG

// 订单服务限流控制
@RestController
@RequestMapping("/orders")
@Slf4j
public class OrderController {
    
    @Autowired
    private OrderService orderService;
    
    /**
     * 创建订单 - 资源名限流
     */
    @PostMapping
    @SentinelResource(
        value = "createOrder", 
        blockHandler = "createOrderBlockHandler",
        fallback = "createOrderFallback"
    )
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        log.info("创建订单请求: {}", request);
        Order order = orderService.createOrder(request);
        return ResponseEntity.ok(order);
    }
    
    /**
     * 流控异常处理
     */
    public ResponseEntity<Order> createOrderBlockHandler(OrderRequest request, BlockException ex) {
        log.warn("创建订单触发流控, 规则: {}", ex.getRule());
        
        Map<String, Object> result = new HashMap<>();
        result.put("code", 429);
        result.put("message", "系统繁忙，请稍后重试");
        result.put("data", null);
        
        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body(null);
    }
    
    /**
     * 降级异常处理
     */
    public ResponseEntity<Order> createOrderFallback(OrderRequest request, Throwable ex) {
        log.error("创建订单服务降级", ex);
        
        Map<String, Object> result = new HashMap<>();
        result.put("code", 500);
        result.put("message", "服务暂时不可用，请稍后重试");
        result.put("data", null);
        
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }
    
    /**
     * 查询订单 - 参数限流
     */
    @GetMapping("/{orderId}")
    @SentinelResource(
        value = "getOrder",
        blockHandler = "getOrderBlockHandler",
        fallback = "getOrderFallback"
    )
    public ResponseEntity<Order> getOrder(@PathVariable String orderId) {
        log.info("查询订单: {}", orderId);
        Order order = orderService.getOrder(orderId);
        return ResponseEntity.ok(order);
    }
    
    public ResponseEntity<Order> getOrderBlockHandler(String orderId, BlockException ex) {
        log.warn("查询订单触发流控, 订单ID: {}, 规则: {}", orderId, ex.getRule());
        return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body(null);
    }
    
    public ResponseEntity<Order> getOrderFallback(String orderId, Throwable ex) {
        log.error("查询订单服务降级, 订单ID: {}", orderId, ex);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }
}
// 自定义限流规则配置
@Component
public class SentinelRuleConfig {
    
    /**
     * 初始化流控规则
     */
    @PostConstruct
    public void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        // 创建订单流控规则
        FlowRule createOrderRule = new FlowRule();
        createOrderRule.setResource("createOrder");
        createOrderRule.setGrade(RuleConstant.FLOW_GRADE_QPS);  // QPS限流
        createOrderRule.setCount(100);                          // 阈值100
        createOrderRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP); // 预热模式
        createOrderRule.setWarmUpPeriodSec(10);                 // 预热时间10秒
        rules.add(createOrderRule);
        
        // 查询订单流控规则
        FlowRule getOrderRule = new FlowRule();
        getOrderRule.setResource("getOrder");
        getOrderRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        getOrderRule.setCount(500);                            // 阈值500
        getOrderRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER); // 排队等待
        getOrderRule.setMaxQueueingTimeMs(1000);               // 最大排队时间1秒
        rules.add(getOrderRule);
        
        FlowRuleManager.loadRules(rules);
        log.info("初始化Sentinel流控规则完成");
    }
    
    /**
     * 热点参数限流规则
     */
    public void initParamFlowRules() {
        List<ParamFlowRule> paramRules = new ArrayList<>();
        
        ParamFlowRule paramRule = new ParamFlowRule("getOrder")
            .setParamIdx(0)  // 第一个参数(orderId)
            .setCount(10);   // 单参数阈值
        
        // 针对特定参数值设置独立限流
        ParamFlowItem item = new ParamFlowItem().setObject("SPECIAL_ORDER_123")
            .setClassType(String.class.getName())
            .setCount(1);    // 特殊订单限流更严格
        
        paramRule.setParamFlowItemList(Collections.singletonList(item));
        paramRules.add(paramRule);
        
        ParamFlowRuleManager.loadRules(paramRules);
        log.info("初始化Sentinel热点参数限流规则完成");
    }
}
// 高级限流策略
@Service
@Slf4j
public class AdvancedRateLimitService {
    
    /**
     * 集群流控示例
     */
    @SentinelResource(
        value = "clusterFlowControl",
        blockHandler = "clusterFlowBlockHandler"
    )
    public String clusterFlowOperation(String data) {
        // 集群环境下的流控操作
        return processData(data);
    }
    
    public String clusterFlowBlockHandler(String data, BlockException ex) {
        log.warn("集群流控触发, 数据: {}", data);
        return "集群流控限制，请稍后重试";
    }
    
    /**
     * 网关层限流示例
     */
    @SentinelResource(value = "gatewayFlowControl")
    public ResponseEntity<?> gatewayLevelFlowControl(HttpServletRequest request) {
        // 获取客户端IP
        String clientIp = getClientIp(request);
        
        // 基于IP的限流
        if (isIpOverLimit(clientIp)) {
            return ResponseEntity.status(429)
                .body(Map.of("error", "IP访问频率过高"));
        }
        
        return ResponseEntity.ok("访问正常");
    }
    
    private String getClientIp(HttpServletRequest request) {
        String xff = request.getHeader("X-Forwarded-For");
        if (xff != null && !xff.isEmpty()) {
            return xff.split(",")[0].trim();
        }
        return request.getRemoteAddr();
    }
    
    private boolean isIpOverLimit(String ip) {
        // 实现基于IP的限流逻辑
        // 可以使用Redis等分布式缓存记录访问次数
        return false;
    }
    
    private String processData(String data) {
        // 模拟数据处理
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "processed: " + data;
    }
}

// 熔断降级服务
@Service
@Slf4j
public class CircuitBreakerService {
    
    @Autowired
    private RestTemplate restTemplate;
    
    /**
     * 调用支付服务 - 熔断保护
     */
    @SentinelResource(
        value = "callPaymentService",
        blockHandler = "paymentServiceBlockHandler",
        fallback = "paymentServiceFallback",
        exceptionsToIgnore = {IllegalArgumentException.class} // 忽略的异常
    )
    public PaymentResult callPaymentService(PaymentRequest request) {
        log.info("调用支付服务: {}", request);
        
        // 模拟外部服务调用
        ResponseEntity<PaymentResult> response = restTemplate.postForEntity(
            "http://payment-service/api/payments", 
            request, 
            PaymentResult.class
        );
        
        if (!response.getStatusCode().is2xxSuccessful()) {
            throw new RuntimeException("支付服务调用失败: " + response.getStatusCode());
        }
        
        return response.getBody();
    }
    
    /**
     * 流控异常处理
     */
    public PaymentResult paymentServiceBlockHandler(PaymentRequest request, BlockException ex) {
        log.warn("支付服务流控触发: {}", ex.getClass().getSimpleName());
        return PaymentResult.failed("SYSTEM_BUSY", "系统繁忙，请稍后重试");
    }
    
    /**
     * 降级异常处理
     */
    public PaymentResult paymentServiceFallback(PaymentRequest request, Throwable ex) {
        log.error("支付服务降级, 请求: {}", request, ex);
        
        // 根据异常类型提供不同的降级策略
        if (ex instanceof TimeoutException) {
            return PaymentResult.failed("TIMEOUT", "支付服务响应超时，请检查支付状态");
        } else if (ex instanceof ConnectException) {
            return PaymentResult.failed("UNAVAILABLE", "支付服务暂时不可用");
        } else {
            return PaymentResult.failed("ERROR", "支付服务异常，请稍后重试");
        }
    }
}
// 熔断规则配置
@Component
@Slf4j
public class CircuitBreakerRuleConfig {
    
    /**
     * 初始化熔断降级规则
     */
    @PostConstruct
    public void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();
        
        // 支付服务熔断规则
        DegradeRule paymentRule = new DegradeRule();
        paymentRule.setResource("callPaymentService");
        paymentRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT); // 异常数模式
        paymentRule.setCount(5);                  // 异常数阈值
        paymentRule.setTimeWindow(10);            // 熔断时间10秒
        paymentRule.setStatIntervalMs(60000);     // 统计窗口60秒
        paymentRule.setMinRequestAmount(5);       // 最小请求数
        rules.add(paymentRule);
        
        // 库存服务熔断规则 - 慢调用比例模式
        DegradeRule inventoryRule = new DegradeRule();
        inventoryRule.setResource("callInventoryService");
        inventoryRule.setGrade(RuleConstant.DEGRADE_GRADE_RT);           // 慢调用比例模式
        inventoryRule.setCount(500);              // 响应时间阈值500ms
        inventoryRule.setTimeWindow(10);          // 熔断时间10秒
        inventoryRule.setRtSlowRequestAmount(5);  // 慢调用临界请求数
        inventoryRule.setMinRequestAmount(10);    // 最小请求数
        rules.add(inventoryRule);
        
        DegradeRuleManager.loadRules(rules);
        log.info("初始化Sentinel熔断降级规则完成");
    }
}
// 优雅降级服务
@Service
@Slf4j
public class GracefulDegradationService {
    
    /**
     * 多级降级策略
     */
    @SentinelResource(
        value = "multiLevelDegradation",
        fallback = "primaryFallback",
        fallbackClass = MultiLevelFallback.class
    )
    public ServiceResult primaryService(String request) {
        // 主服务逻辑
        return callPrimaryService(request);
    }
    
    /**
     * 降级服务调用链
     */
    @SentinelResource(
        value = "degradationChain",
        blockHandler = "degradationChainBlockHandler",
        fallback = "degradationChainFallback"
    )
    public ServiceResult degradationChain(String request) {
        try {
            // 1. 尝试主服务
            return callPrimaryService(request);
        } catch (Exception e) {
            log.warn("主服务失败，尝试备用服务", e);
            
            try {
                // 2. 尝试备用服务
                return callSecondaryService(request);
            } catch (Exception ex) {
                log.warn("备用服务失败，返回兜底数据", ex);
                
                // 3. 返回兜底数据
                return getFallbackData(request);
            }
        }
    }
    
    public ServiceResult degradationChainBlockHandler(String request, BlockException ex) {
        log.warn("服务调用链流控触发");
        return ServiceResult.failed("DEGRADED", "服务降级中");
    }
    
    public ServiceResult degradationChainFallback(String request, Throwable ex) {
        log.error("服务调用链降级", ex);
        return getFallbackData(request);
    }
    
    private ServiceResult callPrimaryService(String request) {
        // 模拟主服务调用
        if (Math.random() < 0.1) { // 10%失败率
            throw new RuntimeException("主服务异常");
        }
        return ServiceResult.success("primary: " + request);
    }
    
    private ServiceResult callSecondaryService(String request) {
        // 模拟备用服务调用
        if (Math.random() < 0.2) { // 20%失败率
            throw new RuntimeException("备用服务异常");
        }
        return ServiceResult.success("secondary: " + request);
    }
    
    private ServiceResult getFallbackData(String request) {
        // 返回兜底数据
        return ServiceResult.success("fallback: " + request);
    }
}
// 多级降级回退类
@Slf4j
public class MultiLevelFallback {
    
    public static ServiceResult primaryFallback(String request, Throwable ex) {
        log.warn("主服务降级，请求: {}", request, ex);
        
        // 一级降级：尝试本地缓存
        ServiceResult cacheResult = getFromLocalCache(request);
        if (cacheResult != null) {
            return cacheResult;
        }
        
        // 二级降级：返回默认值
        return ServiceResult.success("default_value");
    }
    
    private static ServiceResult getFromLocalCache(String request) {
        // 从本地缓存获取数据
        // 模拟实现
        if (request.contains("cache")) {
            return ServiceResult.success("cached_data");
        }
        return null;
    }
}

// 系统保护配置
@Component
@Slf4j
public class SystemProtectionConfig {
    
    /**
     * 初始化系统保护规则
     */
    @PostConstruct
    public void initSystemRules() {
        List<SystemRule> rules = new ArrayList<>();
        
        // LOAD自适应保护
        SystemRule loadRule = new SystemRule();
        loadRule.setHighestSystemLoad(3.0);       // 最大系统负载
        loadRule.setAvgRt(1000);                  // 平均响应时间
        loadRule.setMaxThread(500);               // 最大并发线程数
        loadRule.setQps(1000);                    // 入口QPS
        loadRule.setHighestCpuUsage(0.8);         // CPU使用率阈值
        rules.add(loadRule);
        
        SystemRuleManager.loadRules(rules);
        log.info("初始化Sentinel系统保护规则完成");
    }
}
// 热点参数限流服务
@Service
@Slf4j
public class HotParamLimitService {
    
    /**
     * 商品详情查询 - 热点参数限流
     */
    @SentinelResource(
        value = "getProductDetail",
        blockHandler = "productDetailBlockHandler",
        fallback = "productDetailFallback"
    )
    public ProductDetail getProductDetail(String productId, Long userId) {
        log.info("查询商品详情, 商品ID: {}, 用户ID: {}", productId, userId);
        
        // 模拟数据库查询
        return productService.getProductDetail(productId);
    }
    
    /**
     * 热点参数限流异常处理
     */
    public ProductDetail productDetailBlockHandler(String productId, Long userId, BlockException ex) {
        log.warn("商品详情查询触发热点限流, 商品ID: {}, 用户ID: {}", productId, userId);
        
        // 返回缓存数据或默认数据
        return getCachedProductDetail(productId);
    }
    
    public ProductDetail productDetailFallback(String productId, Long userId, Throwable ex) {
        log.error("商品详情查询服务降级", ex);
        return getDefaultProductDetail();
    }
    
    /**
     * 初始化热点参数规则
     */
    @PostConstruct
    public void initHotParamRules() {
        List<ParamFlowRule> rules = new ArrayList<>();
        
        // 商品ID热点参数规则
        ParamFlowRule productRule = new ParamFlowRule("getProductDetail")
            .setParamIdx(0)  // 第一个参数productId
            .setCount(50);   // 单商品QPS阈值
        
        // 特殊商品独立限流
        Map<Object, Integer> hotItems = new HashMap<>();
        hotItems.put("HOT_PRODUCT_001", 5);   // 爆款商品限流更严格
        hotItems.put("HOT_PRODUCT_002", 5);
        
        productRule.setParamFlowItemList(
            hotItems.entrySet().stream()
                .map(entry -> new ParamFlowItem()
                    .setObject(entry.getKey())
                    .setClassType(String.class.getName())
                    .setCount(entry.getValue()))
                .collect(Collectors.toList())
        );
        
        rules.add(productRule);
        ParamFlowRuleManager.loadRules(rules);
        log.info("初始化热点参数限流规则完成");
    }
    
    private ProductDetail getCachedProductDetail(String productId) {
        // 从缓存获取商品详情
        return new ProductDetail(productId, "缓存商品数据");
    }
    
    private ProductDetail getDefaultProductDetail() {
        return new ProductDetail("default", "默认商品数据");
    }
}

# application.yml 网关配置
spring:
  application:
    name: api-gateway
  cloud:
    gateway:
      routes:
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10    # 每秒令牌数
                redis-rate-limiter.burstCapacity: 20    # 令牌桶容量
                redis-rate-limiter.requestedTokens: 1   # 每次请求消耗令牌数
                key-resolver: "#{@userKeyResolver}"     # 限流键解析器
            - name: StripPrefix=1
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/users/**
          filters:
            - name: CircuitBreaker
              args:
                name: userServiceBreaker
                fallbackUri: forward:/fallback/user
            - StripPrefix=1
    
    # Sentinel网关流控
    sentinel:
      filter:
        enabled: true
      scg:
        fallback:
          mode: response
          response-status: 429
          response-body: '{"code":429,"message":"请求过于频繁"}'
# Redis配置
redis:
  host: 127.0.0.1
  port: 6379
  timeout: 3000ms
# 限流配置
resilience4j:
  ratelimiter:
    instances:
      orderService:
        limit-for-period: 100
        limit-refresh-period: 1s
        timeout-duration: 0
        allow-health-indicator-to-fail: true

// 网关限流配置类
@Configuration
public class GatewayRateLimitConfig {
    
    /**
     * 基于用户的限流键解析器
     */
    @Bean
    public KeyResolver userKeyResolver() {
        return exchange -> {
            // 从请求头获取用户ID
            String userId = exchange.getRequest()
                .getHeaders()
                .getFirst("X-User-Id");
            
            if (userId != null) {
                return Mono.just(userId);
            }
            
            // 从Token解析用户ID
            String token = exchange.getRequest()
                .getHeaders()
                .getFirst("Authorization");
            
            if (token != null && token.startsWith("Bearer ")) {
                String actualToken = token.substring(7);
                // 解析Token获取用户ID（实际项目需要实现Token解析逻辑）
                return Mono.just(actualToken);
            }
            
            // 使用客户端IP作为备用键
            String clientIp = exchange.getRequest()
                .getRemoteAddress()
                .getAddress()
                .getHostAddress();
            
            return Mono.just(clientIp);
        };
    }
    
    /**
     * 基于IP的限流键解析器
     */
    @Bean
    public KeyResolver ipKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest()
                .getRemoteAddress()
                .getAddress()
                .getHostAddress()
        );
    }
    
    /**
     * 基于API路径的限流键解析器
     */
    @Bean
    public KeyResolver apiKeyResolver() {
        return exchange -> Mono.just(
            exchange.getRequest()
                .getPath()
                .value()
        );
    }
}
// 网关熔断降级处理器
@Component
@Slf4j
public class GatewayFallbackHandler {
    
    /**
     * 用户服务熔断降级处理
     */
    @RequestMapping("/fallback/user")
    public Mono<Map<String, Object>> userServiceFallback(ServerWebExchange exchange) {
        log.warn("用户服务熔断降级");
        
        Map<String, Object> result = new HashMap<>();
        result.put("code", 503);
        result.put("message", "用户服务暂时不可用");
        result.put("timestamp", Instant.now());
        result.put("path", exchange.getRequest().getPath().value());
        
        return Mono.just(result);
    }
    
    /**
     * 订单服务熔断降级处理
     */
    @RequestMapping("/fallback/order")
    public Mono<Map<String, Object>> orderServiceFallback(ServerWebExchange exchange) {
        log.warn("订单服务熔断降级");
        
        Map<String, Object> result = new HashMap<>();
        result.put("code", 503);
        result.put("message", "订单服务暂时不可用");
        result.put("timestamp", Instant.now());
        result.put("path", exchange.getRequest().getPath().value());
        
        return Mono.just(result);
    }
}
// 自定义网关过滤器
@Component
@Slf4j
public class CustomGatewayFilter implements GlobalFilter, Ordered {
    
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        
        // 1. 记录请求日志
        log.info("网关请求: {} {}, 客户端: {}", 
            request.getMethod(), 
            request.getPath(),
            request.getRemoteAddress());
        
        // 2. 请求头校验
        if (!isValidRequest(request)) {
            return handleInvalidRequest(exchange);
        }
        
        // 3. 限流前置检查
        if (isRateLimitExceeded(request)) {
            return handleRateLimit(exchange);
        }
        
        // 4. 添加追踪头
        ServerHttpRequest modifiedRequest = addTraceHeaders(request);
        
        return chain.filter(exchange.mutate().request(modifiedRequest).build());
    }
    
    @Override
    public int getOrder() {
        return Ordered.HIGHEST_PRECEDENCE;
    }
    
    private boolean isValidRequest(ServerHttpRequest request) {
        // 实现请求校验逻辑
        return true;
    }
    
    private Mono<Void> handleInvalidRequest(ServerWebExchange exchange) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.BAD_REQUEST);
        
        DataBuffer buffer = response.bufferFactory()
            .wrap("{\"error\": \"Invalid request\"}".getBytes());
        
        return response.writeWith(Mono.just(buffer));
    }
    
    private boolean isRateLimitExceeded(ServerHttpRequest request) {
        // 实现自定义限流逻辑
        return false;
    }
    
    private Mono<Void> handleRateLimit(ServerWebExchange exchange) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
        
        DataBuffer buffer = response.bufferFactory()
            .wrap("{\"error\": \"Rate limit exceeded\"}".getBytes());
        
        return response.writeWith(Mono.just(buffer));
    }
    
    private ServerHttpRequest addTraceHeaders(ServerHttpRequest request) {
        return request.mutate()
            .header("X-Trace-Id", generateTraceId())
            .header("X-Gateway-Timestamp", String.valueOf(System.currentTimeMillis()))
            .build();
    }
    
    private String generateTraceId() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

// 自适应限流服务
@Service
@Slf4j
public class AdaptiveRateLimitService {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    private final Map<String, AdaptiveLimitConfig> limitConfigs = new ConcurrentHashMap<>();
    
    /**
     * 自适应限流检查
     */
    public boolean shouldAllowRequest(String resource, Map<String, String> context) {
        AdaptiveLimitConfig config = limitConfigs.computeIfAbsent(
            resource, k -> new AdaptiveLimitConfig());
        
        // 获取系统指标
        SystemMetrics metrics = getSystemMetrics();
        
        // 计算动态限流阈值
        int dynamicThreshold = calculateDynamicThreshold(config, metrics, context);
        
        // 检查当前QPS
        double currentQps = getCurrentQps(resource);
        
        boolean allowed = currentQps < dynamicThreshold;
        
        if (!allowed) {
            log.warn("自适应限流触发: {}, QPS: {}/{}, 系统负载: {}",
                resource, currentQps, dynamicThreshold, metrics.getSystemLoad());
        }
        
        return allowed;
    }
    
    /**
     * 计算动态阈值
     */
    private int calculateDynamicThreshold(AdaptiveLimitConfig config, 
                                        SystemMetrics metrics, 
                                        Map<String, String> context) {
        int baseThreshold = config.getBaseThreshold();
        
        // 基于系统负载调整
        double loadFactor = calculateLoadFactor(metrics);
        
        // 基于时间因素调整（比如高峰期）
        double timeFactor = calculateTimeFactor();
        
        // 基于业务因素调整
        double businessFactor = calculateBusinessFactor(context);
        
        return (int) (baseThreshold * loadFactor * timeFactor * businessFactor);
    }
    
    private double calculateLoadFactor(SystemMetrics metrics) {
        double systemLoad = metrics.getSystemLoad();
        double cpuUsage = metrics.getCpuUsage();
        
        if (systemLoad > 4.0 || cpuUsage > 0.8) {
            return 0.5; // 高负载时降低阈值
        } else if (systemLoad > 2.0 || cpuUsage > 0.6) {
            return 0.8; // 中负载时适当降低
        } else {
            return 1.0; // 正常负载
        }
    }
    
    private double calculateTimeFactor() {
        // 基于时间的调整因子
        LocalTime now = LocalTime.now();
        
        // 高峰期（9-12, 14-18）
        if ((now.isAfter(LocalTime.of(9, 0)) && now.isBefore(LocalTime.of(12, 0))) ||
            (now.isAfter(LocalTime.of(14, 0)) && now.isBefore(LocalTime.of(18, 0)))) {
            return 1.2; // 高峰期提高阈值
        }
        
        // 凌晨低峰期
        if (now.isAfter(LocalTime.of(0, 0)) && now.isBefore(LocalTime.of(6, 0))) {
            return 1.5; // 低峰期进一步提高
        }
        
        return 1.0; // 正常时段
    }
    
    private double calculateBusinessFactor(Map<String, String> context) {
        // 基于业务场景的调整因子
        String userType = context.get("userType");
        String requestType = context.get("requestType");
        
        if ("VIP".equals(userType)) {
            return 2.0; // VIP用户提高阈值
        }
        
        if ("read".equals(requestType)) {
            return 1.5; // 读操作提高阈值
        }
        
        return 1.0; // 默认因子
    }
    
    private SystemMetrics getSystemMetrics() {
        SystemMetrics metrics = new SystemMetrics();
        
        // 获取系统负载
        metrics.setSystemLoad(getSystemLoad());
        
        // 获取CPU使用率
        metrics.setCpuUsage(getCpuUsage());
        
        // 获取内存使用率
        metrics.setMemoryUsage(getMemoryUsage());
        
        return metrics;
    }
    
    private double getSystemLoad() {
        // 获取系统负载
        return ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage();
    }
    
    private double getCpuUsage() {
        // 获取CPU使用率（简化实现）
        return 0.3; // 实际项目需要实现具体逻辑
    }
    
    private double getMemoryUsage() {
        // 获取内存使用率
        Runtime runtime = Runtime.getRuntime();
        long usedMemory = runtime.totalMemory() - runtime.freeMemory();
        long maxMemory = runtime.maxMemory();
        return (double) usedMemory / maxMemory;
    }
    
    private double getCurrentQps(String resource) {
        // 获取当前QPS（从监控指标中获取）
        Counter counter = meterRegistry.counter("request.count", "resource", resource);
        return counter.count(); // 简化实现，实际需要计算QPS
    }
    
    @Data
    public static class AdaptiveLimitConfig {
        private int baseThreshold = 100;
        private int minThreshold = 10;
        private int maxThreshold = 1000;
        private double sensitivity = 1.0;
    }
    
    @Data
    public static class SystemMetrics {
        private double systemLoad;
        private double cpuUsage;
        private double memoryUsage;
        private long gcCount;
        private long threadCount;
    }
}

// 流量染色服务
@Component
@Slf4j
public class TrafficColoringService {
    
    /**
     * 流量染色类型
     */
    public enum TrafficColor {
        NORMAL("normal", "正常流量"),
        TEST("test", "测试流量"),
        GRAY("gray", "灰度流量"),
        PRESSURE("pressure", "压测流量"),
        DEBUG("debug", "调试流量");
        
        private final String code;
        private final String description;
        
        TrafficColor(String code, String description) {
            this.code = code;
            this.description = description;
        }
    }
    
    /**
     * 染色流量过滤器
     */
    @Component
    public class TrafficColorFilter implements Filter {
        
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                throws IOException, ServletException {
            
            HttpServletRequest httpRequest = (HttpServletRequest) request;
            HttpServletResponse httpResponse = (HttpServletResponse) response;
            
            // 获取流量染色标记
            String trafficColor = getTrafficColor(httpRequest);
            
            // 设置到请求上下文中
            TrafficContext.setTrafficColor(trafficColor);
            
            try {
                // 根据流量类型进行不同处理
                handleColoredTraffic(httpRequest, httpResponse, trafficColor);
                
                chain.doFilter(request, response);
            } finally {
                // 清理上下文
                TrafficContext.clear();
            }
        }
        
        private String getTrafficColor(HttpServletRequest request) {
            // 从请求头获取染色标记
            String colorHeader = request.getHeader("X-Traffic-Color");
            if (colorHeader != null && !colorHeader.isEmpty()) {
                return colorHeader;
            }
            
            // 从参数获取染色标记
            String colorParam = request.getParameter("_traffic_color");
            if (colorParam != null && !colorParam.isEmpty()) {
                return colorParam;
            }
            
            // 默认正常流量
            return TrafficColor.NORMAL.code;
        }
        
        private void handleColoredTraffic(HttpServletRequest request, 
                                        HttpServletResponse response, 
                                        String trafficColor) {
            
            switch (trafficColor) {
                case "test":
                    // 测试流量：记录详细日志
                    log.debug("测试流量: {}", request.getRequestURI());
                    break;
                    
                case "pressure":
                    // 压测流量：跳过某些非核心逻辑
                    handlePressureTestTraffic(request);
                    break;
                    
                case "debug":
                    // 调试流量：开启调试模式
                    enableDebugMode(request);
                    break;
                    
                default:
                    // 正常流量：不做特殊处理
                    break;
            }
        }
        
        private void handlePressureTestTraffic(HttpServletRequest request) {
            // 压测流量处理逻辑
            // 比如：跳过数据上报、跳过某些校验等
            log.info("处理压测流量: {}", request.getRequestURI());
        }
        
        private void enableDebugMode(HttpServletRequest request) {
            // 开启调试模式
            // 比如：记录完整调用链、输出详细日志等
            log.info("调试流量: {}", request.getRequestURI());
        }
    }
    
    /**
     * 流量上下文
     */
    public static class TrafficContext {
        
        private static final ThreadLocal<String> TRAFFIC_COLOR = new ThreadLocal<>();
        
        public static void setTrafficColor(String color) {
            TRAFFIC_COLOR.set(color);
        }
        
        public static String getTrafficColor() {
            return TRAFFIC_COLOR.get();
        }
        
        public static boolean isPressureTest() {
            return TrafficColor.PRESSURE.code.equals(TRAFFIC_COLOR.get());
        }
        
        public static boolean isTest() {
            return TrafficColor.TEST.code.equals(TRAFFIC_COLOR.get());
        }
        
        public static void clear() {
            TRAFFIC_COLOR.remove();
        }
    }
}
// 全链路压测控制器
@RestController
@RequestMapping("/pressure-test")
@Slf4j
public class PressureTestController {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private UserService userService;
    
    /**
     * 压测流量创建订单
     */
    @PostMapping("/orders")
    public ResponseEntity<Order> createPressureTestOrder(@RequestBody OrderRequest request) {
        // 标记为压测流量
        TrafficContext.setTrafficColor("pressure");
        
        try {
            log.info("压测流量创建订单: {}", request);
            
            // 压测特定逻辑：跳过风控、使用影子表等
            Order order = orderService.createPressureTestOrder(request);
            
            return ResponseEntity.ok(order);
        } finally {
            TrafficContext.clear();
        }
    }
    
    /**
     * 压测数据清理
     */
    @DeleteMapping("/data")
    public ResponseEntity<Void> cleanupPressureTestData() {
        log.info("清理压测数据");
        
        try {
            // 清理压测过程中产生的数据
            orderService.cleanupPressureTestData();
            userService.cleanupPressureTestData();
            
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            log.error("清理压测数据失败", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}

// 流量治理监控服务
@Component
@Slf4j
public class TrafficGovernanceMonitor {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    /**
     * 监控关键指标
     */
    @Scheduled(fixedRate = 30000) // 每30秒执行一次
    public void monitorTrafficMetrics() {
        try {
            // 监控限流情况
            monitorRateLimitMetrics();
            
            // 监控熔断情况
            monitorCircuitBreakerMetrics();
            
            // 监控系统负载
            monitorSystemLoadMetrics();
            
            // 检查异常情况
            checkAnomalies();
            
        } catch (Exception e) {
            log.error("流量治理监控异常", e);
        }
    }
    
    private void monitorRateLimitMetrics() {
        // 获取限流相关指标
        Map<String, Double> rateLimitMetrics = getRateLimitMetrics();
        
        for (Map.Entry<String, Double> entry : rateLimitMetrics.entrySet()) {
            String resource = entry.getKey();
            Double blockQps = entry.getValue();
            
            // 限流比例过高告警
            if (blockQps > 10.0) {
                log.warn("资源 {} 限流比例过高: {} QPS", resource, blockQps);
                sendAlert("限流告警", String.format("资源 %s 限流比例过高: %f QPS", resource, blockQps));
            }
        }
    }
    
    private void monitorCircuitBreakerMetrics() {
        // 获取熔断相关指标
        Map<String, CircuitBreakerMetrics> breakerMetrics = getCircuitBreakerMetrics();
        
        for (Map.Entry<String, CircuitBreakerMetrics> entry : breakerMetrics.entrySet()) {
            String resource = entry.getKey();
            CircuitBreakerMetrics metrics = entry.getValue();
            
            // 熔断开启告警
            if (metrics.isOpen()) {
                log.warn("资源 {} 熔断器开启, 失败率: {}", resource, metrics.getFailureRate());
                sendAlert("熔断告警", String.format("资源 %s 熔断器开启", resource));
            }
            
            // 高失败率告警
            if (metrics.getFailureRate() > 0.5) {
                log.warn("资源 {} 失败率过高: {}", resource, metrics.getFailureRate());
                sendAlert("失败率告警", String.format("资源 %s 失败率过高: %f", resource, metrics.getFailureRate()));
            }
        }
    }
    
    private void monitorSystemLoadMetrics() {
        // 获取系统负载指标
        SystemLoadMetrics loadMetrics = getSystemLoadMetrics();
        
        // 系统负载告警
        if (loadMetrics.getSystemLoad() > 4.0) {
            log.warn("系统负载过高: {}", loadMetrics.getSystemLoad());
            sendAlert("系统负载告警", String.format("系统负载过高: %f", loadMetrics.getSystemLoad()));
        }
        
        // CPU使用率告警
        if (loadMetrics.getCpuUsage() > 0.8) {
            log.warn("CPU使用率过高: {}", loadMetrics.getCpuUsage());
            sendAlert("CPU告警", String.format("CPU使用率过高: %f", loadMetrics.getCpuUsage()));
        }
        
        // 内存使用率告警
        if (loadMetrics.getMemoryUsage() > 0.8) {
            log.warn("内存使用率过高: {}", loadMetrics.getMemoryUsage());
            sendAlert("内存告警", String.format("内存使用率过高: %f", loadMetrics.getMemoryUsage()));
        }
    }
    
    private void checkAnomalies() {
        // 检查异常模式
        checkTrafficSpike();
        checkErrorSpike();
        checkLatencyAnomaly();
    }
    
    private void checkTrafficSpike() {
        // 检查流量突增
        // 实现流量突增检测逻辑
    }
    
    private void checkErrorSpike() {
        // 检查错误率突增
        // 实现错误率突增检测逻辑
    }
    
    private void checkLatencyAnomaly() {
        // 检查延迟异常
        // 实现延迟异常检测逻辑
    }
    
    private Map<String, Double> getRateLimitMetrics() {
        // 获取限流指标（从Sentinel或自定义指标中获取）
        return Collections.emptyMap();
    }
    
    private Map<String, CircuitBreakerMetrics> getCircuitBreakerMetrics() {
        // 获取熔断器指标
        return Collections.emptyMap();
    }
    
    private SystemLoadMetrics getSystemLoadMetrics() {
        // 获取系统负载指标
        return new SystemLoadMetrics();
    }
    
    private void sendAlert(String title, String message) {
        // 发送告警通知
        log.info("发送告警: {} - {}", title, message);
    }
    
    @Data
    public static class CircuitBreakerMetrics {
        private boolean open;
        private double failureRate;
        private long totalRequests;
        private long failedRequests;
    }
    
    @Data
    public static class SystemLoadMetrics {
        private double systemLoad;
        private double cpuUsage;
        private double memoryUsage;
        private long gcCount;
    }
}
// 流量治理仪表板
@RestController
@RequestMapping("/traffic-dashboard")
@Slf4j
public class TrafficDashboardController {
    
    @Autowired
    private TrafficGovernanceMonitor monitor;
    
    /**
     * 获取流量治理概览
     */
    @GetMapping("/overview")
    public ResponseEntity<TrafficOverview> getTrafficOverview() {
        TrafficOverview overview = new TrafficOverview();
        
        // 总体流量统计
        overview.setTotalQps(getTotalQps());
        overview.setSuccessRate(getSuccessRate());
        overview.setAvgResponseTime(getAvgResponseTime());
        
        // 限流统计
        overview.setRateLimitStats(getRateLimitStats());
        
        // 熔断统计
        overview.setCircuitBreakerStats(getCircuitBreakerStats());
        
        // 系统负载
        overview.setSystemLoad(getSystemLoad());
        
        return ResponseEntity.ok(overview);
    }
    
    /**
     * 获取资源详情
     */
    @GetMapping("/resources/{resourceName}")
    public ResponseEntity<ResourceDetail> getResourceDetail(@PathVariable String resourceName) {
        ResourceDetail detail = new ResourceDetail();
        detail.setResourceName(resourceName);
        detail.setCurrentQps(getResourceQps(resourceName));
        detail.setRateLimitConfig(getRateLimitConfig(resourceName));
        detail.setCircuitBreakerStatus(getCircuitBreakerStatus(resourceName));
        detail.setMetricsHistory(getMetricsHistory(resourceName));
        
        return ResponseEntity.ok(detail);
    }
    
    // 内部方法实现...
    private double getTotalQps() { return 0.0; }
    private double getSuccessRate() { return 0.0; }
    private double getAvgResponseTime() { return 0.0; }
    private Object getRateLimitStats() { return null; }
    private Object getCircuitBreakerStats() { return null; }
    private Object getSystemLoad() { return null; }
    private double getResourceQps(String resourceName) { return 0.0; }
    private Object getRateLimitConfig(String resourceName) { return null; }
    private Object getCircuitBreakerStatus(String resourceName) { return null; }
    private Object getMetricsHistory(String resourceName) { return null; }
    
    @Data
    public static class TrafficOverview {
        private double totalQps;
        private double successRate;
        private double avgResponseTime;
        private Object rateLimitStats;
        private Object circuitBreakerStats;
        private Object systemLoad;
        private Instant timestamp = Instant.now();
    }
    
    @Data
    public static class ResourceDetail {
        private String resourceName;
        private double currentQps;
        private Object rateLimitConfig;
        private Object circuitBreakerStatus;
        private Object metricsHistory;
        private Instant timestamp = Instant.now();
    }
}