Sentinel[超详细讲解]-3

主要讲解🚀 - 基于QPS/并发数的流量控制

1、流控规则

流量控制（Flow Control）用于限制某个资源的访问频率，防止系统被瞬时的流量高峰冲垮。流量控制规则可以针对不同的资源进行配置，例如接口、方法、类等。

流量规则的定义

重要属性：

同一个资源可以同时有多个限流规则，检查规则时会依次检查   

以下是一个例子

private void FlowQpsRule() {
    // 定义流量控制规则
    FlowRule rule = new FlowRule();
    rule.setResource("orderQuery"); // 资源名称
    rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 限流阈值类型(QPS/线程数)
    rule.setCount(10); // 阈值(每秒10次)
    rule.setLimitApp("default"); // 针对来源(default代表不区分来源)
    rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 流控效果(直接拒绝)
    rule.setClusterMode(false); // 是否集群模式

    // 加载规则
    List<FlowRule> rules = new ArrayList<>();
    rules.add(rule);
    FlowRuleManager.loadRules(rules);
}

2、基于QPS/并发数的流量控制

• 流量控制分为统计线程数和QPS两种类型。

• 线程数限流用于保护业务线程不被耗尽。

• QPS限流包括直接拒绝、冷启动和匀速器三种方式。

直接拒绝、冷启动、匀速器 解释：

1. 直接拒绝：超过阈值直接拒绝，抛出FlowException异常。
2. 冷启动：冷启动是让通过的流量缓慢增加，在一定时间内逐渐增加到阈值，避免瞬间流量过大导致系统崩溃。
3. 匀速器：匀速器是让通过的流量按照固定的速率匀速通过，避免瞬间流量过大导致系统崩溃。

2.1、基于QPS的流量控制

基于QPS的流量控制是指对某个资源的访问频率进行限制，例如每秒最多允许访问10次。当访问频率超过设定的阈值时，新的请求将被拒绝。

主要代码：

@PostConstruct
     private void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        FlowRule rule = new FlowRule();
        rule.setResource(RESOURCE_NAME);        // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 基于QPS的流量控制
        rule.setCount(10);                      // 每秒最多10个请求
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 直接拒绝
        rule.setLimitApp("default");            // 默认对所有来源生效
        
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }

 比如：订单查询接口，每秒最多允许访问10次，超过10次则拒绝。

代码例子🫡：

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

@Service
public class OrderService {

    // 定义资源名称
    private static final String RESOURCE_NAME = "createOrder";
    
    // 初始化流量控制规则
    @PostConstruct
    private void initFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        FlowRule rule = new FlowRule();
        rule.setResource(RESOURCE_NAME);        // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS); // 基于QPS的流量控制
        rule.setCount(10);                      // 每秒最多10个请求
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT); // 直接拒绝
        rule.setLimitApp("default");            // 默认对所有来源生效
        
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
    
    // 受保护的资源方法
    @SentinelResource(value = RESOURCE_NAME, blockHandler = "createOrderBlockHandler")
    public String createOrder(String orderInfo) {
        // 业务逻辑处理
        return "订单创建成功: " + orderInfo;
    }
    
    // 限流处理逻辑
    public String createOrderBlockHandler(String orderInfo, BlockException ex) {
        return "请求过于频繁，请稍后再试！当前订单信息: " + orderInfo;
    }
}

2.2 、基于并发数的流量控制

基于并发数的流量控制是指对某个资源的并发访问数量进行限制，例如最多允许同时有10个请求访问该资源。当并发访问数量超过设定的阈值时，新的请求将被拒绝。

主要代码如下😎：

       
    // 初始化并发线程数控制规则
    @PostConstruct
    private void initConcurrentRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        FlowRule rule = new FlowRule();
        rule.setResource(ORDER_QUERY_RESOURCE);   // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_THREAD); // 基于并发线程数的流量控制
        rule.setCount(10);                       // 最大并发数10
        rule.setLimitApp("default");             // 默认对所有来源生效
        
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }

 比如：订单查询接口，最多允许同时有10个请求访问，超过10个则拒绝。

example😁：基于线程数限流

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;

@Service
public class OrderQueryService {

    // 定义资源名称
    private static final String ORDER_QUERY_RESOURCE = "orderQuery";
    
    // 初始化并发线程数控制规则
    @PostConstruct
    private void initConcurrentRules() {
        List<FlowRule> rules = new ArrayList<>();
        
        FlowRule rule = new FlowRule();
        rule.setResource(ORDER_QUERY_RESOURCE);   // 资源名
        rule.setGrade(RuleConstant.FLOW_GRADE_THREAD); // 基于并发线程数的流量控制
        rule.setCount(10);                       // 最大并发数10
        rule.setLimitApp("default");             // 默认对所有来源生效
        
        rules.add(rule);
        FlowRuleManager.loadRules(rules);
    }
    
    // 受保护的订单查询方法
    @SentinelResource(value = ORDER_QUERY_RESOURCE, 
                     blockHandler = "orderQueryBlockHandler")
    public String queryOrder(String orderId) {
        // 模拟业务处理耗时
        try {
            Thread.sleep(100); // 100ms处理时间
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return "订单详情: " + orderId;
    }
    
    // 限流处理逻辑
    public String orderQueryBlockHandler(String orderId, BlockException ex) {
        return "系统繁忙，当前并发查询人数过多，请稍后再试！订单ID: " + orderId;
    }
}