熔断器模式：从Hystrix到Sentinel

public class CircuitBreaker {
    private enum State { CLOSED, OPEN, HALF_OPEN }

    private State state = State.CLOSED;
    private int failureCount = 0;
    private int successCount = 0;
    private final int failureThreshold;
    private final int successThreshold;
    private final long openTimeoutMs;
    private long lastStateChangeTime;
    private final Object lock = new Object();

    public CircuitBreaker(int failureThreshold, int successThreshold, long openTimeoutMs) {
        this.failureThreshold = failureThreshold;
        this.successThreshold = successThreshold;
        this.openTimeoutMs = openTimeoutMs;
    }

    public <T> T execute(Supplier<T> action, Supplier<T> fallback) {
        if (!allowRequest()) {
            return fallback.get();
        }

        try {
            T result = action.get();
            recordSuccess();
            return result;
        } catch (Exception e) {
            recordFailure();
            return fallback.get();
        }
    }

    private boolean allowRequest() {
        synchronized (lock) {
            switch (state) {
                case CLOSED:
                    return true;
                case OPEN:
                    if (System.currentTimeMillis() - lastStateChangeTime >= openTimeoutMs) {
                        transitionTo(State.HALF_OPEN);
                        return true;
                    }
                    return false;
                case HALF_OPEN:
                    return true;
                default:
                    return false;
            }
        }
    }

    private void recordSuccess() {
        synchronized (lock) {
            if (state == State.HALF_OPEN) {
                successCount++;
                if (successCount >= successThreshold) {
                    transitionTo(State.CLOSED);
                }
            }
            failureCount = 0;
        }
    }

    private void recordFailure() {
        synchronized (lock) {
            failureCount++;
            if (state == State.HALF_OPEN) {
                transitionTo(State.OPEN);
            } else if (failureCount >= failureThreshold) {
                transitionTo(State.OPEN);
            }
        }
    }

    private void transitionTo(State newState) {
        state = newState;
        lastStateChangeTime = System.currentTimeMillis();
        failureCount = 0;
        successCount = 0;
    }
}

// HystrixCommand 方式
public class OrderServiceCommand extends HystrixCommand<Order> {
    private final String orderId;
    private final OrderClient orderClient;

    public OrderServiceCommand(String orderId, OrderClient orderClient) {
        super(HystrixCommand.Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("OrderService"))
            .andCommandKey(HystrixCommandKey.Factory.asKey("GetOrder"))
            .andCommandPropertiesDefaults(
                HystrixCommandProperties.Setter()
                    .withCircuitBreakerRequestVolumeThreshold(20)  // 至少20个请求
                    .withCircuitBreakerErrorThresholdPercentage(50) // 错误率50%
                    .withCircuitBreakerSleepWindowInMilliseconds(5000) // 熔断5秒
                    .withExecutionTimeoutInMilliseconds(3000)      // 超时3秒
                    .withMetricsRollingStatisticalWindowInMilliseconds(10000) // 统计窗口10秒
            )
            .andThreadPoolPropertiesDefaults(
                HystrixThreadPoolProperties.Setter()
                    .withCoreSize(10)        // 线程池核心线程数
                    .withMaxQueueSize(100)   // 队列大小
                    .withQueueSizeRejectionThreshold(50) // 队列拒绝阈值
            ));
        this.orderId = orderId;
        this.orderClient = orderClient;
    }

    @Override
    protected Order run() throws Exception {
        return orderClient.getOrder(orderId);
    }

    @Override
    protected Order getFallback() {
        // 降级策略：返回缓存数据或默认值
        return Order.defaultOrder(orderId);
    }
}

// 注解方式 (Spring Cloud)
@Service
public class OrderService {
    @HystrixCommand(
        fallbackMethod = "getOrderFallback",
        commandProperties = {
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
        },
        threadPoolProperties = {
            @HystrixProperty(name = "coreSize", value = "10")
        }
    )
    public Order getOrder(String orderId) {
        return orderClient.getOrder(orderId);
    }

    private Order getOrderFallback(String orderId) {
        return Order.defaultOrder(orderId);
    }
}

// 基于注解的流控
@SentinelResource(
    value = "getOrder",
    blockHandler = "getOrderBlockHandler",
    fallback = "getOrderFallback"
)
public Order getOrder(String orderId) {
    return orderClient.getOrder(orderId);
}

// 流控触发时的处理（参数列表需一致，额外加 BlockException）
public Order getOrderBlockHandler(String orderId, BlockException ex) {
    // 被限流或降级时执行
    return Order.limitedOrder(orderId);
}

// 业务异常降级
public Order getOrderFallback(String orderId, Throwable throwable) {
    return Order.defaultOrder(orderId);
}

// 编程式流控规则
private void initFlowRules() {
    List<FlowRule> rules = new ArrayList<>();

    // QPS 限流
    FlowRule qpsRule = new FlowRule();
    qpsRule.setResource("getOrder");
    qpsRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    qpsRule.setCount(100);  // 100 QPS
    qpsRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
    qpsRule.setWarmUpPeriodSec(10); // 预热10秒
    rules.add(qpsRule);

    // 线程数限流
    FlowRule threadRule = new FlowRule();
    threadRule.setResource("getOrder");
    threadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
    threadRule.setCount(50);  // 最大并发线程数50
    rules.add(threadRule);

    // 关联限流：当写接口压力大时，限制读接口
    FlowRule relatedRule = new FlowRule();
    relatedRule.setResource("queryOrder");
    relatedRule.setStrategy(RuleConstant.STRATEGY_RELATE);
    relatedRule.setRefResource("createOrder"); // 关联资源
    relatedRule.setCount(50);
    rules.add(relatedRule);

    FlowRuleManager.loadRules(rules);
}

// 降级（熔断）规则
private void initDegradeRules() {
    List<DegradeRule> rules = new ArrayList<>();

    // 慢调用比例熔断
    DegradeRule slowCallRule = new DegradeRule();
    slowCallRule.setResource("getOrder");
    slowCallRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
    slowCallRule.setCount(500);        // 慢调用阈值: 500ms
    slowCallRule.setSlowRatioThreshold(0.5); // 慢调用比例: 50%
    slowCallRule.setMinRequestAmount(10);     // 最小请求数
    slowCallRule.setStatIntervalMs(10000);    // 统计窗口: 10s
    slowCallRule.setTimeWindow(30);           // 熔断时长: 30s
    rules.add(slowCallRule);

    // 异常比例熔断
    DegradeRule errorRatioRule = new DegradeRule();
    errorRatioRule.setResource("createOrder");
    errorRatioRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
    errorRatioRule.setCount(0.5);              // 异常比例: 50%
    errorRatioRule.setMinRequestAmount(10);
    errorRatioRule.setStatIntervalMs(10000);
    errorRatioRule.setTimeWindow(60);          // 熔断时长: 60s
    rules.add(errorRatioRule);

    // 异常数熔断
    DegradeRule errorCountRule = new DegradeRule();
    errorCountRule.setResource("payOrder");
    errorCountRule.setGrade(CircuitBreakerStrategy.ERROR_COUNT.getType());
    errorCountRule.setCount(10);               // 异常数: 10
    errorCountRule.setStatIntervalMs(60000);   // 统计窗口: 1min
    errorCountRule.setTimeWindow(120);         // 熔断时长: 2min
    rules.add(errorCountRule);

    DegradeRuleManager.loadRules(rules);
}

// 系统保护规则
private void initSystemRules() {
    List<SystemRule> rules = new ArrayList<>();

    SystemRule rule = new SystemRule();
    rule.setHighestSystemLoad(3.0);     // CPU load > 3 时触发
    rule.setHighestCpuUsage(0.8);       // CPU 使用率 > 80%
    rule.setAvgRt(200);                 // 平均RT > 200ms
    rule.setMaxThread(500);             // 最大并发线程数
    rule.setQps(5000);                  // 入口QPS上限
    rules.add(rule);

    SystemRuleManager.loadRules(rules);
}

// 多级降级策略
@Service
public class ProductService {
    @Autowired
    private ProductClient productClient;
    @Autowired
    private RedisTemplate<String, Product> redis;

    @SentinelResource(value = "getProduct", fallback = "getProductFallback")
    public Product getProduct(String productId) {
        Product product = productClient.getById(productId);
        // 成功时更新缓存
        redis.opsForValue().set("product:" + productId, product, 1, TimeUnit.HOURS);
        return product;
    }

    // 降级：先查缓存
    public Product getProductFallback(String productId, Throwable t) {
        Product cached = redis.opsForValue().get("product:" + productId);
        if (cached != null) {
            return cached;
        }
        // 缓存也没有，返回兜底数据
        return Product.skeleton(productId);
    }
}