Spring Cloud Sentinel 熔断降级实战与原理解析

Sentinel vs Hystrix 对比

Sentinel 实战教程

环境准备

1. 添加依赖

首先引入 Spring Cloud Alibaba 的依赖管理，并添加 Sentinel 核心及 Nacos 数据源依赖。

<!-- 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. 配置文件

配置 Sentinel 控制台地址及心跳信息，确保应用能上报监控数据。

server:
  port: 8080
spring:
  application:
    name: order-service
  cloud:
    sentinel:
      # 开启 Sentinel
      enabled: true
      # 传输配置
      transport:
        dashboard: localhost:8080
        # 服务与控制台通信端口（本地启动需要）
        port: 8719
        # 心跳配置
        heartbeat-interval-ms: 5000
        # 取消 HTTP 收敛 URL 的合并（方便 Sentinel 管理）
        web-context-unify: false
      # 限流处理
      block-handler: com.example.handler.BlockExceptionHandler
      # 降级处理
      fallback: com.example.handler.FallbackExceptionHandler
management:
  endpoints:
    web:
      exposure:
        include: '*'

基础示例：注解方式

3. 主启动类

标准的 Spring Boot 启动类，无需特殊改动。

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

4. 创建订单服务

使用 @SentinelResource 注解标记需要保护的资源。这里要注意 blockHandler 和 fallback 的区别：前者针对限流/系统保护异常，后者针对业务异常。

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. 控制器

暴露 REST 接口供测试，同时包含一个慢调用接口用于演示 RT 熔断。

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. 流控规则配置

这里展示了如何编程式地设置 QPS 限流和多种熔断策略（慢调用比例、异常比例、异常数）。

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);
        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);
        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);
        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);
        rule3.setMinRequestAmount(5);
        rules.add(rule3);

        DegradeRuleManager.loadRules(rules);
    }
}

OpenFeign 集成

7. Feign 客户端集成 Sentinel

在 application.yml 中开启 Feign 对 Sentinel 的支持即可。

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

编写 Feign 客户端时，指定 fallback 类来处理降级逻辑。

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 数据源配置

在配置文件中指定 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 规则配置示例

在 Nacos 控制台创建对应的 JSON 文件。

流控规则 (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}]

全局异常处理

为了让前端收到统一的错误格式，建议统一捕获 Sentinel 抛出的异常。

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. 若业务执行异常且达到熔断阈值，进入熔断状态。
6. 熔断期间，请求直接返回降级结果。
7. 经过冷却时间后，进入半开状态，允许少量请求探测。
8. 若探测成功，关闭熔断；若失败，继续熔断。

测试验证

测试场景

我们可以使用简单的脚本或工具来模拟不同场景。

# 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. 调用备用服务

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

3. 监控告警

不要只依赖控制台，建议接入 Prometheus 或自建监控，对熔断状态进行告警。

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@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