一、热点

热点就是访问非常频繁的参数，例如商城系统中首页的数据；热点参数就比如是商城系统商品的id。
那么 Sentinel 是怎么知道哪些参数是热点，哪些参数不是热点的呢？Sentinel 利用 LRU 策略，结合底层的滑动窗口机制来实现热点参数统计。LRU 策略可以统计单位时间内，最近最常访问的热点参数，而滑动窗口机制可以帮助统计每个参数的 qps。
说简单点就是，Sentinel 会先检查出提交过来的参数，哪些是热点的参数，然后在应用热点参数的限流规则，将qps 超过设定阈值的请求给 block 掉，整个过程如下图所示：

image.png

二、如何应用

1、引入依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-parameter-flow-control</artifactId>
    <version>x.y.z</version>
</dependency>

2、定义资源

使用热点限流时，定义资源和普通限流的操作方式是一致的。例如我们可以定义资源名为：

/**
     * 资源名
     */
    private static String RESOURCE_NAME = "freqParam";

3、定义规则

定义好资源之后，就可以来定义规则了，我们还是先用简单的硬编码的方式来演示，实际的使用过程中还是要通过控制台来定义规则的。
热点参数的规则是通过 ParamFlowRule 来定义的，跟流控的规则类 FlowRule 差不多，具体的属性如下表所示：

image.png

定义好规则之后，可以通过 ParamFlowRuleManager 的 loadRules 方法更新热点参数规则，如下所示：

private void init() {
        // 定义热点限流的规则，对第一个参数设置 qps 限流模式，阈值为5
        ParamFlowRule rule = new ParamFlowRule(RESOURCE_NAME)
                .setParamIdx(0)
                .setGrade(RuleConstant.FLOW_GRADE_QPS)
                .setCount(5);
        ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
    }

4、埋点

我们定义好资源，也定义好规则了，最后一步就是在代码中埋点来使应用热点限流的规则了。
那么如何传入对应的参数来让 Sentinel 进行统计呢？我们可以通过 SphU 类里面几个 entry 重载方法来传入
其中最后的一串 args 就是要传入的参数，有多个就按照次序依次传入。
还是通过一个简单的 Controller 方法来进行埋点，如下所示：

/**
     * 热点参数限流
     * 构造不同的uid的值，并且以不同的频率来请求该方法，查看效果
     */
    @GetMapping("/freqParamFlow")
    public String freqParamFlow(@RequestParam("uid") Long uid, @RequestParam("ip") Long ip) {
        Entry entry = null;
        String retVal;
        try{
            // 只对参数 uid 的值进行限流，参数 ip 的值不进行限制
            entry = SphU.entry(RESOURCE_NAME, EntryType.IN,1,uid);
            retVal = "passed";
        }catch(BlockException e){
            retVal = "blocked";
        }finally {
            if(entry!=null){
                entry.exit();
            }
        }
        return retVal;
    }

5、查看效果

image.png image.png

sentinel控制台展示结果：

image.png

完整代码：

package com.gzf.sentinel.controller;

import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.EntryType;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientAssignConfig;
import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientConfig;
import com.alibaba.csp.sentinel.cluster.client.config.ClusterClientConfigManager;
import com.alibaba.csp.sentinel.datasource.ReadableDataSource;
import com.alibaba.csp.sentinel.datasource.nacos.NacosDataSource;
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.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.Collections;
import java.util.List;

/**
 * @program: sentinel-tutorial
 * @description: 集群热点参数限流规则
 * @author: Gaozf
 * @create: 2020-07-24 16:58
 **/
@RestController
public class ParamFlowController {
    private static String RESOURCE_NAME = "freqParam";

    private static final String APP_NAME = "single";

    private static final String REMOTE_ADDRESS = "localhost";
    private static final String GROUP_ID = "DEFAULT_GROUP";

    private static final String PARAM_FLOW_POSTFIX = "-param-rules";

    public ParamFlowController(){
        //registerClusterFlowRuleProperty();
        init();
    }

    private void init() {
        // 定义热点限流的规则，对第一个参数设置 qps 限流模式，阈值为5
        ParamFlowRule rule = new ParamFlowRule(RESOURCE_NAME)
                .setParamIdx(0)
                .setGrade(RuleConstant.FLOW_GRADE_QPS)
                .setCount(5);
        ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
    }
    /**
     * 注册动态规则Property
     * 当client与Server连接中断，退化为本地限流时需要用到的该规则
     */
    private void registerClusterFlowRuleProperty(){
        // 使用 Nacos 数据源作为配置中心，需要在 REMOTE_ADDRESS 上启动一个 Nacos 的服务
        ReadableDataSource<String, List<FlowRule>> ds = new NacosDataSource<>(REMOTE_ADDRESS, GROUP_ID, APP_NAME+PARAM_FLOW_POSTFIX,
                source -> JSON.parseObject(source, new TypeReference<List<FlowRule>>() {}));
        // 为集群客户端注册动态规则源
        FlowRuleManager.register2Property(ds.getProperty());
    }

    /**
     * 热点参数限流
     * 构造不同的uid的值，并且以不同的频率来请求该方法，查看效果
     */
    @GetMapping("/freqParamFlow")
    public String freqParamFlow(@RequestParam("uid") Long uid, @RequestParam("ip") Long ip) {
        Entry entry = null;
        String retVal;
        try{
            // 只对参数 uid 的值进行限流，参数 ip 的值不进行限制
            entry = SphU.entry(RESOURCE_NAME, EntryType.IN,1,uid);
            retVal = "passed";
        }catch(BlockException e){
            retVal = "blocked";
        }finally {
            if(entry!=null){
                entry.exit();
            }
        }
        return retVal;
    }

    @GetMapping("/freqParamFlowTwo")
    public String freqParamFlowTwo(@RequestParam("uid") Long uid, @RequestParam("ip") Long ip) {
        Entry entry = null;
        String retVal;
        try{
            // 只对参数 uid 的值进行限流，参数 ip 的值不进行限制
            entry = SphU.entry(RESOURCE_NAME, EntryType.IN,1);
            retVal = "passed";
        }catch(BlockException e){
            retVal = "blocked";
        }finally {
            if(entry!=null){
                entry.exit();
            }
        }
        return retVal;
    }
}