#服务熔断与降级机制

// HystrixCircuitBreaker.java - 熔断器核心接口
public interface HystrixCircuitBreaker {
    // 是否允许请求通过
    boolean allowRequest();

    // 是否熔断器打开
    boolean isOpen();

    // 标记熔断器打开
    void open();

    // 标记请求成功
    void markSuccess();

    // 标记请求失败
    void markFailure();
}

// HystrixCircuitBreakerImpl.java - 熔断器实现
public class HystrixCircuitBreakerImpl implements HystrixCircuitBreaker {
    // 配置参数
    private final HystrixCommandProperties properties;

    // 熔断器状态（默认 CLOSED）
    private final AtomicReference<HystrixCircuitBreaker.State> state;

    public enum State {
        CLOSED,    // 关闭
        OPEN,      // 打开
        HALF_OPEN  // 半开
    }

    @Override
    public boolean allowRequest() {
        // 1. 如果是 FORCE_OPEN，直接拒绝
        if (properties.circuitBreakerForceOpen().get()) {
            return false;
        }

        // 2. 如果是 FORCE_CLOSED，允许所有请求
        if (properties.circuitBreakerForceClosed().get()) {
            return true;
        }

        // 3. 检查状态
        if (state.get() == CLOSED) {
            return true;  // 关闭状态，允许请求
        }

        if (state.get() == OPEN) {
            // 检查是否过了熔断时间
            if (durationInOpenState() >= properties.circuitBreakerSleepWindow().get()) {
                // 进入 HALF_OPEN 状态
                if (state.compareAndSet(OPEN, HALF_OPEN)) {
                    circuitOpened.set(System.currentTimeMillis());
                }
                return true;  // 半开状态，允许一个请求通过
            }
            return false;  // 还在熔断窗口内，拒绝请求
        }

        return false;
    }

    @Override
    public void markSuccess() {
        if (state.get() == HALF_OPEN) {
            // HALF_OPEN 状态下，请求成功，关闭熔断器
            state.set(CLOSED);
            // 重置计数器
            metrics.reset();
        }
    }

    @Override
    public void markFailure() {
        if (state.get() == CLOSED) {
            // 在 CLOSED 状态下，标记失败
            metrics.recordFailure();
        }

        // 在 HALF_OPEN 状态下，任何失败都重新打开熔断器
        if (state.get() == HALF_OPEN) {
            circuitOpened.set(System.currentTimeMillis());
            state.set(OPEN);
        }
    }
}

// HystrixCommandProperties.java - 熔断器配置
@HystrixProperty(name = "circuitBreaker.enabled", value = "true")           // 启用熔断
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20") // 最小请求数
@HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "5000") // 熔断持续时间
@HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50") // 错误率阈值

/*
 * 熔断触发条件：
 *
 * 1. requestVolumeThreshold = 20
 *    必须至少收到 20 个请求，才会判断是否熔断
 *    （避免统计样本太少导致的误判）
 *
 * 2. errorThresholdPercentage = 50
 *    当 20 个请求中，失败率超过 50% 时，触发熔断
 *    即 10 个以上请求失败/超时/异常
 *
 * 3. sleepWindowInMilliseconds = 5000
 *    熔断打开后，持续 5 秒
 *    5 秒后，允许一个请求通过（HALF_OPEN）
 *    如果成功则关闭熔断器
 *    如果失败则继续打开 5 秒
 */

// 统计失败率
// HystrixCircuitBreakerImpl.java
public void markFailure() {
    // 将当前请求标记为失败
    metrics.markFailure();
}

// 定时检查是否需要熔断
// HealthCountsStream.java
public void checkCircuitBreaker() {
    long total = getTotal();
    long error = getErrorCount();

    if (total >= requestVolumeThreshold) {
        double errorPercentage = error * 100.0 / total;

        if (errorPercentage >= errorThresholdPercentage) {
            // 错误率超过阈值，打开熔断器
            circuitBreaker.open();
        }
    }
}

// LeapArray.java - Sentinel 的滑动窗口实现
public class LeapArray<T> {
    // 时间窗口参数
    private final int windowLengthInMs;   // 每个桶的时间长度
    private final int sampleCount;        // 桶的数量
    private final int intervalInMs;       // 总时间窗口 = windowLengthInMs * sampleCount

    // 实际存储的桶数组
    private final AtomicReferenceArray<Window<T>> array;

    // LeapArray 示例：
    // windowLengthInMs = 200ms
    // sampleCount = 5
    // intervalInMs = 1000ms (1秒)
    //
    // 滑动窗口示意：
    // |<-- 200ms -->|<-- 200ms -->|<-- 200ms -->|<-- 200ms -->|<-- 200ms -->|
    // |    Bucket0  |    Bucket1  |    Bucket2  |    Bucket3  |    Bucket4  |
    //                                                              ↑
    //                                                        当前时间
    //
    // 计算 QPS = (Bucket0 + Bucket1 + ... + Bucket4) / 1s
}

// WindowBucket.java - 单个时间桶
public class Window<T> {
    private long windowStart;  // 桶的开始时间
    private T value;           // 统计数据

    // value 可能是：
    // - MetricBucket: 请求总数、成功数、异常数、阻塞数、响应时间
    // - BucketWrap: 存储上述数据的包装类
}

// DegradeRule.java - Sentinel 熔断规则
// 支持三种熔断策略：

// 1. 基于异常比例熔断
@HystrixProperty(name = "degrade.max_exception_ratio", value = "0.3")
// 异常比例阈值：0.3 = 30%
// 当 1 秒内请求数 >= 5，且异常比例 >= 30% 时，熔断

// 2. 基于异常数熔断
@HystrixProperty(name = "degrade.max_exception_count", value = "10")
// 异常数阈值：10
// 当 1 秒内异常数 >= 10 时，熔断

// 3. 基于慢调用比例熔断
@HystrixProperty(name = "degrade.max_slow_ratio", value = "0.5")
@HystrixProperty(name = "degrade.max_rt", value = "1000")
// 慢调用比例阈值：0.5 = 50%
// 慢调用阈值：RT = 1000ms
// 当 1 秒内慢调用比例 >= 50% 时，熔断

// 配置示例
@PostConstruct
public void initRules() {
    List<DegradeRule> rules = new ArrayList<>();

    // 异常比例熔断
    DegradeRule rule1 = new DegradeRule("user-service")
        .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
        .setCount(0.3)  // 30% 异常比例
        .setMinRequestAmount(5)  // 最小请求数
        .setStatIntervalMs(1000)  // 统计时间窗口
        .setTimeWindow(10);  // 熔断持续 10 秒

    // 慢调用比例熔断
    DegradeRule rule2 = new DegradeRule("user-service")
        .setGrade(CircuitBreakerStrategy.SLOW_RT_RATIO.getType())
        .setCount(1000)  // 慢调用阈值 1000ms
        .setMinRequestAmount(5)
        .setSlowRatioThreshold(0.5)  // 50% 慢调用比例
        .setTimeWindow(10);

    rules.add(rule1);
    rules.add(rule2);

    DegradeRuleManager.loadRules(rules);
}

// FlowRule.java - 限流规则
// 五种流量整形策略：

// 1. 直接拒绝（默认）
// 直接拒绝超过阈值的请求
FlowRule rule = new FlowRule("user-service")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)  // QPS 上限 100
    .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
    // 超出 100 QPS 的请求直接拒绝

// 2. 冷启动（Warm Up）
// 预热阶段逐步提升阈值
// 适用于秒杀等场景
FlowRule rule = new FlowRule("user-service")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)
    .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP)
    .setWarmUpPeriodSec(10);  // 预热时长 10 秒
    // 开始时 QPS = 100 / 10 = 10
    // 10 秒后逐渐升到 100

// 3. 匀速排队
// 超过阈值的请求排队等待
FlowRule rule = new FlowRule("user-service")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)
    .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER)
    .setMaxQueueingTimeMs(500);  // 最多排队 500ms
    // 如果 QPS = 1000，超出 900 个请求会排队
    // 每个请求间隔 10ms 释放
    // 排队超过 500ms 的请求会被拒绝

// 4. 预热 + 匀速排队
// 组合策略
FlowRule rule = new FlowRule("user-service")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)
    .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP_RATE_LIMITER)
    .setWarmUpPeriodSec(10)
    .setMaxQueueingTimeMs(500);

// 5. 冷启动 + 匀速排队
// 基于漏桶算法的组合

// Hystrix 隔离策略配置
@HystrixCommand(
    commandProperties = {
        // 信号量隔离
        @HystrixProperty(name = "execution.isolation.strategy", value = "SEMAPHORE"),
        // 信号量最大并发数
        @HystrixProperty(name = "execution.isolation.semaphore.maxConcurrentRequests", value = "10")
    },
    threadPoolProperties = {
        // 线程池隔离
        @HystrixProperty(name = "coreSize", value = "10"),
        @HystrixProperty(name = "maxQueueSize", value = "100"),
        @HystrixProperty(name = "keepAliveTimeMinutes", value = "1")
    }
)
public String callUserService() {
    return userClient.getUser();
}

// 每个 HystrixCommandGroup 有一个 ThreadPoolKey
// 相同 ThreadPoolKey 的命令共享线程池

@HystrixCommand(
    groupKey = "UserGroup",
    threadPoolKey = "UserServicePool",  // 指定 ThreadPoolKey
    commandProperties = {
        @HystrixProperty(name = "coreSize", value = "10")
    }
)
public String getUser() {}

// ThreadPoolKey 相同，则共享线程池
@HystrixCommand(groupKey = "UserGroup", threadPoolKey = "UserServicePool")
public String getUserInfo() {}  // 和上面的命令共享线程池

// 分级降级策略
public class GradedFallback {
    // 第一级降级：返回缓存数据
    public User fallbackFromCache(Long userId) {
        User cached = redisTemplate.opsForValue().get("user:" + userId);
        if (cached != null) {
            log.info("一级降级：从缓存返回 user={}", userId);
            return cached;
        }
        throw new NeedSecondFallbackException();
    }

    // 第二级降级：返回默认数据
    public User fallbackDefault(Long userId) {
        log.info("二级降级：返回默认 user={}", userId);
        User user = new User();
        user.setId(userId);
        user.setName("默认用户");
        user.setStatus("降级返回");
        return user;
    }
}

// ❌ 错误：requestVolumeThreshold 设置过低
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "3")
// 只有 3 个请求就判断熔断，统计样本太少，容易误判

// ✅ 正确：设置足够的统计样本
@HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20")
// 至少 20 个请求后再判断熔断，统计更准确

// ❌ 错误：熔断持续时间太短
.setTimeWindow(1)  // 只熔断 1 秒就恢复
// 服务还没完全恢复，又被打挂了

// ✅ 正确：根据服务恢复时间设置
.setTimeWindow(30)  // 熔断 30 秒后再尝试