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

2. 配置文件

配置 application.yml，指定 Sentinel 控制台地址及降级处理类：

server:
  port: 8080

spring:
  application:
    name: order-service
  cloud:
    sentinel:
      enabled: true
      transport:
        dashboard: localhost:8080
        port: 8719
      web-context-unify: false
      block-handler: com.example.handler.BlockExceptionHandler
      fallback: com.example.handler.FallbackExceptionHandler

management:
  endpoints:
    web:
      exposure:
        include: '*'

基础示例：注解方式

主启动类

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

创建订单服务

使用 @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 {

    /**
     * 创建订单接口
     * 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 "服务暂时不可用，已启动降级处理";
    }
}

控制器

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 "接口响应太慢，已触发熔断";
    }
}

高级配置：规则定义

除了控制台配置，也可以通过代码动态加载规则。

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 集成

Feign 客户端集成

开启 Feign 对 Sentinel 的支持：

feign:
  sentinel:
    enabled: true

定义 Feign 客户端并指定降级类：

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

@FeignClient(
    name = "inventory-service",
    path = "/inventory",
    fallback = InventoryServiceFallback.class
)
public interface InventoryServiceClient {

    @GetMapping("/deduct")
    String deductStock(@RequestParam("productId") String productId,
                       @RequestParam("count") Integer count);
}

Feign 降级处理

import org.springframework.stereotype.Component;

@Component
public class InventoryServiceFallback implements InventoryServiceClient {

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

规则持久化（Nacos）

生产环境中建议将规则持久化到 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

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
  }
]

全局异常处理

统一捕获 Sentinel 抛出的异常，返回友好的 JSON 格式。

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. 探测成功则关闭熔断，失败则继续熔断。

测试验证

测试场景

• 压测流控：使用 Apache Bench 发送高频请求。

  ab -n 100 -c 20 http://localhost:8080/order/create?productId=123&count=1
  

• 测试慢调用熔断：多次访问慢接口。

  for i in {1..10}; do curl http://localhost:8080/order/slow; done
  

• 测试异常熔断：调用抛出异常的接口。

  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;

@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. 生产环境检查清单

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

总结

熔断降级是微服务架构中保护系统稳定性的重要机制。合理设置阈值、完善降级策略、持久化规则配置并做好监控告警，能有效防止雪崩效应，提升用户体验和系统可用性。建议从非核心接口开始实践，逐步完善核心接口保护，定期进行故障演练，持续优化规则参数。