Spring Cloud 熔断降级详解：Sentinel 实战与保险丝类比

核心概念对比

Sentinel vs Hystrix 对比

Sentinel 实战教程

环境准备

1. 添加依赖

<!-- Spring Cloud Alibaba -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2022.0.0.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
<dependencies>
    <!-- Sentinel 核心依赖 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>
    <!-- Sentinel 数据源-Nacos（持久化规则） -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
    </dependency>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

2. 配置文件

server:
  port: 8080
spring:
  application:
    name: order-service
  cloud:
    sentinel:
      enabled: true
      transport:
        dashboard: localhost:8080
        port: 8719
      heartbeat-interval-ms: 5000
      web-context-unify: false
      block-handler: com.example.handler.BlockExceptionHandler
      fallback: com.example.handler.FallbackExceptionHandler
management:
  endpoints:
    web:
      exposure:
        include: '*'

基础示例：注解方式

3. 主启动类

@SpringBootApplication
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

4. 创建订单服务

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    /**
     * 创建订单接口
     * @SentinelResource 注解说明：
     * - value: 资源名称，唯一标识
     * - blockHandler: 限流/熔断时的处理方法
     * - fallback: 降级时的处理方法
     */
    @SentinelResource(
        value = "createOrder",
        blockHandler = "handleBlock",
        fallback = "handleFallback"
    )
    public String createOrder(String productId, Integer count) {
        // 模拟业务逻辑
        System.out.println("创建订单：商品 ID=" + productId + ", 数量=" + count);
        // 模拟异常情况（用于测试降级）
        if ("error".equals(productId)) {
            throw new RuntimeException("商品不存在");
        }
        return "订单创建成功！";
    }

    /**
     * 限流/熔断处理方法
     * 注意：方法签名必须与原方法一致，最后添加 BlockException 参数
     */
    public String handleBlock(String productId, Integer count, BlockException ex) {
        return "系统繁忙，请稍后再试（限流/熔断）";
    }

    /**
     * 降级处理方法
     * 注意：方法签名必须与原方法一致，最后可添加 Throwable 参数
     */
    public String handleFallback(String productId, Integer count, Throwable ex) {
        return "服务暂时不可用，已启动降级处理";
    }
}

5. 控制器

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/order")
public class OrderController {
    @Autowired
    private OrderService orderService;

    @PostMapping("/create")
    public String createOrder(@RequestParam String productId, @RequestParam Integer count) {
        return orderService.createOrder(productId, count);
    }

    /**
     * 测试接口：模拟慢调用（用于测试 RT 熔断）
     */
    @GetMapping("/slow")
    @SentinelResource(value = "slowApi", blockHandler = "handleBlock")
    public String slowApi() throws InterruptedException {
        Thread.sleep(1000); // 模拟慢调用
        return "正常响应";
    }

    public String handleBlock(BlockException ex) {
        return "接口响应太慢，已触发熔断";
    }
}

高级配置：规则定义

6. 流控规则配置

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

@Configuration
public class SentinelRuleConfig {
    @PostConstruct
    public void initRules() {
        initFlowRules();
        initDegradeRules();
    }

    /**
     * 流量控制规则
     */
    private void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        // 规则 1：创建订单接口限流
        FlowRule rule1 = new FlowRule();
        rule1.setResource("createOrder");
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS); // QPS 限流
        rule1.setCount(10); // 每秒最多 10 个请求
        rule1.setStrategy(RuleConstant.STRATEGY_DIRECT); // 直接拒绝
        rule1.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 快速失败
        rules.add(rule1);

        // 规则 2：慢查询 API 限流
        FlowRule rule2 = new FlowRule();
        rule2.setResource("slowApi");
        rule2.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule2.setCount(2); // 每秒最多 2 个请求
        rule2.setStrategy(RuleConstant.STRATEGY_DIRECT);
        rules.add(rule2);

        FlowRuleManager.loadRules(rules);
    }

    /**
     * 熔断降级规则
     */
    private void initDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();
        // 规则 1：慢调用比例熔断
        DegradeRule rule1 = new DegradeRule();
        rule1.setResource("slowApi");
        rule1.setGrade(RuleConstant.DEGRADE_GRADE_RT); // 慢调用比例
        rule1.setCount(500); // 响应时间超过 500ms 视为慢调用
        rule1.setTimeWindow(10); // 熔断时长 10 秒
        rule1.setMinRequestAmount(5); // 最小请求数
        rule1.setSlowRatioThreshold(0.5); // 慢调用比例阈值 50%
        rules.add(rule1);

        // 规则 2：异常比例熔断
        DegradeRule rule2 = new DegradeRule();
        rule2.setResource("createOrder");
        rule2.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO); // 异常比例
        rule2.setCount(0.5); // 异常比例 50%
        rule2.setTimeWindow(10); // 熔断时长 10 秒
        rule2.setMinRequestAmount(5); // 最小请求数
        rules.add(rule2);

        // 规则 3：异常数熔断
        DegradeRule rule3 = new DegradeRule();
        rule3.setResource("createOrder");
        rule3.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT); // 异常数
        rule3.setCount(10); // 异常数超过 10 个
        rule3.setTimeWindow(10); // 熔断时长 10 秒
        rule3.setMinRequestAmount(5);
        rules.add(rule3);

        DegradeRuleManager.loadRules(rules);
    }
}

OpenFeign 集成

7. Feign 客户端集成 Sentinel

# application.yml
feign:
  sentinel:
    enabled: true # 开启 Feign 对 Sentinel 的支持

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * 库存服务 Feign 客户端
 * fallback: 指定降级处理类
 */
@FeignClient(
    name = "inventory-service",
    path = "/inventory",
    fallback = InventoryServiceFallback.class
)
public interface InventoryServiceClient {
    @GetMapping("/deduct")
    String deductStock(@RequestParam("productId") String productId, @RequestParam("count") Integer count);
}

8. Feign 降级处理

import org.springframework.stereotype.Component;

@Component
public class InventoryServiceFallback implements InventoryServiceClient {
    @Override
    public String deductStock(String productId, Integer count) {
        // 降级逻辑：返回默认值或缓存数据
        return "库存服务暂时不可用，已为您预留库存，稍后将自动扣减";
    }
}

规则持久化（Nacos）

9. 添加 Nacos 数据源配置

spring:
  cloud:
    sentinel:
      datasource:
        flow:
          nacos:
            server-addr: localhost:8848
            data-id: ${spring.application.name}-flow-rules
            group-id: SENTINEL_GROUP
            rule-type: flow
            data-type: json
        degrade:
          nacos:
            server-addr: localhost:8848
            data-id: ${spring.application.name}-degrade-rules
            group-id: SENTINEL_GROUP
            rule-type: degrade
            data-type: json

10. Nacos 规则配置示例

流控规则 (order-service-flow-rules.json)

[{"resource":"createOrder","limitApp":"default","grade":1,"count":10,"strategy":0,"controlBehavior":0,"clusterMode":false}]

熔断规则 (order-service-degrade-rules.json)

[{"resource":"slowApi","grade":0,"count":500,"timeWindow":10,"minRequestAmount":5,"slowRatioThreshold":0.5,"statIntervalMs":1000}]

全局异常处理

11. 统一异常处理

import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
import java.util.HashMap;
import java.util.Map;

@RestControllerAdvice
public class GlobalExceptionHandler {
    /**
     * 统一处理 Sentinel 异常
     */
    @ExceptionHandler(BlockException.class)
    public Map<String, Object> handleBlockException(BlockException ex) {
        Map<String, Object> result = new HashMap<>();
        result.put("code", 429);
        result.put("message", "服务限流或熔断，请稍后重试");
        // 区分不同类型的异常
        if (ex instanceof FlowException) {
            result.put("type", "限流");
        } else if (ex instanceof DegradeException) {
            result.put("type", "熔断降级");
        } else if (ex instanceof ParamFlowException) {
            result.put("type", "热点参数限流");
        } else if (ex instanceof AuthorityException) {
            result.put("type", "授权规则不通过");
        }
        return result;
    }
}

完整工作流程

1. 客户端请求
2. Sentinel 拦截
3. 通过规则校验
   • 成功：执行业务逻辑 → 返回正常响应
   • 失败：触发限流 → 返回限流结果
4. 统计失败指标
   • 失败率超阈值？
     • 是：触发熔断 → 返回降级结果
     • 否：继续监控
5. 熔断时长计时
   • 进入半开状态
     • 允许单次请求探测
       • 恢复：关闭状态
       • 失败：继续熔断

测试验证

测试场景

# 1. 测试流控规则
# 使用 Apache Bench 进行压测
ab -n 100 -c 20 http://localhost:8080/order/create?productId=123&count=1

# 2. 测试慢调用熔断
# 访问慢接口多次
for i in {1..10}; do curl http://localhost:8080/order/slow; done

# 3. 测试异常熔断
# 调用会抛出异常的接口
curl http://localhost:8080/order/create?productId=error&count=1

Sentinel 控制台观察

访问 http://localhost:8080 可以看到：

1. 实时监控：QPS、响应时间、成功率等指标
2. 规则管理：动态配置流控、熔断规则
3. 簇点链路：查看服务调用链路
4. 机器列表：监控集群机器状态

最佳实践与生产建议

1. 熔断阈值设置建议

2. 降级策略建议

/**
 * 降级策略优先级：
 * 1. 返回缓存数据（最新缓存或默认值）
 * 2. 返回友好提示
 * 3. 调用备用服务
 */
public String degradeStrategy() {
    // 优先级 1：返回缓存
    String cached = cache.get(key);
    if (cached != null) {
        return cached;
    }
    // 优先级 2：返回默认值
    return "服务繁忙，请稍后重试";
}

3. 监控告警

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.util.List;

@Component
public class SentinelMonitor {
    @Scheduled(cron = "0/5 * * * * ?")
    public void monitorMetrics() {
        // 监控熔断状态
        List<DegradeRule> rules = DegradeRuleManager.getRules();
        for (DegradeRule rule : rules) {
            // 获取资源状态
            ResourceNode resourceNode = ClusterBuilderSlot.getClusterNode(rule.getResource());
            if (resourceNode != null) {
                double passQps = resourceNode.passQps();
                double blockQps = resourceNode.blockQps();
                double exception = resourceNode.totalException();
                // 发送告警
                if (blockQps > 0 || exception > 0) {
                    alertService.sendAlert("服务异常：资源=" + rule.getResource());
                }
            }
        }
    }
}

4. 生产环境检查清单

• 核心接口配置流控规则
• 依赖服务配置熔断规则
• 所有降级方法经过测试
• 规则持久化到配置中心
• 配置监控告警
• 降级数据准备充分
• 定期演练故障恢复

总结

熔断降级是微服务架构中保护系统稳定性的重要机制：

✅ 核心价值：

• 防止雪崩效应
• 保护核心服务
• 提升用户体验
• 保障系统可用性

✅ 关键要点：

• 合理设置阈值
• 完善降级策略
• 持久化规则配置
• 做好监控告警

✅ 实战建议：

• 从非核心接口开始实践
• 逐步完善核心接口保护
• 定期进行故障演练
• 持续优化规则参数

通过合理使用 Sentinel，可以有效提升微服务架构的稳定性和可靠性！

参考资料

• Sentinel 官方文档
• Spring Cloud Alibaba
• Sentinel GitHub