Sentinel 降级与熔断

@FeignClient(
    name = "stock-service",
    path = "/stock",
    fallbackFactory = StockFeignFallbackFactory.class
)
public interface StockFeignClient {

    @GetMapping("/{productId}")
    StockVO getStock(@PathVariable("productId") Long productId);
}

@Component
public class StockFeignFallbackFactory implements FallbackFactory<StockFeignClient> {

    @Override
    public StockFeignClient create(Throwable cause) {
        log.error("库存服务调用失败，触发降级", cause);
        return productId -> {
            StockVO fallback = new StockVO();
            fallback.setProductId(productId);
            fallback.setQuantity(0);
            fallback.setMessage("库存查询暂不可用，请稍后重试");
            return fallback;
        };
    }
}

@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private StockFeignClient stockFeignClient;

    @GetMapping("/stock/{productId}")
    @SentinelResource(
        value = "queryStock",
        blockHandler = "queryStockBlock",
        fallback = "queryStockFallback"
    )
    public Result<StockVO> queryStock(@PathVariable Long productId) {
        StockVO stock = stockFeignClient.getStock(productId);
        return Result.success(stock);
    }

    // 熔断/限流触发时调用
    public Result<StockVO> queryStockBlock(Long productId, BlockException ex) {
        log.warn("queryStock 被 Sentinel 限流或熔断，productId={}", productId);
        return Result.error(429, "查询过于频繁或服务暂不可用，请稍后重试");
    }

    // 业务异常时调用
    public Result<StockVO> queryStockFallback(Long productId, Throwable ex) {
        log.error("queryStock 业务异常，productId={}", productId, ex);
        return Result.error(500, "服务暂时不可用");
    }
}

@Component
public class DegradeRuleConfig implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
        List<DegradeRule> rules = new ArrayList<>();

        DegradeRule rule = new DegradeRule("queryStock")
                .setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType())
                .setCount(500)                     // 最大 RT 500ms
                .setSlowRatioThreshold(0.5)        // 慢调用比例 50%
                .setMinRequestAmount(5)            // 最小请求数
                .setStatIntervalMs(10000)          // 统计窗口 10s
                .setTimeWindow(10);                // 熔断时长 10s
        rules.add(rule);

        DegradeRuleManager.loadRules(rules);
    }
}

@Service
public class SmsService {

    @Autowired
    private PrimarySmsClient primarySmsClient;    // 主链路：某第三方短信服务商

    @Autowired
    private AliyunSmsClient aliyunSmsClient;      // 备用链路：阿里云短信

    @SentinelResource(
        value = "sendVerifyCode",
        blockHandler = "sendVerifyCodeBlock",
        fallback = "sendVerifyCodeFallback"
    )
    public SmsResult sendVerifyCode(String phone) {
        // 主链路发送
        return primarySmsClient.send(phone, generateCode());
    }

    // 熔断/限流触发 → 直接切换备用链路
    public SmsResult sendVerifyCodeBlock(String phone, BlockException ex) {
        log.warn("主链路被 Sentinel 熔断，切换备用链路发送短信，phone={}", phone);
        return aliyunSmsClient.send(phone, generateCode());
    }

    // 业务异常（如主链路返回异常）→ 也切换备用链路
    public SmsResult sendVerifyCodeFallback(String phone, Throwable ex) {
        log.warn("主链路发送异常，切换备用链路发送短信，phone={}", phone, ex);
        return aliyunSmsClient.send(phone, generateCode());
    }

    private String generateCode() {
        return String.valueOf((int) (Math.random() * 900000 + 100000));
    }
}

@Component
public class SmsDegradeRuleConfig implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
        List<DegradeRule> rules = new ArrayList<>();

        DegradeRule rule = new DegradeRule("sendVerifyCode")
                .setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType())
                .setCount(0.5)                     // 异常比例 50%
                .setMinRequestAmount(5)            // 最小请求数
                .setStatIntervalMs(10000)          // 统计窗口 10s
                .setTimeWindow(20);                // 熔断时长 20s
        rules.add(rule);

        DegradeRuleManager.loadRules(rules);
    }
}

@FeignClient(
    name = "stock-service",
    path = "/stock",
    fallbackFactory = StockFeignFallbackFactory.class
)
public interface StockFeignClient {

    @GetMapping("/{productId}")
    StockVO getStock(@PathVariable("productId") Long productId);

    @GetMapping("/batch")
    List<StockVO> getStockBatch(@RequestParam("productIds") List<Long> productIds);
}

@Component
@Slf4j
public class StockFeignFallbackFactory implements FallbackFactory<StockFeignClient> {

    @Override
    public StockFeignClient create(Throwable cause) {
        // cause 包含具体的异常信息，可用于精细化降级
        if (cause instanceof RetryableException) {
            log.error("库存服务连接失败，触发降级", cause);
        } else if (cause instanceof FeignException.ServiceUnavailable) {
            log.error("库存服务返回 503，触发降级", cause);
        } else {
            log.error("库存服务调用异常，触发降级", cause);
        }

        return new StockFeignClient() {

            @Override
            public StockVO getStock(Long productId) {
                StockVO fallback = new StockVO();
                fallback.setProductId(productId);
                fallback.setQuantity(0);
                fallback.setMessage("库存查询暂不可用");
                return fallback;
            }

            @Override
            public List<StockVO> getStockBatch(List<Long> productIds) {
                // 批量降级：每个商品返回默认库存 0
                return productIds.stream()
                        .map(id -> {
                            StockVO vo = new StockVO();
                            vo.setProductId(id);
                            vo.setQuantity(0);
                            vo.setMessage("库存查询暂不可用");
                            return vo;
                        })
                        .collect(Collectors.toList());
            }
        };
    }
}

@RestController
@RequestMapping("/order")
@Slf4j
public class OrderController {

    @Autowired
    private StockFeignClient stockFeignClient;

    @GetMapping("/detail/{productId}")
    public Result<OrderDetailVO> getOrderDetail(@PathVariable Long productId) {
        // Feign 调用已自动受到 Sentinel 保护
        // 失败时 FallbackFactory 返回降级结果
        StockVO stock = stockFeignClient.getStock(productId);

        OrderDetailVO detail = new OrderDetailVO();
        detail.setProductId(productId);
        detail.setStock(stock);

        if (stock.getQuantity() == 0 && "库存查询暂不可用".equals(stock.getMessage())) {
            // 降级提示：引导用户稍后重试
            detail.setTip("当前库存信息加载失败，显示为默认值，请刷新重试");
        }

        return Result.success(detail);
    }
}