Laoli

The world is big, you have to go and see

Announcement

Welcome to Laoli's blog!

Learn More

1549 字

8 分钟

基于 Sentinel 的熔断与降级机制(Alibaba Sentinel 熔断降级完整指南)

2025-10-19

面经

/

快手

/

Sentinel

/

熔断

/

降级

基于 Sentinel 的熔断与降级机制(Alibaba Sentinel 熔断降级完整指南)#

一、核心概念#

1. 熔断 vs 降级#

熔断（Circuit Breaking）：当下游服务出现问题时，自动切断调用，避免级联故障
降级（Degradation）：服务降级到更低级别的服务质量，保证核心功能可用

2. Sentinel 的工作原理#

1
请求 → 资源定义 → 规则判断 → 熔断/降级决策 → Fallback 处理

二、熔断触发条件详解#

1. 慢调用比例策略#

1
// 场景：当慢调用（RT > 阈值）比例超过设定值时熔断
2
DegradeRule slowCallRule = new DegradeRule("orderService")
3
    .setGrade(RuleConstant.DEGRADE_GRADE_RT)           // RT模式
4
    .setCount(500)                                      // 最大响应时间 500ms
5
    .setTimeWindow(10)                                  // 熔断时长 10秒
6
    .setMinRequestAmount(5)                             // 最小请求数
7
    .setSlowRatioThreshold(0.6)                        // 慢调用比例 60%
8
    .setStatIntervalMs(1000);                          // 统计时长 1秒

触发逻辑：

在 1 秒统计窗口内
请求数 ≥ 5
响应时间 > 500ms 的请求占比 ≥ 60%
触发熔断 10 秒

2. 异常比例策略#

1
DegradeRule exceptionRatioRule = new DegradeRule("paymentService")
2
    .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO)  // 异常比例模式
3
    .setCount(0.5)                                          // 异常比例 50%
4
    .setTimeWindow(15)                                      // 熔断 15 秒
5
    .setMinRequestAmount(10)                                // 最小请求数
6
    .setStatIntervalMs(1000);                              // 统计周期

3. 异常数策略#

1
DegradeRule exceptionCountRule = new DegradeRule("smsService")
2
    .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT)  // 异常数模式
3
    .setCount(10)                                           // 异常数阈值
4
    .setTimeWindow(60)                                      // 熔断 60 秒
5
    .setStatIntervalMs(60000);                             // 60秒统计窗口

三、降级策略实现#

1. 注解方式配置#

1
@Service
2
public class OrderService {
3

4
    /**
5
     * 基础降级配置
6
     * blockHandler: 处理限流/熔断
7
     * fallback: 处理业务异常
8
     */
9
    @SentinelResource(
10
        value = "createOrder",
11
        blockHandler = "createOrderBlockHandler",
12
        fallback = "createOrderFallback"
13
    )
14
    public OrderResult createOrder(OrderRequest request) {
15
        // 调用下游服务
16
        PaymentResult payment = paymentService.pay(request);
17
        InventoryResult inventory = inventoryService.deduct(request);
18
        return new OrderResult(payment, inventory);
19
    }
20

21
    // 熔断/限流时的处理逻辑
22
    public OrderResult createOrderBlockHandler(OrderRequest request,
23
                                               BlockException ex) {
24
        log.warn("订单服务被熔断: {}", ex.getClass().getSimpleName());
25
        return OrderResult.builder()
26
            .success(false)
27
            .message("系统繁忙，请稍后重试")
28
            .orderId(null)
29
            .build();
30
    }
31

32
    // 业务异常时的降级逻辑
33
    public OrderResult createOrderFallback(OrderRequest request,
34
                                           Throwable ex) {
35
        log.error("订单创建失败，执行降级: ", ex);
36

37
        // 返回降级数据
38
        return OrderResult.builder()
39
            .success(false)
40
            .message("订单提交失败，请重试")
41
            .orderId(generateTempOrderId())
42
            .needRetry(true)
43
            .build();
44
    }
45
}

2. 编程式配置（规则 API）#

1
@Configuration
2
public class SentinelRuleConfig {
3

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

8
        // 支付服务熔断规则
9
        rules.add(new DegradeRule("paymentService")
10
            .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO)
11
            .setCount(0.3)              // 异常率 30%
12
            .setTimeWindow(30)          // 熔断 30 秒
13
            .setMinRequestAmount(20)
14
            .setStatIntervalMs(1000));
15

16
        // 库存服务慢调用熔断
17
        rules.add(new DegradeRule("inventoryService")
18
            .setGrade(RuleConstant.DEGRADE_GRADE_RT)
19
            .setCount(1000)             // RT > 1秒
20
            .setSlowRatioThreshold(0.5) // 慢调用 50%
21
            .setTimeWindow(20)
22
            .setMinRequestAmount(10));
23

24
        DegradeRuleManager.loadRules(rules);
25
    }
26
}

3. 动态配置（Nacos 集成）#

1
@Configuration
2
public class SentinelNacosConfig {
3

4
    @Bean
5
    public Converter<String, List<DegradeRule>> degradeRuleConverter() {
6
        return source -> JSON.parseArray(source, DegradeRule.class);
7
    }
8

9
    @PostConstruct
10
    public void initNacosDataSource() {
11
        String remoteAddress = "localhost:8848";
12
        String groupId = "SENTINEL_GROUP";
13
        String dataId = "degrade-rules";
14

15
        ReadableDataSource<String, List<DegradeRule>> degradeRuleDataSource =
16
            new NacosDataSource<>(remoteAddress, groupId, dataId,
17
                source -> JSON.parseArray(source, DegradeRule.class));
18

19
        DegradeRuleManager.registerDataSource(degradeRuleDataSource);
20
    }
21
}

四、多级降级策略设计#

1. 核心链路保护架构#

1
@Service
2
public class MultiLevelDegradeService {
3

4
    /**
5
     * 三级降级策略：
6
     * Level 1: 正常调用完整服务
7
     * Level 2: 调用缓存数据
8
     * Level 3: 返回兜底数据
9
     */
10
    @SentinelResource(
11
        value = "getProductDetail",
12
        blockHandler = "getProductDetailBlock",
13
        fallback = "getProductDetailFallback"
14
    )
15
    public ProductDetail getProductDetail(Long productId) {
16
        // Level 1: 完整服务
17
        ProductDetail detail = productService.getDetailFromDB(productId);
18
        RecommendList recommends = recommendService.getRecommends(productId);
19
        ReviewList reviews = reviewService.getReviews(productId);
20

21
        return ProductDetail.builder()
22
            .basic(detail)
23
            .recommends(recommends)
24
            .reviews(reviews)
25
            .build();
26
    }
27

28
    // Level 2: 缓存降级
29
    public ProductDetail getProductDetailFallback(Long productId, Throwable ex) {
30
        log.warn("降级到缓存数据: productId={}", productId);
31

32
        // 尝试从缓存获取
33
        ProductDetail cached = redisCache.get("product:" + productId);
34
        if (cached != null) {
35
            cached.setFromCache(true);
36
            return cached;
37
        }
38

39
        // 缓存未命中，继续降级
40
        return getProductDetailDefaultValue(productId);
41
    }
42

43
    // Level 3: 兜底数据
44
    private ProductDetail getProductDetailDefaultValue(Long productId) {
45
        log.warn("使用兜底数据: productId={}", productId);
46

47
        return ProductDetail.builder()
48
            .productId(productId)
49
            .available(false)
50
            .message("商品信息暂时无法获取")
51
            .recommends(Collections.emptyList())
52
            .reviews(Collections.emptyList())
53
            .build();
54
    }
55

56
    // 熔断处理
57
    public ProductDetail getProductDetailBlock(Long productId, BlockException ex) {
58
        log.error("服务熔断: productId={}, reason={}",
59
                  productId, ex.getClass().getSimpleName());
60

61
        // 直接返回 Level 3 兜底数据
62
        return getProductDetailDefaultValue(productId);
63
    }
64
}

2. 核心与非核心链路分离#

1
@Service
2
public class OrderProcessService {
3

4
    // 核心链路：订单创建（必须成功）
5
    @SentinelResource(
6
        value = "coreOrderCreate",
7
        blockHandler = "coreOrderBlockHandler"
8
    )
9
    public OrderResult createCoreOrder(OrderRequest request) {
10
        // 只保留核心逻辑
11
        String orderId = orderService.createOrder(request);
12
        paymentService.createPayment(orderId, request.getAmount());
13

14
        // 异步处理非核心逻辑
15
        asyncExecutor.execute(() -> {
16
            try {
17
                sendNotification(orderId);
18
                updateRecommendSystem(request);
19
            } catch (Exception e) {
20
                log.error("非核心逻辑失败，但不影响订单", e);
21
            }
22
        });
23

24
        return OrderResult.success(orderId);
25
    }
26

27
    // 非核心链路：营销活动（可降级）
28
    @SentinelResource(
29
        value = "marketingPromotion",
30
        fallback = "marketingPromotionFallback"
31
    )
32
    public PromotionInfo getPromotion(Long userId) {
33
        return marketingService.getPersonalizedPromotion(userId);
34
    }
35

36
    // 营销降级：返回通用活动
37
    public PromotionInfo marketingPromotionFallback(Long userId, Throwable ex) {
38
        log.warn("营销服务降级，返回默认活动");
39
        return PromotionInfo.getDefaultPromotion();
40
    }
41
}

五、实战最佳实践#

1. 分级熔断配置模板#

1
@Component
2
public class CircuitBreakerTemplate {
3

4
    /**
5
     * 根据服务重要性配置不同的熔断策略
6
     */
7
    public void configureDegradeRules() {
8
        // P0 核心服务：严格熔断
9
        addCoreServiceRule("paymentService", 0.05, 500, 60);
10
        addCoreServiceRule("orderService", 0.05, 300, 60);
11

12
        // P1 重要服务：适中熔断
13
        addImportantServiceRule("inventoryService", 0.2, 1000, 30);
14
        addImportantServiceRule("userService", 0.2, 1000, 30);
15

16
        // P2 非核心服务：宽松熔断
17
        addNormalServiceRule("recommendService", 0.5, 2000, 10);
18
        addNormalServiceRule("reviewService", 0.5, 2000, 10);
19
    }
20

21
    private void addCoreServiceRule(String resource, double exceptionRatio,
22
                                    int rt, int timeWindow) {
23
        DegradeRule rule = new DegradeRule(resource)
24
            .setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO)
25
            .setCount(exceptionRatio)
26
            .setTimeWindow(timeWindow)
27
            .setMinRequestAmount(50)    // 高流量阈值
28
            .setStatIntervalMs(1000);
29

30
        DegradeRuleManager.loadRules(Collections.singletonList(rule));
31
    }
32
}

2. 监控与告警#

1
@Component
2
public class SentinelMonitor {
3

4
    @Scheduled(fixedRate = 10000)
5
    public void monitorCircuitBreaker() {
6
        Map<String, DegradeRule> rules = DegradeRuleManager.getRules()
7
            .stream()
8
            .collect(Collectors.toMap(DegradeRule::getResource, r -> r));
9

10
        for (Map.Entry<String, DegradeRule> entry : rules.entrySet()) {
11
            String resource = entry.getKey();
12

13
            // 检查熔断状态
14
            if (isCircuitBreakerOpen(resource)) {
15
                sendAlert(resource, "熔断器开启");
16
            }
17

18
            // 统计降级次数
19
            long degradeCount = getDegradeCount(resource);
20
            if (degradeCount > 100) {
21
                sendAlert(resource, "降级次数过高: " + degradeCount);
22
            }
23
        }
24
    }
25

26
    private void sendAlert(String resource, String message) {
27
        log.error("【告警】资源: {}, 消息: {}", resource, message);
28
        // 发送到告警系统
29
        alertService.send(resource, message);
30
    }
31
}

3. 灰度降级策略#

1
@Service
2
public class GrayDegradeService {
3

4
    /**
5
     * 根据用户等级实施差异化降级
6
     */
7
    @SentinelResource(value = "vipService")
8
    public ServiceResult processRequest(UserContext user) {
9
        // VIP 用户：完整服务
10
        if (user.isVip()) {
11
            return fullService.process(user);
12
        }
13

14
        // 普通用户：在高峰期降级
15
        if (isHighTrafficPeriod()) {
16
            return degradedService.process(user);
17
        }
18

19
        return fullService.process(user);
20
    }
21

22
    /**
23
     * 基于流量百分比的降级
24
     */
25
    public ServiceResult processWithTrafficShaping(Request request) {
26
        int randomValue = ThreadLocalRandom.current().nextInt(100);
27

28
        // 10% 流量降级
29
        if (randomValue < 10) {
30
            return degradedService.handle(request);
31
        }
32

33
        return normalService.handle(request);
34
    }
35
}

六、关键配置建议#

服务类型	异常比例	RT 阈值	熔断时长	最小请求数
核心服务	5%	300ms	60s	50
重要服务	20%	1000ms	30s	20
一般服务	50%	2000ms	10s	10

七、注意事项#

避免雪崩：熔断时长不宜过短，给下游服务恢复时间
监控覆盖：所有熔断降级都要有监控和告警
测试验证：压测验证熔断阈值是否合理
文档化：明确记录每个服务的降级策略和预期行为
动态调整：通过配置中心实现规则热更新

通过合理配置 Sentinel 的熔断降级机制，可以有效保障微服务架构的稳定性和核心链路的可用性！