Spring Cloud Alibaba教程第四弹 Sentinel限流组件入门

r囧r小猫 2022-12-14 03:58 116阅读 0赞

**写在前面的话**

更多Spring与微服务相关的教程请戳这里 [火力全开系列 Spring与微服务教程合集 持续更新][Spring_]

# 1、Sentinel入门案例 #

## 1.1、pom.xml ##

<dependency>
                <groupId>com.alibaba.csp</groupId>
                <artifactId>sentinel-core</artifactId>
                <version>1.8.0</version>
            </dependency>

## 1.2、示例代码 ##

import com.alibaba.csp.sentinel.Entry;
    import com.alibaba.csp.sentinel.SphU;
    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 java.util.ArrayList;
    import java.util.List;
    import java.util.Random;
    
    
    public class Introduction {
        //设置资源名称
        private static final String RESOURCE_NAME = "helloworld";
        //设置QPS(每秒的请求数)
        private static final int QPS_MAX = 50;
        private static int qps;
    
        /**
         * 定义规则
         */
        private static void initFlowRules(){
            List<FlowRule> rules = new ArrayList<>();
            FlowRule rule = new FlowRule();
            rule.setResource(RESOURCE_NAME);
            rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
            //设置QPS：每秒的请求数
            rule.setCount(QPS_MAX);
            rules.add(rule);
            FlowRuleManager.loadRules(rules);
        }
    
        /**
         * 定义资源：用try-catch-finally语法
         */
        private static void exeResourceWithFinally(){
            Entry entry = null;
            try {
                entry = SphU.entry(RESOURCE_NAME);
                //被保护的逻辑
                System.out.println("pass："+qps);
            } catch (BlockException e) {
                //流控处理逻辑
                System.out.println("block："+qps);
            } finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    
        /**
         * 定义资源：用try-with-resources语法，自动exit entry
         */
        private static void exeResource(){
            try (Entry entry = SphU.entry(RESOURCE_NAME)) {
                //被保护的逻辑
                System.out.println("pass："+qps);
            } catch (BlockException e) {
                //流控处理逻辑
                System.out.println("block："+qps);
            }
    
        }
    
    
        public static void main(String[] args) throws InterruptedException {
            initFlowRules();
            Random r = new Random();
            while (true) {
                Thread.sleep(1000);
                //用随机数模拟每秒流量,count为当前秒的流量
                qps = r.nextInt(100)+1;
                for (int i=0;i<=qps;i++){
                    //访问资源
                    exeResource();
                    exeResourceWithFinally();
                }
    
            }
        }
    }

# 2、热点参数限流 #

## 2.1、概述 ##

何为热点？热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的 Top K 数据，并对其访问进行限制。比如：

*  商品 ID 为参数，统计一段时间内最常购买的商品 ID 并进行限制
 *  用户 ID 为参数，针对一段时间内频繁访问的用户 ID 进行限制

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。

热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。

![Sentinel Parameter Flow Control][]

Sentinel 利用 LRU 策略统计最近最常访问的热点参数，结合令牌桶算法来进行参数级别的流控。热点参数限流支持集群模式。

## 2.2、热点参数规则 ##

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th style="width:620px;">说明</th> 
   <th style="width:123px;">默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resource</td> 
   <td style="width:620px;">资源名，必填</td> 
   <td style="width:123px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td style="width:620px;">限流阈值，必填</td> 
   <td style="width:123px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td>grade</td> 
   <td style="width:620px;">限流模式</td> 
   <td style="width:123px;">QPS 模式</td> 
  </tr> 
  <tr> 
   <td>durationInSec</td> 
   <td style="width:620px;">统计窗口时间长度（单位为秒），1.6.0 版本开始支持</td> 
   <td style="width:123px;">1s</td> 
  </tr> 
  <tr> 
   <td>controlBehavior</td> 
   <td style="width:620px;">流控效果（支持快速失败和匀速排队模式），1.6.0 版本开始支持</td> 
   <td style="width:123px;">快速失败</td> 
  </tr> 
  <tr> 
   <td>maxQueueingTimeMs</td> 
   <td style="width:620px;">最大排队等待时长（仅在匀速排队模式生效），1.6.0 版本开始支持</td> 
   <td style="width:123px;">0ms</td> 
  </tr> 
  <tr> 
   <td>paramIdx</td> 
   <td style="width:620px;">热点参数的索引，必填，对应&nbsp;<code>SphU.entry(xxx, args)</code>&nbsp;中的参数索引位置</td> 
   <td style="width:123px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td>paramFlowItemList</td> 
   <td style="width:620px;">参数例外项，可以针对指定的参数值单独设置限流阈值，不受前面&nbsp;<code>count</code>&nbsp;阈值的限制。<strong>仅支持基本类型和字符串类型</strong></td> 
   <td style="width:123px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td>clusterMode</td> 
   <td style="width:620px;">是否是集群参数流控规则</td> 
   <td style="width:123px;"><code>false</code></td> 
  </tr> 
  <tr> 
   <td>clusterConfig</td> 
   <td style="width:620px;">集群流控相关配置</td> 
   <td style="width:123px;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

## 2.3、热点参数限流示例代码 ##

注意：其实热点参数限流我没彻底搞懂，比如observe方法注释的测试结果，为什么会出现这种现象，多个热点参数如何把控？

鉴于时间问题，暂时就 不深究了

import com.alibaba.csp.sentinel.Entry;
    import com.alibaba.csp.sentinel.EntryType;
    import com.alibaba.csp.sentinel.SphU;
    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 com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowItem;
    import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
    import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
    
    import java.util.*;
    
    public class HotResource {
        //设置资源名称
        private static final String RESOURCE_NAME = "hot";
        //设置QPS(每秒的请求数)
        private static final int QPS_MAX = 50;
        private static int qps;
        private static int param_a = 66;
        private static int param_b = 99;
    
        //打印日志相关
        private static final boolean printWithSet = true;
        private static Set<String> logSet = new HashSet<>();
    
        /**
         * 定义规则
         */
        private static void initParamFlowRules(){
            ParamFlowRule rule = new ParamFlowRule("hot")
                    .setParamIdx(0)
                    .setCount(QPS_MAX);
            //配置例外项：针对 int 类型的参数param_b，单独设置限流QPS阈值为 10，而不是全局的阈值50
            ParamFlowItem item = new ParamFlowItem().setObject(String.valueOf(param_b))
                    .setClassType(int.class.getName())
                    .setCount(10);
            rule.setParamFlowItemList(Collections.singletonList(item));
            ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
        }
    
        /**
         * 定义热点资源：不能用try-with-resources语法
         */
        private static void exeHotResource(){
            Entry entry = null;
            try {
                //param_a在index=0的位置，param_b在index1的位置
                //若需要配置例外项或者使用集群维度流控，则传入的参数只支持基本类型
                //count 大多数情况都填 1，代表访问一次资源视为1次调用
                //EntryType 代表流量类型，其中系统规则只对 IN 类型的埋点生效
                //多个埋点的顺序应该为：比如 entry1 -> entry2 -> exit2 -> exit1
                entry = SphU.entry(RESOURCE_NAME, EntryType.IN, 1, param_a, param_b);
                printLog(true);
            } catch (BlockException ex) {
                printLog(false);
            }finally {
                if (entry != null) {
                    entry.exit(1, param_a, param_b);
                }
            }
        }
    
        /**
         * 定义普通资源
         */
        private static void exeResource(){
            Entry entry = null;
            try {
                entry = SphU.entry(RESOURCE_NAME);
                printLog(true);
            } catch (BlockException ex) {
                printLog(false);
            }finally {
                if (entry != null) {
                    entry.exit();
                }
            }
        }
    
    
    
    
        public static void main(String[] args) throws InterruptedException {
            observe();
            initParamFlowRules();
            Random r = new Random();
            while (true) {
                Thread.sleep(1000);
                //用随机数模拟每秒流量,count为当前秒的流量
                qps = r.nextInt(100)+1;
                for (int i=0;i<=qps;i++){
                    //访问资源
                    exeHotResource();
                }
    
            }
        }
    
    
    
        /**
         * 打印日志，方便观察效果
         */
        private static void printLog(boolean isRun){
            String log = "";
            if(isRun){
                log = "run："+qps;
            }else{
                log = "block："+qps;
            }
    
            if(printWithSet){
                if(logSet.add(log)){
                    System.out.println(log);
                }
            }else{
                System.out.println(log);
            }
        }
    
    
        /**
         * 当有两个热点参数：
         *      a为全局qps50，b为例外qps10，测试结果：50以下基本为run，50以上run和block交织出现
         *      无例外项，测试结果：同上
         *
         *
         */
        private static void observe(){
            Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("执行虚拟机结束事件！");
                    List<String> list = new ArrayList<>();
                    for (String s : logSet) {
                        list.add(s);
                    }
                    Collections.sort(list, new Comparator<String>() {
                        @Override
                        public int compare(String o1, String o2) {
                            int a = Integer.parseInt(o1.replace("run：","").replace("block：",""));
                            int b = Integer.parseInt(o2.replace("run：","").replace("block：",""));
                            return a-b;
                        }
                    });
                    for (String s : list) {
                        System.out.println(s);
                    }
    
                }
            }));
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(120000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.exit(0);
                }
            }).start();
        }
    }

[Spring_]: https://blog.csdn.net/xl_1803/article/details/109462842
[Sentinel Parameter Flow Control]: /images/20221123/0660052e3c88441f8027d25976592c1b.png