<!-- 核心库 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-core</artifactId>
    <version>1.8.10</version>
</dependency>

<!-- 注解支持 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-annotation-aspectj</artifactId>
    <version>1.8.10</version>
</dependency>

<!-- 控制台通信 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-transport-simple-http</artifactId>
    <version>1.8.10</version>
</dependency>

public class SentinelQuickStart {

    public static void main(String[] args) {
        // 1. 定义流控规则
        initFlowRules();

        // 2. 模拟高频请求
        for (int i = 0; i < 20; i++) {
            doBusiness();
        }
    }

    private static void doBusiness() {
        // 3. 使用 SphU.entry 包裹资源访问
        try (Entry entry = SphU.entry("doBusiness")) {
            System.out.println("业务执行成功: " + System.currentTimeMillis());
        } catch (BlockException e) {
            System.out.println("被限流: " + e.getClass().getSimpleName());
        }
    }

    private static void initFlowRules() {
        FlowRule rule = new FlowRule();
        rule.setResource("doBusiness");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(10); // 每秒最多 10 个请求
        rule.setLimitApp("default");
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 直接拒绝

        FlowRuleManager.loadRules(Collections.singletonList(rule));
    }
}

@Service
public class OrderService {

    /**
     * @SentinelResource 同时定义资源名与降级/限流后的处理逻辑
     */
    @SentinelResource(
        value = "createOrder",
        blockHandler = "createOrderBlockHandler",       // 限流/熔断后的处理
        blockHandlerClass = OrderBlockHandler.class,     // 可指定外部类
        fallback = "createOrderFallback"                 // 异常时的兜底
    )
    public Order createOrder(OrderRequest request) {
        // 正常业务逻辑
        return orderMapper.insert(request.toOrder());
    }

    /** blockHandler 方法签名必须与原方法一致,末尾多一个 BlockException 参数 */
    public Order createOrderBlockHandler(OrderRequest request, BlockException ex) {
        log.warn("订单创建被限流/熔断, resource={}", ex.getRule() != null ? ex.getRule().getResource() : "unknown");
        return Order.degraded("系统繁忙,请稍后重试");
    }

    /** fallback 方法签名必须与原方法一致,末尾多一个 Throwable 参数 */
    public Order createOrderFallback(OrderRequest request, Throwable ex) {
        log.error("订单创建异常", ex);
        return Order.degraded("创建失败,请稍后重试");
    }
}

流量入口 → queryOrder (被限流)
         → createOrder (触发限流)

private static void initFlowRules() {
    // 规则1:QPS 直接快速失败
    FlowRule directRule = new FlowRule();
    directRule.setResource("queryOrder");
    directRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    directRule.setCount(100);
    directRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);

    // 规则2:Warm Up 冷启动(初始阈值 = 100/3 ≈ 33,10秒后达到100)
    FlowRule warmUpRule = new FlowRule();
    warmUpRule.setResource("expensiveQuery");
    warmUpRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    warmUpRule.setCount(100);
    warmUpRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
    warmUpRule.setWarmUpPeriodSec(10);

    // 规则3:匀速排队(每秒100个,超时等待最长2000ms)
    FlowRule queueRule = new FlowRule();
    queueRule.setResource("batchProcess");
    queueRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    queueRule.setCount(100);
    queueRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER);
    queueRule.setMaxQueueingTimeMs(2000);

    FlowRuleManager.loadRules(Arrays.asList(directRule, warmUpRule, queueRule));
}

最大 RT (maxRT):  超过此值视为"慢调用"(如 500ms)
比例阈值:         慢调用占比达到此值触发熔断(如 0.5 = 50%)
熔断时长:         熔断持续时间(如 10s)
最小请求数:       触发熔断的最小请求数(如 5),避免样本不足误判
统计时长:         统计窗口(默认 1000ms)

                    满足触发条件
    ┌──────────┐ ──────────────→ ┌──────────┐
    │  CLOSED  │                 │   OPEN   │
    │ (正常放行) │                 │ (熔断拒绝) │
    └──────────┘                 └──────────┘
         ↑                             │
         │                    等待熔断时长
         │                             │
         │                             ▼
         │                    ┌──────────────┐
         │      探测成功        │ HALF-OPEN    │
         └──────────────────── │ (半开,放行1个) │
                              └──────────────┘
                                     │
                              探测失败
                                     │
                                     ▼
                              ┌──────────┐
                              │   OPEN   │
                              └──────────┘

private static void initDegradeRules() {
    // 策略1:慢调用比例熔断
    DegradeRule slowCallRule = new DegradeRule();
    slowCallRule.setResource("rpcService");
    slowCallRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
    slowCallRule.setCount(500);       // 最大 RT: 500ms
    slowCallRule.setSlowRatioThreshold(0.5);  // 慢调用比例阈值: 50%
    slowCallRule.setTimeWindow(10);   // 熔断时长: 10s
    slowCallRule.setMinRequestAmount(5);      // 最小请求数: 5
    slowCallRule.setStatIntervalMs(1000);     // 统计窗口: 1s

    // 策略2:异常比例熔断
    DegradeRule exceptionRatioRule = new DegradeRule();
    exceptionRatioRule.setResource("rpcService");
    exceptionRatioRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
    exceptionRatioRule.setCount(0.5);   // 异常比例阈值: 50%
    exceptionRatioRule.setTimeWindow(15); // 熔断时长: 15s
    exceptionRatioRule.setMinRequestAmount(5);

    // 策略3:异常数熔断
    DegradeRule exceptionCountRule = new DegradeRule();
    exceptionCountRule.setResource("paymentService");
    exceptionCountRule.setGrade(CircuitBreakerStrategy.ERROR_COUNT.getType());
    exceptionCountRule.setCount(5);     // 异常数阈值: 5
    exceptionCountRule.setTimeWindow(20); // 熔断时长: 20s

    DegradeRuleManager.loadRules(Arrays.asList(slowCallRule, exceptionRatioRule, exceptionCountRule));
}

// 系统自适应保护规则(通常只需配置 1~2 项)
SystemRule rule = new SystemRule();
rule.setHighestCpuUsage(0.8);   // CPU 使用率 > 80% 触发
rule.setAvgRt(100);             // 平均 RT > 100ms 触发
rule.setMaxThread(500);         // 并发线程数 > 500 触发
rule.setQps(5000);              // 入口总 QPS > 5000 触发
SystemRuleManager.loadRules(Collections.singletonList(rule));

@SentinelResource(value = "queryOrder", blockHandler = "queryOrderBlockHandler")
public Order queryOrder(@RequestParam Long orderId, @RequestParam String userId) {
    return orderMapper.selectById(orderId);
}

// 热点参数限流规则
ParamFlowRule rule = new ParamFlowRule("queryOrder")
    .setParamIdx(0)            // 对第 0 个参数(orderId)限流
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(10);             // 每个 orderId 每秒最多 10 次

// 对特定参数值设置例外阈值
ParamFlowItem item = new ParamFlowItem();
item.setObject("10086");       // orderId=10086 是大客户,放宽到 100
item.setClassType(String.class.getName());
item.setCount(100);
rule.setParamFlowItemList(Collections.singletonList(item));

ParamFlowRuleManager.loadRules(Collections.singletonList(rule));

# 下载最新版 Dashboard
wget https://github.com/alibaba/Sentinel/releases/download/1.8.10/sentinel-dashboard-1.8.10.jar

# 启动(默认端口 8080)
java -Dserver.port=8080 \
     -Dcsp.sentinel.dashboard.server=localhost:8080 \
     -Dproject.name=sentinel-dashboard \
     -jar sentinel-dashboard-1.8.10.jar

# application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719          # 客户端与 Dashboard 通信端口
      eager: true            # 应用启动即上报(无需首次访问)

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-alibaba-dependencies</artifactId>
            <version>2023.0.3.2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- Spring Cloud Alibaba Sentinel Starter -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

    <!-- Sentinel 对 Feign/OpenFeign 的支持 -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

    <!-- Sentinel 对 Spring WebFlux 的支持(可选) -->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-spring-webflux-adapter</artifactId>
    </dependency>
</dependencies>

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080
        port: 8719
      eager: true
      # 自定义资源名前缀过滤(可选)
      filter:
        enabled: true
        url-patterns: /**
      datasource:           # 规则持久化配置(见 1.6)
        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

# 启用 Feign 对 Sentinel 的集成
feign:
  sentinel:
    enabled: true

@FeignClient(
    name = "user-service",
    fallbackFactory = UserServiceFallbackFactory.class  // 推荐使用 Factory 获取异常信息
)
public interface UserService {

    @GetMapping("/users/{id}")
    User getUser(@PathVariable("id") Long id);
}

@Component
public class UserServiceFallbackFactory implements FallbackFactory<UserService> {

    @Override
    public UserService create(Throwable cause) {
        return new UserService() {
            @Override
            public User getUser(Long id) {
                // 区分限流熔断 vs 业务异常
                if (cause instanceof BlockException) {
                    return User.degraded("服务限流/熔断,请稍后重试");
                }
                return User.degraded("服务调用失败: " + cause.getMessage());
            }
        };
    }
}

@Configuration
public class RestConfig {

    @Bean
    @LoadBalanced
    @SentinelRestTemplate(
        blockHandler = "handleBlock",
        blockHandlerClass = RestTemplateHandler.class,
        fallback = "handleFallback",
        fallbackClass = RestTemplateHandler.class
    )
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

public class RestTemplateHandler {
    public static ClientHttpResponse handleBlock(HttpRequest request, byte[] body,
                                                  ClientHttpRequestExecution execution, BlockException ex) {
        return new SentinelClientHttpResponse("{\"code\":-1,\"msg\":\"请求被限流\"}");
    }

    public static ClientHttpResponse handleFallback(HttpRequest request, byte[] body,
                                                     ClientHttpRequestExecution execution, Throwable ex) {
        return new SentinelClientHttpResponse("{\"code\":-1,\"msg\":\"请求异常\"}");
    }
}

[
  {
    "resource": "createOrder",
    "limitApp": "default",
    "grade": 1,
    "count": 100,
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
  },
  {
    "resource": "queryOrder",
    "limitApp": "default",
    "grade": 1,
    "count": 200,
    "strategy": 0,
    "controlBehavior": 0,
    "clusterMode": false
  }
]

请求进入
  │
  ▼
┌─────────────────────────────────────────────────────────────────┐
│                     ProcessorSlotChain                          │
│                                                                 │
│  NodeSelectorSlot → ClusterBuilderSlot → StatisticsSlot         │
│       │                │                  │                     │
│  构建调用链路树      构建集群节点         统计 QPS/RT/线程数      │
│                                                                 │
│  → ParamFlowSlot → FlowSlot → DegradeSlot → SystemSlot         │
│       │              │           │             │                │
│  热点参数检查      流控检查     熔断检查     系统自适应检查       │
│                                                                 │
│  → AuthoritySlot → LogSlot → Entry                              │
│       │             │         │                                 │
│  黑白名单检查     日志记录   放行执行                              │
└─────────────────────────────────────────────────────────────────┘

// SphU.java — 用户调用入口
public static Entry entry(String name) throws BlockException {
    return Env.sph.entry(name, EntryType.IN);
}

// CtSph.java — 核心实现
private Entry entryWithPriority(ResourceWrapper resourceWrapper, Context context,
                                 EntryType type, int count, Object... args) throws BlockException {

    // 1. 构建 Slot Chain(每个资源对应一条 Chain,通过缓存复用)
    ProcessorSlot<Object> chain = lookProcessChain(resourceWrapper);

    // 2. 创建 Entry
    Entry entry = new CtEntry(chain, context, resourceWrapper, type);

    // 3. 执行 Slot Chain — 责任链入口
    try {
        chain.entry(context, resourceWrapper, null, count, args);
    } catch (BlockException e) {
        entry.exit(0);  // 清理
        throw e;        // 向上抛出限流/熔断异常
    }

    return entry;
}

public class DefaultSlotChainBuilder implements SlotChainBuilder {

    @Override
    public ProcessorSlotChain build() {
        ProcessorSlotChain chain = new DefaultProcessorSlotChain();

        // SPI 机制加载所有 Slot,按 @SpiOrder 注解排序
        List<ProcessorSlot> sortedSlots = loadSortedSlots();

        for (ProcessorSlot slot : sortedSlots) {
            // 构建单向链表
            chain.addLast((AbstractLinkedProcessorSlot<?>) slot);
        }

        return chain;
    }
}

时间轴 ──────────────────────────────────────→

  窗口0(0~500ms)  窗口1(500~1000ms)  窗口2(1000~1500ms)
 ┌──────────────┐ ┌──────────────┐ ┌──────────────┐
 │  QPS=60      │ │  QPS=45      │ │  QPS=80      │
 └──────────────┘ └──────────────┘ └──────────────┘
       ↑                                    ↑
       │         当前时间点 t=1200ms          │
       │                                    │
       └──── 统计范围:窗口1 + 窗口2 ─────────┘
              合计 QPS = 45 + 80 = 125(仅统计未过期的窗口)

public class LeapArray<T> {

    private final int sampleCount;        // 窗口格子数(默认 2)
    private final int intervalInMs;       // 总窗口时长(默认 1000ms)
    private final AtomicReferenceArray<WindowWrap<T>> array;  // 环形数组

    /**
     * 根据当前时间获取对应的窗口
     * Sentinel 将 1 秒拆分为 2 个 500ms 的窗口(sampleCount=2)
     */
    public WindowWrap<T> currentWindow(long timeMillis) {
        int idx = calculateTimeIdx(timeMillis);   // 计算数组下标
        long windowStart = calculateWindowStart(timeMillis);  // 计算窗口起始时间

        while (true) {
            WindowWrap<T> old = array.get(idx);
            if (old == null) {
                // 新窗口:创建并 CAS 写入
                WindowWrap<T> wrap = new WindowWrap<>(windowLengthInMs, windowStart, newEmptyBucket());
                if (array.compareAndSet(idx, null, wrap)) {
                    return wrap;
                }
            } else if (windowStart == old.windowStart()) {
                // 当前窗口:直接返回
                return old;
            } else if (windowStart > old.windowStart()) {
                // 窗口已过期:重置统计值并更新起始时间
                if (updateLock.tryLock()) {
                    try {
                        resetWindowTo(old, windowStart);
                        return old;
                    } finally {
                        updateLock.unlock();
                    }
                }
            }
            // 其他线程在更新,让出 CPU 重试
            Thread.yield();
        }
    }
}

请求进入
  │
  ▼
StatisticsSlot.entry()
  │
  ▼
rollingCounterInSecond.pass()  ← 获取当前窗口的 pass 计数
  │
  ▼
LeapArray.currentWindow(timeMillis)  ← 定位到时间格子
  │
  ▼
WindowWrap.value().addPass()  ← 在对应格子的计数器 +1

public class DefaultController implements TrafficShapingController {

    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        // 获取当前已通过的 QPS(滑动窗口统计)
        int currentCount = (int) node.passQps();

        // 判断:已通过 + 本次请求 是否超过阈值
        if (currentCount + acquireCount > count) {
            return false;  // 超阈值,拒绝
        }

        // CAS 更新计数
        for (int i = 0; i < RETRY_TIMES; i++) {
            int oldCount = (int) node.passQps();
            int newCount = oldCount + acquireCount;
            if (newCount > count) {
                return false;
            }
            if (node.rollingPassCount().compareAndSet(oldCount, newCount)) {
                return true;  // CAS 成功,放行
            }
        }
        return false;
    }
}

public class WarmUpController implements TrafficShapingController {

    private double count;              // 最终阈值(QPS)
    private int coldFactor;            // 冷启动因子(默认 3)
    private int warningToken = 20;     // 警戒线令牌数
    private int maxToken;              // 最大令牌数
    private double slope;              // 令牌消耗斜率
    private AtomicLong storedTokens;   // 当前令牌数
    private AtomicLong lastFilledTime; // 上次填充时间

    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        long passQps = (long) node.passQps();
        long previousQps = (long) node.previousPassQps();

        // 1. 根据上一秒 QPS 调整令牌数
        syncToken(previousQps);

        long restToken = storedTokens.get();

        // 2. 令牌数超过警戒线 → 系统处于冷启动阶段,严格限流
        if (restToken >= warningToken) {
            // 当前 QPS 超过冷启动允许值 → 拒绝
            long aboveToken = restToken - warningToken;
            double warningQps = aboveToken * slope + count;  // 冷启动允许的 QPS
            if (passQps + acquireCount <= warningQps) {
                return true;
            }
            return false;
        }
        // 3. 令牌数低于警戒线 → 系统已预热,正常限流
        if (passQps + acquireCount <= count) {
            return true;
        }
        return false;
    }

    private void syncToken(long passQps) {
        long currentTime = TimeUtil.currentTimeMillis();
        long oldTime = lastFilledTime.get();
        // 每秒填充一次令牌
        if (currentTime - oldTime > 1000) {
            // 令牌补充:count - passQps(上一秒消耗的令牌)
            long newValue = maxToken - passQps;
            storedTokens.set(newValue);
            lastFilledTime.set(currentTime);
        }
    }
}

QPS阈值
  │
  │           ╭────────────────  最终阈值 count (如 100)
  │         ╱
  │       ╱
  │     ╱    ← 预热期:阈值逐步提升
  │   ╱
  │  ╱
  │╱────────────────  初始阈值 count/coldFactor (如 33)
  └──────────────────────────────→ 时间
   启动    预热期结束(约 warmUpPeriodSec)

public class ThrottlingController implements TrafficShapingController {

    private final double count;              // QPS 阈值
    private final int maxQueueingTimeMs;     // 最大排队等待时间
    private final AtomicLong latestPassedTime = new AtomicLong(-1);

    @Override
    public boolean canPass(Node node, int acquireCount, boolean prioritized) {
        // 若当前 QPS 远低于阈值,直接放行
        if (passQps.get() + acquireCount <= count) {
            return true;
        }

        // 计算本次请求需要等待的时间(漏桶:每个请求间隔 = 1000ms / count)
        long currentTime = TimeUtil.currentTimeMillis();
        long expectedTime = currentTime;  // 默认立即通过

        // 计算排队位置:前一个通过时间 + 本次间隔
        long lastTime = latestPassedTime.get();
        long expectedRt = lastTime + (long)(acquireCount * 1000.0 / count);

        if (expectedRt <= currentTime) {
            // 不需要排队,立即通过
            latestPassedTime.set(currentTime);
            return true;
        }

        // 需要排队:计算等待时间
        long estimatedTime = expectedRt - currentTime;
        if (estimatedTime > maxQueueingTimeMs) {
            // 超过最大排队时间,拒绝
            return false;
        }

        // CAS 更新最新通过时间
        long oldTime = latestPassedTime.addAndGet(estimatedTime);
        try {
            // 等待
            if (oldTime - estimatedTime > 0) {
                Thread.sleep(oldTime - currentTime);
            }
            return true;
        } catch (InterruptedException e) {
            return false;
        }
    }
}

public abstract class AbstractCircuitBreaker implements CircuitBreaker {

    protected final DegradeRule rule;
    protected AtomicInteger state;                    // 状态:0=CLOSED, 1=OPEN, 2=HALF_OPEN
    protected long nextRetryTimestamp;                // 下次重试时间(半开探测时间)

    @Override
    public boolean tryPass(Context context) {
        // 模板方法
        if (currentState() == STATE_CLOSED) {
            return true;  // 关闭状态,直接放行
        }
        if (currentState() == STATE_OPEN) {
            // 熔断状态:检查是否到半开时间
            return retryTimeoutArrived() && fromOpenToHalfOpen(context);
        }
        return false;  // 半开状态:只允许一个探测请求
    }

    /**
     * 请求结束后回调,判断是否需要更新熔断器状态
     */
    @Override
    public void onRequestComplete(Context context, double rt, Exception ex) {
        // 子类实现具体的策略判断
        // SlowRequestCircuitBreaker:检查 RT 是否超过阈值
        // ExceptionRatioCircuitBreaker:检查异常比例
        // ExceptionCountCircuitBreaker:检查异常数
    }

    protected boolean fromOpenToHalfOpen(Context context) {
        // CAS: OPEN → HALF_OPEN
        if (state.compareAndSet(STATE_OPEN, STATE_HALF_OPEN)) {
            // 注册探测回调:探测成功则 CLOSED,失败则重新 OPEN
            context.getCurEntry().whenTerminate(entry -> {
                if (entry.getBlockError() != null) {
                    // 探测被限流或异常 → 重新 OPEN
                    fromHalfOpenToOpen(1.0);
                } else {
                    // 探测成功 → CLOSED
                    fromHalfOpenToClose();
                }
            });
            return true;
        }
        return false;
    }
}

public class SlowRequestCircuitBreaker extends AbstractCircuitBreaker {

    private final long maxRT;              // 慢调用阈值(ms)
    private final double slowRatioThreshold; // 慢调用比例阈值

    @Override
    public void onRequestComplete(Context context, double rt, Exception ex) {
        // 1. 获取滑动窗口统计
        SimpleLeapArray<SlowRequestCounter> slidingWindow = ...;

        SlowRequestCounter counter = slidingWindow.currentWindow().value();

        // 2. 更新统计:总请求数 +1,慢调用数 +1(if RT > maxRT)
        counter.totalCount++;
        if (rt > maxRT) {
            counter.slowCount++;
        }

        // 3. 计算慢调用比例
        double slowRatio = (double) counter.slowCount / counter.totalCount;

        // 4. 达到阈值 + 满足最小请求数 → 触发熔断
        if (counter.totalCount >= minRequestAmount
            && slowRatio >= slowRatioThreshold) {
            // CLOSED → OPEN
            fromClosedToOpen();
        }
    }
}

请求完成时回调 onRequestComplete()
         │
         ▼
    ┌────────────┐     满足触发条件      ┌────────────┐
    │  CLOSED    │ ──────────────────→ │   OPEN     │
    │ 正常统计    │                      │ 拒绝请求    │
    └────────────┘                      └─────┬──────┘
         ↑                                    │
         │                          经过 timeWindow
         │                                    │
         │                                    ▼
         │                          ┌──────────────┐
         │    探测成功               │  HALF_OPEN   │
         └───────────────────────── │ 放行 1 个请求 │
                                    └──────┬───────┘
                                           │
                                   探测失败(超时/异常)
                                           │
                                           ▼
                                    ┌────────────┐
                                    │   OPEN     │
                                     │ 重新熔断    │
                                     └────────────┘

NodeSelectorSlot → ClusterBuilderSlot → StatisticsSlot
→ ParamFlowSlot → FlowSlot → DegradeSlot → SystemSlot
→ AuthoritySlot → LogSlot

CLOSED --满足触发条件--> OPEN --经过timeWindow--> HALF_OPEN
                                                      │
                                              ┌───────┴───────┐
                                         探测成功          探测失败
                                              │               │
                                              ▼               ▼
                                          CLOSED          OPEN(重新计时)

@SpiOrder(-1000)  // 数字越小优先级越高
public class CustomSlot extends AbstractLinkedProcessorSlot<DefaultNode> {
    @Override
    public void entry(Context context, ResourceWrapper resourceWrapper, Node node, int count, Object... args)
            throws Throwable {
        // 自定义逻辑
        fireEntry(context, resourceWrapper, node, count, args);  // 传递给下一个 Slot
    }
}

// 秒杀接口:QPS 限流 + 热点参数限流(按 userId)
@SentinelResource(value = "seckill", blockHandler = "seckillBlockHandler")
public Result seckill(@RequestParam Long goodsId, @RequestParam Long userId) {
    // 扣库存逻辑
}

// 热点参数规则:每个 userId 每秒限 1 次
ParamFlowRule rule = new ParamFlowRule("seckill")
    .setParamIdx(1)    // 第 1 个参数 userId
    .setGrade(RuleConstant.FLOW_GRADE_QPS)
    .setCount(1);

// 1. 线程数限流:保护自身线程池
FlowRule threadRule = new FlowRule();
threadRule.setResource("callUserService");
threadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
threadRule.setCount(50);  // 最多 50 个并发线程

// 2. 慢调用熔断:RT > 500ms 且比例 > 50% 时熔断 10s
DegradeRule slowRule = new DegradeRule();
slowRule.setResource("callUserService");
slowRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
slowRule.setCount(500);              // 最大 RT
slowRule.setSlowRatioThreshold(0.5); // 慢调用比例 50%
slowRule.setTimeWindow(10);          // 熔断 10s
slowRule.setMinRequestAmount(5);     // 最小 5 个请求

// 集群限流规则
FlowRule rule = new FlowRule();
rule.setResource("globalAPI");
rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule.setCount(1000);           // 全局 QPS 1000
rule.setClusterMode(true);     // 启用集群限流
rule.setClusterConfig(new ClusterFlowConfig()
    .setThresholdType(ClusterRuleConstant.FLOW_THRESHOLD_GLOBAL));

                    ┌──────────────────┐
   瞬间 10万请求     │   CDN + 前端层     │
  ─────────────────→│  按钮防抖+验证码    │  过滤 80%(8万)
                    └────────┬─────────┘
                             │ 2万请求
                    ┌────────▼─────────┐
                    │   网关层限流       │
                    │  Sentinel Gateway │  过滤 70%(1.4万)
                    └────────┬─────────┘
                             │ 6000请求
                    ┌────────▼─────────┐
                    │  接口层限流        │
                    │  QPS限流+热点参数  │  过滤 80%(4800)
                    └────────┬─────────┘
                             │ 1200请求
                    ┌────────▼─────────┐
                    │  缓存+MQ异步下单   │
                    │  Redis预减库存     │  过滤 90%(1080)
                    └────────┬─────────┘
                             │ 120请求
                    ┌────────▼─────────┐
                    │  数据库扣库存       │
                    └──────────────────┘

@RestController
public class SeckillController {

    /**
     * 秒杀接口 —— 多维度限流
     */
    @SentinelResource(value = "seckill", blockHandler = "seckillBlockHandler")
    public Result seckill(@RequestParam Long goodsId, @RequestParam Long userId) {
        // 1. Redis 预减库存
        Long stock = redisTemplate.opsForValue().decrement("seckill:stock:" + goodsId);
        if (stock != null && stock < 0) {
            redisTemplate.opsForValue().increment("seckill:stock:" + goodsId); // 回滚
            return Result.fail("商品已售罄");
        }

        // 2. 发送 MQ 异步创建订单
        rabbitTemplate.convertAndSend("seckill.exchange", "seckill.order",
                new SeckillMessage(goodsId, userId));

        return Result.success("秒杀成功,订单创建中");
    }

    /** 限流兜底 */
    public Result seckillBlockHandler(Long goodsId, Long userId, BlockException ex) {
        if (ex instanceof ParamFlowException) {
            return Result.fail("操作太频繁,请稍后再试");
        }
        return Result.fail("当前排队人数过多,请稍后再试");
    }
}

/**
 * 秒杀限流规则配置
 */
@Configuration
public class SeckillSentinelConfig {

    @PostConstruct
    public void init() {
        // 规则1:接口级 QPS 限流 —— 快速失败
        FlowRule apiRule = new FlowRule();
        apiRule.setResource("seckill");
        apiRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        apiRule.setCount(2000);  // 接口最大 QPS 2000
        apiRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);

        // 规则2:热点参数限流 —— 单用户每秒限 1 次
        ParamFlowRule userRule = new ParamFlowRule("seckill")
            .setParamIdx(1)  // userId 参数
            .setGrade(RuleConstant.FLOW_GRADE_QPS)
            .setCount(1);

        // 规则3:热点参数限流 —— 单商品每秒限 500 次(防刷单)
        ParamFlowRule goodsRule = new ParamFlowRule("seckill")
            .setParamIdx(0)  // goodsId 参数
            .setGrade(RuleConstant.FLOW_GRADE_QPS)
            .setCount(500);

        // 规则4:慢调用熔断 —— RT > 200ms 且比例 > 30% 时熔断 5s
        DegradeRule slowRule = new DegradeRule();
        slowRule.setResource("seckill");
        slowRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
        slowRule.setCount(200);
        slowRule.setSlowRatioThreshold(0.3);
        slowRule.setTimeWindow(5);
        slowRule.setMinRequestAmount(10);

        // 规则5:系统自适应保护 —— CPU > 80% 时全局限流
        SystemRule sysRule = new SystemRule();
        sysRule.setHighestCpuUsage(0.8);

        FlowRuleManager.loadRules(Collections.singletonList(apiRule));
        ParamFlowRuleManager.loadRules(Arrays.asList(userRule, goodsRule));
        DegradeRuleManager.loadRules(Collections.singletonList(slowRule));
        SystemRuleManager.loadRules(Collections.singletonList(sysRule));
    }
}

Service A → Service B → Service C (故障:响应超时)
     ↑           ↑
  线程阻塞     线程阻塞
     ↑
  线程池耗尽 → A 不可用 → A 的上游也不可用 → 雪崩

@Service
public class OrderFacadeService {

    @Autowired
    private UserFeignClient userFeignClient;     // 调用用户服务
    @Autowired
    private InventoryFeignClient inventoryFeignClient; // 调用库存服务

    /**
     * 创建订单 —— 多个下游调用,每个都需熔断保护
     */
    @SentinelResource(value = "createOrder", blockHandler = "createOrderBlockHandler")
    public OrderResult createOrder(OrderRequest request) {
        // 1. 查用户信息(可能慢)
        UserInfo user = queryUserInfo(request.getUserId());

        // 2. 扣库存(可能失败)
        boolean deducted = deductInventory(request.getGoodsId(), request.getQuantity());

        // 3. 创建订单
        if (deducted) {
            return orderMapper.insert(request.toOrder());
        }
        return OrderResult.fail("库存不足");
    }

    /** 调用用户服务 —— 独立资源名,独立熔断规则 */
    @SentinelResource(value = "callUserService", blockHandler = "userFallback")
    private UserInfo queryUserInfo(Long userId) {
        return userFeignClient.getUser(userId);
    }

    /** 调用库存服务 —— 独立资源名,独立熔断规则 */
    @SentinelResource(value = "callInventoryService", blockHandler = "inventoryFallback")
    private boolean deductInventory(Long goodsId, int quantity) {
        return inventoryFeignClient.deduct(goodsId, quantity);
    }

    // --- 降级方法 ---

    public UserInfo userFallback(Long userId, BlockException ex) {
        log.warn("用户服务熔断,返回降级数据, userId={}", userId);
        return UserInfo.defaultUser();  // 返回默认用户信息
    }

    public boolean inventoryFallback(Long goodsId, int quantity, BlockException ex) {
        log.warn("库存服务熔断,返回降级结果, goodsId={}", goodsId);
        return false;  // 降级:库存扣减失败
    }

    public OrderResult createOrderBlockHandler(OrderRequest request, BlockException ex) {
        log.warn("订单创建被限流");
        return OrderResult.degraded("系统繁忙,请稍后重试");
    }
}

@PostConstruct
public void initDegradeRules() {
    List<DegradeRule> rules = new ArrayList<>();

    // 用户服务:慢调用熔断(RT > 300ms, 比例 > 50%, 熔断 10s)
    DegradeRule userRule = new DegradeRule();
    userRule.setResource("callUserService");
    userRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
    userRule.setCount(300);
    userRule.setSlowRatioThreshold(0.5);
    userRule.setTimeWindow(10);
    userRule.setMinRequestAmount(5);
    rules.add(userRule);

    // 用户服务:异常比例熔断(异常率 > 50%, 熔断 15s)
    DegradeRule userExceptionRule = new DegradeRule();
    userExceptionRule.setResource("callUserService");
    userExceptionRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
    userExceptionRule.setCount(0.5);
    userExceptionRule.setTimeWindow(15);
    userExceptionRule.setMinRequestAmount(5);
    rules.add(userExceptionRule);

    // 库存服务:异常数熔断(5个异常即熔断)
    DegradeRule inventoryRule = new DegradeRule();
    inventoryRule.setResource("callInventoryService");
    inventoryRule.setGrade(CircuitBreakerStrategy.ERROR_COUNT.getType());
    inventoryRule.setCount(5);
    inventoryRule.setTimeWindow(20);
    rules.add(inventoryRule);

    // 线程数限流:每个下游调用最多 50 个并发线程
    FlowRule userThreadRule = new FlowRule();
    userThreadRule.setResource("callUserService");
    userThreadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
    userThreadRule.setCount(50);

    FlowRule inventoryThreadRule = new FlowRule();
    inventoryThreadRule.setResource("callInventoryService");
    inventoryThreadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
    inventoryThreadRule.setCount(30);

    DegradeRuleManager.loadRules(rules);
    FlowRuleManager.loadRules(Arrays.asList(userThreadRule, inventoryThreadRule));
}

// 场景:系统刚发布,数据库连接池未预热,缓存未填充
// 直接放开 1000 QPS 会导致 DB 连接池耗尽

FlowRule warmUpRule = new FlowRule();
warmUpRule.setResource("queryProduct");
warmUpRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
warmUpRule.setCount(1000);          // 最终阈值 1000 QPS
warmUpRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
warmUpRule.setWarmUpPeriodSec(30);  // 30 秒预热期

// 预热曲线:
// 0~10s:   阈值 ≈ 333 QPS (1000/3)
// 10~20s:  阈值 ≈ 666 QPS
// 20~30s:  阈值 ≈ 1000 QPS
// 30s+:    阈值 = 1000 QPS

// 场景:消息队列消费者,每秒消费 100 条消息调用下游
// 下游处理能力 = 100 QPS,但不允许突发

FlowRule rateLimitRule = new FlowRule();
rateLimitRule.setResource("processMessage");
rateLimitRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
rateLimitRule.setCount(100);          // 每秒 100 个
rateLimitRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER);
rateLimitRule.setMaxQueueingTimeMs(5000);  // 最多排队 5 秒

// 效果:请求以 10ms 间隔匀速通过(1000ms / 100 = 10ms)
// 突发 500 个请求 → 100 个立即通过,400 个排队等待,最多等 5 秒

// 场景:大促刚开始,需要预热 + 匀速
FlowRule combinedRule = new FlowRule();
combinedRule.setResource("promotionAPI");
combinedRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
combinedRule.setCount(500);
combinedRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP_RATE_LIMITER);
combinedRule.setWarmUpPeriodSec(20);
combinedRule.setMaxQueueingTimeMs(3000);

@Service
public class OrderQueryService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 复杂查询接口 —— 可能产生慢 SQL
     * 用线程数限流保护数据库连接池
     */
    @SentinelResource(value = "complexQuery", blockHandler = "complexQueryBlockHandler")
    public List<Order> complexQuery(OrderQueryParam param) {
        // 模拟复杂 SQL
        return jdbcTemplate.query(
            "SELECT * FROM orders WHERE create_time > ? AND status = ? ORDER BY create_time DESC",
            new Object[]{param.getStartTime(), param.getStatus()},
            new OrderRowMapper()
        );
    }

    public List<Order> complexQueryBlockHandler(OrderQueryParam param, BlockException ex) {
        log.warn("复杂查询被限流,返回空列表");
        return Collections.emptyList();
    }
}

@PostConstruct
public void initDbProtectionRules() {
    List<FlowRule> flowRules = new ArrayList<>();

    // 规则1:线程数限流 —— 并发查询不超过 20(假设连接池大小 50,留 30 给其他业务)
    FlowRule threadRule = new FlowRule();
    threadRule.setResource("complexQuery");
    threadRule.setGrade(RuleConstant.FLOW_GRADE_THREAD);
    threadRule.setCount(20);
    flowRules.add(threadRule);

    // 规则2:QPS 限流 —— 每秒最多 100 次查询
    FlowRule qpsRule = new FlowRule();
    qpsRule.setResource("complexQuery");
    qpsRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
    qpsRule.setCount(100);
    flowRules.add(qpsRule);

    FlowRuleManager.loadRules(flowRules);

    // 规则3:慢调用熔断 —— SQL 执行 > 1s 且比例 > 30% 时熔断 15s
    DegradeRule slowSqlRule = new DegradeRule();
    slowSqlRule.setResource("complexQuery");
    slowSqlRule.setGrade(CircuitBreakerStrategy.SLOW_REQUEST_RATIO.getType());
    slowSqlRule.setCount(1000);      // RT > 1000ms 视为慢查询
    slowSqlRule.setSlowRatioThreshold(0.3);
    slowSqlRule.setTimeWindow(15);
    slowSqlRule.setMinRequestAmount(5);
    DegradeRuleManager.loadRules(Collections.singletonList(slowSqlRule));
}

<!-- 依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
    <version>1.8.10</version>
</dependency>

@Configuration
public class GatewaySentinelConfig {

    @Bean
    @Order(-1)
    public SentinelGatewayFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }

    @Bean
    @Order(-1)
    public SentinelGatewayBlockExceptionHandler sentinelBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler();
    }

    @PostConstruct
    public void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();

        // 规则1:API 分组限流 —— 所有 /api/** 路径总 QPS 5000
        rules.add(new GatewayFlowRule("api_group")
            .setResourceMode(SentinelGatewayConstants.RESOURCE_MODE_CUSTOM_API_NAME)
            .setCount(5000)
            .setIntervalSec(1));

        // 规则2:特定路由限流 —— /api/orders 每秒 1000
        rules.add(new GatewayFlowRule("order_route")
            .setCount(1000)
            .setIntervalSec(1));

        // 规则3:参数限流 —— 按 userId 限流,每用户每秒 10 次
        rules.add(new GatewayFlowRule("order_route")
            .setCount(10)
            .setIntervalSec(1)
            .setParamItem(new GatewayParamFlowItem()
                .setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_HEADER)
                .setFieldName("X-User-Id")));

        // 规则4:突发流量允许 —— 2 秒窗口,允许 2 倍突发
        rules.add(new GatewayFlowRule("order_route")
            .setCount(2000)
            .setIntervalSec(2)
            .setBurst(2000));  // 突发量

        GatewayRuleManager.loadRules(rules);
    }

    @PostConstruct
    public void initCustomApis() {
        // 定义 API 分组
        Set<ApiDefinition> definitions = new HashSet<>();
        ApiDefinition apiGroup = new ApiDefinition("api_group")
            .setPredicateItems(new HashSet<ApiPredicateItem>() {{
                add(new ApiPathPredicateItem()
                    .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX)
                    .setPattern("/api/"));
            }});
        definitions.add(apiGroup);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }
}

@Component
public class CustomBlockExceptionHandler implements BlockExceptionHandler {

    @Override
    public void handle(ServerWebExchange exchange, BlockException ex) {
        String body;
        if (ex instanceof ParamFlowException) {
            body = "{\"code\":429,\"msg\":\"请求过于频繁\"}";
        } else {
            body = "{\"code\":429,\"msg\":\"系统繁忙,请稍后重试\"}";
        }

        exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
        exchange.getResponse().getHeaders().setContentType(MediaType.APPLICATION_JSON);
        DataBuffer buffer = exchange.getResponse().bufferFactory().wrap(body.getBytes());
        exchange.getResponse().writeWith(Mono.just(buffer));
    }
}

// === Token Server 配置 ===

// Token Server 启动类
public class TokenServer {

    public static void main(String[] args) throws Exception {
        ClusterTokenServer tokenServer = new ClusterTokenServer(8720);  // 端口
        tokenServer.start();
    }
}

// === Token Client 配置(应用节点) ===

@Configuration
public class ClusterClientConfig {

    @PostConstruct
    public void init() {
        // 配置 Token Server 地址
        ClusterClientAssignProcessor.setServerAssignProperty(
            new TokenClientConfig()
                .setServerHost("10.0.0.1")
                .setServerPort(8720)
        );

        // 集群限流规则:全局 QPS 800
        FlowRule clusterRule = new FlowRule();
        clusterRule.setResource("globalAPI");
        clusterRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        clusterRule.setCount(800);
        clusterRule.setClusterMode(true);
        clusterRule.setClusterConfig(new ClusterFlowConfig()
            .setThresholdType(ClusterRuleConstant.FLOW_THRESHOLD_GLOBAL)
            .setFallbackToLocalWhenFail(true));  // Token Server 不可用时降级为单机限流

        FlowRuleManager.loadRules(Collections.singletonList(clusterRule));
    }
}

/**
 * Redis + Lua 滑动窗口限流
 * 适用于非 Spring Cloud Alibaba 生态
 */
@Component
public class RedisRateLimiter {

    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final String LUA_SCRIPT =
        "local key = KEYS[1] " +
        "local limit = tonumber(ARGV[1]) " +
        "local window = tonumber(ARGV[2]) " +
        "local current = tonumber(redis.call('time')[1]) " +
        "local clearBefore = current - window " +
        "" +
        "-- 清除过期记录 " +
        "redis.call('zremrangebyscore', key, 0, clearBefore) " +
        "" +
        "-- 统计当前窗口内请求数 " +
        "local count = redis.call('zcard', key) " +
        "" +
        "if count < limit then " +
        "    redis.call('zadd', key, current, current) " +
        "    redis.call('expire', key, window) " +
        "    return 1 " +  -- 放行
        "else " +
        "    return 0 " +  -- 拒绝
        "end";

    private final DefaultRedisScript<Long> script = new DefaultRedisScript<>(LUA_SCRIPT, Long.class);

    public boolean tryAcquire(String resource, int limit, int windowSeconds) {
        String key = "rate_limit:" + resource;
        Long result = redisTemplate.execute(script, Collections.singletonList(key),
                String.valueOf(limit), String.valueOf(windowSeconds));
        return result != null && result == 1;
    }
}

// 使用示例:结合 AOP 自动限流
@Aspect
@Component
public class RateLimitAspect {

    @Autowired
    private RedisRateLimiter rateLimiter;

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint point, RateLimit rateLimit) throws Throwable {
        String resource = rateLimit.resource();
        if (!rateLimiter.tryAcquire(resource, rateLimit.limit(), rateLimit.window())) {
            throw new RateLimitException("请求过于频繁,请稍后重试");
        }
        return point.proceed();
    }
}

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    String resource();
    int limit() default 100;
    int window() default 1;
}