服务治理

熔断

Sentinel 熔断

@SentinelResource(
    value = "getUser",
    blockHandler = "getUserBlockHandler",
    fallback = "getUserFallback"
)
public User getUser(Long id) {
    return userService.getUser(id);
}

// 限流/熔断处理
public User getUserBlockHandler(Long id, BlockException ex) {
    return new User(-1L, "服务繁忙");
}

// 异常降级
public User getUserFallback(Long id, Throwable throwable) {
    return new User(-1L, "服务异常");
}

熔断规则

// 慢调用比例熔断
DegradeRule rule = new DegradeRule("getUser")
    .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType())
    .setCount(0.5)           // 慢调用比例阈值
    .setSlowRatioThreshold(1000)  // 慢调用 RT 阈值
    .setMinRequestAmount(5)  // 最小请求数
    .setStatIntervalMs(10000)  // 统计时长
    .setTimeWindow(10);      // 熔断时长

// 异常比例熔断
DegradeRule rule = new DegradeRule("getUser")
    .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
    .setCount(0.5)           // 异常比例阈值
    .setMinRequestAmount(5)
    .setStatIntervalMs(10000)
    .setTimeWindow(10);

熔断状态

┌─────────────────────────────────────────────────────────┐
│                    熔断状态转换                          │
├─────────────────────────────────────────────────────────┤
│                                                         │
│    ┌────────┐    触发熔断    ┌────────┐                │
│    │ CLOSED │ ────────────> │  OPEN  │                │
│    └────────┘               └────────┘                │
│         ▲                        │                     │
│         │                        │ 熔断时间结束         │
│         │                        ▼                     │
│         │    探测成功      ┌───────────┐              │
│         └───────────────── │ HALF_OPEN │              │
│                            └───────────┘              │
│                                  │                     │
│                                  │ 探测失败            │
│                                  ▼                     │
│                            ┌────────┐                 │
│                            │  OPEN  │                 │
│                            └────────┘                 │
│                                                         │
└─────────────────────────────────────────────────────────┘

限流

Sentinel 限流

// 注解方式
@SentinelResource(value = "createOrder", blockHandler = "createOrderBlockHandler")
public Order createOrder(OrderDTO dto) {
    return orderService.create(dto);
}

public Order createOrderBlockHandler(OrderDTO dto, BlockException ex) {
    throw new BusinessException("系统繁忙，请稍后重试");
}

限流规则

// QPS 限流
FlowRule rule = new FlowRule("createOrder")
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(100)           // QPS 阈值
    .setStrategy(RuleConstant.STRATEGY_DIRECT)
    .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);

// 并发线程数限流
FlowRule rule = new FlowRule("createOrder")
    .setGrade(RuleConstant.FLOW_GRADE_THREAD)
    .setCount(10);           // 并发线程数

// 关联限流
FlowRule rule = new FlowRule("queryOrder")
    .setStrategy(RuleConstant.STRATEGY_RELATE)
    .setRefResource("createOrder")  // 关联资源
    .setCount(100);

// 链路限流
FlowRule rule = new FlowRule("getUser")
    .setStrategy(RuleConstant.STRATEGY_CHAIN)
    .setRefResource("createOrder")  // 入口资源
    .setCount(100);

流控效果

// 直接拒绝（默认）
.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT)

// 预热（Warm Up）
.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP)
.setWarmUpPeriodSec(10)  // 预热时长

// 排队等待
.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER)
.setMaxQueueingTimeMs(500)  // 最大等待时间

降级

降级策略

@Service
public class OrderService {
    
    @Autowired
    private UserClient userClient;
    
    public Order createOrder(Long userId, OrderDTO dto) {
        User user;
        try {
            user = userClient.getUser(userId);
        } catch (Exception e) {
            // 降级：使用缓存或默认值
            user = userCache.get(userId);
            if (user == null) {
                user = new User(userId, "未知用户");
            }
        }
        
        return doCreateOrder(user, dto);
    }
}

Feign 降级

@FeignClient(name = "user-service", fallbackFactory = UserClientFallbackFactory.class)
public interface UserClient {
    @GetMapping("/users/{id}")
    User getUser(@PathVariable Long id);
}

@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {
    @Override
    public UserClient create(Throwable cause) {
        return new UserClient() {
            @Override
            public User getUser(Long id) {
                log.error("调用 user-service 失败", cause);
                return new User(id, "降级用户");
            }
        };
    }
}

热点参数限流

@SentinelResource(value = "getProduct", blockHandler = "getProductBlockHandler")
public Product getProduct(Long productId) {
    return productService.getById(productId);
}

// 热点规则
ParamFlowRule rule = new ParamFlowRule("getProduct")
    .setParamIdx(0)          // 参数索引
    .setCount(100)           // 阈值
    .setGrade(RuleConstant.FLOW_GRADE_QPS);

// 特定参数值例外
rule.setParamFlowItemList(Arrays.asList(
    new ParamFlowItem()
        .setObject("1001")   // 热门商品 ID
        .setClassType(Long.class.getName())
        .setCount(1000)      // 更高阈值
));

系统保护

// 系统规则
SystemRule rule = new SystemRule()
    .setHighestSystemLoad(3.0)      // 最高系统负载
    .setHighestCpuUsage(0.8)        // 最高 CPU 使用率
    .setAvgRt(100)                  // 平均 RT
    .setMaxThread(200)              // 最大并发线程数
    .setQps(1000);                  // 入口 QPS

配置持久化

# Nacos 配置
spring:
  cloud:
    sentinel:
      datasource:
        flow:
          nacos:
            server-addr: localhost:8848
            dataId: ${spring.application.name}-flow-rules
            groupId: SENTINEL_GROUP
            rule-type: flow
        degrade:
          nacos:
            server-addr: localhost:8848
            dataId: ${spring.application.name}-degrade-rules
            groupId: SENTINEL_GROUP
            rule-type: degrade