Spring Cloud Sentinel快速入门步骤

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

# application.yml
spring:
  application:
    name: your-service-name
# 配置 Sentinel Dashboard 地址
cloud:
  sentinel:
    transport:
      dashboard: localhost:8080

import com.alibaba.csp.sentinel.annotation.SentinelResource;
@Service
public class OrderService {
    // 使用 @SentinelResource 保护方法
    @SentinelResource(value = "createOrder", 
                      blockHandler = "handleBlock", // 违背限流/降级规则时调用的方法
                      fallback = "handleFallback") // 业务异常时调用的方法
    public String createOrder(String userId) {
        // 核心业务逻辑
        return "Order created successfully";
    }
    // 限流或降级时的处理逻辑（参数要匹配原方法）
    public String handleBlock(String userId, BlockException ex) {
        System.out.println("Blocked by Sentinel: " + ex.getMessage());
        return "System busy, please try later.";
    }
    // 业务异常时的处理逻辑（Throwable 参数）
    public String handleFallback(String userId, Throwable ex) {
        System.out.println("Service logic error: " + ex.getMessage());
        return "Internal error occurred.";
    }
}

@Service
public class OrderService {
    @SentinelResource(
        value = "createOrder",
        blockHandler = "handleCreateOrderBlock",
        fallback = "createOrderFallback"
    )
    public Order createOrder(Order order) {
        // 业务逻辑
        return orderMapper.insert(order);
    }
    // 处理限流（BlockException）
    public Order handleCreateOrderBlock(Order order, BlockException e) {
        log.warn("订单创建被限流了");
        return null;
    }
    // 处理熔断降级（业务异常）
    public Order createOrderFallback(Order order, Throwable e) {
        log.warn("订单创建失败，执行降级方案");
        return new Order();  // 返回默认值
    }
}

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    @PostMapping
    @SentinelResource(
        value = "createOrderApi",
        blockHandler = "handleBlock"
    )
    public ApiResponse<Order> createOrder(@RequestBody Order order) {
        Order result = orderService.createOrder(order);
        return ApiResponse.success(result);
    }
    public ApiResponse<Order> handleBlock(Order order, BlockException e) {
        return ApiResponse.fail("系统繁忙，请稍后再试");
    }
}

@FeignClient(name = "stock-service", fallback = StockServiceFallback.class)
public interface StockServiceClient {
    @PostMapping("/api/stock/deduct")
    @SentinelResource(
        value = "deductStock",
        fallback = "deductStockFallback"
    )
    Stock deductStock(@RequestParam Long productId, @RequestParam Integer quantity);
    default Stock deductStockFallback(Long productId, Integer quantity) {
        log.warn("库存服务调用失败，执行降级");
        return new Stock();
    }
}

@Service
public class AsyncOrderService {
    @Async
    @SentinelResource(
        value = "asyncProcessOrder",
        blockHandler = "handleAsyncBlock"
    )
    public void processOrderAsync(Order order) {
        // 异步处理逻辑
        doSomeHeavyWork(order);
    }
    public void handleAsyncBlock(Order order, BlockException e) {
        log.warn("异步处理被限流");
    }
}

// 错误示范
@Mapper
public interface OrderMapper {
    @SentinelResource("selectOrder")  // ❌ 不要加这儿
    Order selectById(Long id);
}
// 原因：
// 1. Mapper直接操作数据库，没有业务逻辑
// 2. 限流应该在业务层面
// 3. 多个Service可能调用同一个Mapper

@Service
public class OrderService {
    @SentinelResource("privateMethod")  // ❌ 不要加
    private void privateMethod() {
        // ...
    }
    // 原因：Sentinel是通过代理实现的，私有方法代理不了
}

@Service
public class OrderService {
    @SentinelResource("constructor")  // ❌ 不要加
    public OrderService() {
        // ...
    }
}

@Service
public class OrderService {
    @SentinelResource("staticMethod")  // ❌ 不要加
    public static void staticMethod() {
        // ...
    }
    // 原因：static方法不能被代理
}

// ===== Controller层 =====
@RestController
@RequestMapping("/api/orders")
public class OrderController {
    @SentinelResource(
        value = "createOrderApi",  // API级别的限流
        blockHandler = "apiBlockHandler"
    )
    @PostMapping
    public ApiResponse<Order> createOrder(@RequestBody Order order) {
        return ApiResponse.success(orderService.createOrder(order));
    }
    public ApiResponse<Order> apiBlockHandler(Order order, BlockException e) {
        return ApiResponse.fail("API请求过于频繁");
    }
}
// ===== Service层 =====
@Service
public class OrderService {
    @SentinelResource(
        value = "createOrderService",  // 业务级别的限流
        blockHandler = "serviceBlockHandler",
        fallback = "createOrderFallback"
    )
    public Order createOrder(Order order) {
        // 实际业务逻辑
        return orderMapper.insert(order);
    }
    public Order serviceBlockHandler(Order order, BlockException e) {
        return null;  // 限流处理
    }
    public Order createOrderFallback(Order order, Throwable e) {
        return new Order();  // 降级处理
    }
}

用户请求
    ↓
Controller层（@SentinelResource）
    ├─ 控制HTTP请求的流量
    ├─ 返回友好的错误信息
    └─ 保护系统入口
    ↓
Service层（@SentinelResource）
    ├─ 控制业务操作的流量
    ├─ 保护核心业务逻辑
    └─ 其他Service也可能调用

@SentinelResource(
    value = "createOrder",              // 资源名，必需
    blockHandler = "handleBlock",       // 限流/降级时的处理方法
    blockHandlerClass = BlockHandlers.class,  // 指定外部类
    fallback = "fallbackMethod",        // 业务异常时的降级方法
    fallbackClass = FallbackMethods.class,    // 指定外部类
    exceptionsToIgnore = {IOException.class}  // 忽略的异常
)
public Order createOrder(Order order) {
    // ...
}