#Sentinel 限流降级实战

public class SentinelFlowControl {

    public void handleRequest(String resource) {
        Entry entry = null;
        try {
            // 埋点：定义资源
            entry = SphU.entry(resource);

            // 业务逻辑
            doProcess(resource);

        } catch (BlockException e) {
            // 被限流了
            handleBlock(e);
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }

    private void handleBlock(BlockException e) {
        if (e instanceof FlowException) {
            // 流量控制触发
            throw new RateLimitException("请求过于频繁，请稍后重试");
        } else if (e instanceof DegradeException) {
            // 熔断降级触发
            throw new DegradeException("服务暂时不可用");
        }
    }
}

@Service
public class SentinelAnnotationService {

    // 限流处理
    @SentinelResource(value = "getProduct",
        blockHandler = "getProductBlockHandler",
        fallback = "getProductFallback")
    public Product getProduct(Long productId) {
        return productService.getProduct(productId);
    }

    // 限流时的处理
    public Product getProductBlockHandler(Long productId, BlockException e) {
        log.warn("商品接口被限流: productId={}", productId);
        return Product.defaultProduct(productId);
    }

    // 异常时的降级处理
    public Product getProductFallback(Long productId, Throwable t) {
        log.error("商品接口异常: productId={}", productId, t);
        return Product.defaultProduct(productId);
    }
}

public class DynamicFlowRule {

    @PostConstruct
    public void init() {
        // 加载规则
        List<FlowRule> rules = loadRules();

        // 转换为 FlowRule 对象
        List<FlowRule> flowRules = rules.stream()
            .map(this::toFlowRule)
            .collect(Collectors.toList());

        // 推送规则
        FlowRuleManager.loadRules(flowRules);
    }

    private FlowRule toFlowRule(RuleConfig config) {
        FlowRule rule = new FlowRule();
        rule.setResource(config.getResource());
        rule.setCount(config.getCount());  // QPS 阈值
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);  // 按 QPS 限流
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);  // 直接拒绝

        // 其他策略
        // CONTROL_BEHAVIOR_WARM_UP: 冷启动
        // CONTROL_BEHAVIOR_QUEUE: 排队等待

        return rule;
    }

    // 动态更新规则
    public void updateRule(String resource, double count) {
        FlowRule rule = FlowRuleManager.getRules().stream()
            .filter(r -> r.getResource().equals(resource))
            .findFirst()
            .orElse(new FlowRule());

        rule.setResource(resource);
        rule.setCount(count);

        FlowRuleManager.loadRules(List.of(rule));
    }
}

public class SlowRatioDegrade {

    @PostConstruct
    public void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();

        DegradeRule rule = new DegradeRule("order-service")
            // 按慢调用比例熔断
            .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType())
            // 慢调用阈值：2 秒
            .setCount(2.0)
            // 最小请求数：5
            .setMinRequestAmount(5)
            // 统计时长：10 秒
            .setStatIntervalMs(10000)
            // 熔断恢复时长：30 秒
            .setTimeWindow(30);

        rules.add(rule);
        DegradeRuleManager.loadRules(rules);
    }
}

public class ErrorRatioDegrade {

    public void initErrorRatioRules() {
        DegradeRule rule = new DegradeRule("payment-service")
            // 按异常比例熔断
            .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
            // 异常比例阈值：50%
            .setCount(0.5)
            // 最小请求数：10
            .setMinRequestAmount(10)
            // 统计时长：60 秒
            .setStatIntervalMs(60000)
            // 熔断恢复时长：60 秒
            .setTimeWindow(60);

        DegradeRuleManager.loadRules(List.of(rule));
    }
}

public class SystemAdaptive {

    @PostConstruct
    public void initSystemRules() {
        List<SystemRule> rules = new ArrayList<>();

        SystemRule rule = new SystemRule()
            // CPU 使用率超过 80% 时触发限流
            .setHighestCpuUsage(0.8)
            // 平均响应时间超过 100ms 时触发限流
            .setHighestSystemLoad(100.0)
            // 入口 QPS 超过 1000 时触发限流
            .setHighestQps(1000)
            // 并发线程数超过 200 时触发限流
            .setHighestCpuUsage(200.0);

        rules.add(rule);
        SystemRuleManager.loadRules(rules);
    }
}

@Configuration
public class DubboSentinelConfiguration {

    @Bean
    public Filter dubboSentinelFilter() {
        return new SentinelDubboFilter();
    }
}

public class SentinelMetrics {

    private final ClusterBuilder builder;

    @PostConstruct
    public void init() {
        // 配置指标收集
        Config config = new Config();
        config.setConsoleServerHost("localhost:8080");

        // 记录指标
        ClusterBuilder builder = ClusterBuilder.newBuilder()
            .withClusterName("order-cluster");

        StatisticSlotCallbackHandler.addClusterBuilder(builder);
    }

    // 获取实时指标
    public Map<String, Long> getMetrics(String resource) {
        ClusterNode node = ClusterBuilderSlot.getClusterNode(resource);
        if (node == null) {
            return Collections.emptyMap();
        }

        Map<String, Long> metrics = new HashMap<>();
        metrics.put("passQps", node.totalPass());
        metrics.put("blockQps", node.totalBlock());
        metrics.put("successQps", node.totalSuccess());
        metrics.put("exceptionQps", node.totalException());
        metrics.put("avgRt", node.avgRt());

        return metrics;
    }
}