<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", // 違背限流/降級規(guī)則時調(diào)用的方法
                      fallback = "handleFallback") // 業(yè)務異常時調(diào)用的方法
    public String createOrder(String userId) {
        // 核心業(yè)務邏輯
        return "Order created successfully";
    }
    // 限流或降級時的處理邏輯（參數(shù)要匹配原方法）
    public String handleBlock(String userId, BlockException ex) {
        System.out.println("Blocked by Sentinel: " + ex.getMessage());
        return "System busy, please try later.";
    }
    // 業(yè)務異常時的處理邏輯（Throwable 參數(shù)）
    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) {
        // 業(yè)務邏輯
        return orderMapper.insert(order);
    }
    // 處理限流（BlockException）
    public Order handleCreateOrderBlock(Order order, BlockException e) {
        log.warn("訂單創(chuàng)建被限流了");
        return null;
    }
    // 處理熔斷降級（業(yè)務異常）
    public Order createOrderFallback(Order order, Throwable e) {
        log.warn("訂單創(chuàng)建失敗，執(zhí)行降級方案");
        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("系統(tǒng)繁忙，請稍后再試");
    }
}

@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("庫存服務調(diào)用失敗，執(zhí)行降級");
        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直接操作數(shù)據(jù)庫，沒有業(yè)務邏輯
// 2. 限流應該在業(yè)務層面
// 3. 多個Service可能調(diào)用同一個Mapper

@Service
public class OrderService {
    @SentinelResource("privateMethod")  // ? 不要加
    private void privateMethod() {
        // ...
    }
    // 原因：Sentinel是通過代理實現(xiàn)的，私有方法代理不了
}

@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",  // 業(yè)務級別的限流
        blockHandler = "serviceBlockHandler",
        fallback = "createOrderFallback"
    )
    public Order createOrder(Order order) {
        // 實際業(yè)務邏輯
        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請求的流量
    ├─ 返回友好的錯誤信息
    └─ 保護系統(tǒng)入口
    ↓
Service層（@SentinelResource）
    ├─ 控制業(yè)務操作的流量
    ├─ 保護核心業(yè)務邏輯
    └─ 其他Service也可能調(diào)用

@SentinelResource(
    value = "createOrder",              // 資源名，必需
    blockHandler = "handleBlock",       // 限流/降級時的處理方法
    blockHandlerClass = BlockHandlers.class,  // 指定外部類
    fallback = "fallbackMethod",        // 業(yè)務異常時的降級方法
    fallbackClass = FallbackMethods.class,    // 指定外部類
    exceptionsToIgnore = {IOException.class}  // 忽略的異常
)
public Order createOrder(Order order) {
    // ...
}