第二十二章 alibaba sentinel详解-各种规则的应用

墨蓝 2024-04-01 13:33 52阅读 0赞

**目录**

一、总体规则

二、流量规则

1、QPS

2、线程数

3、关联

4、预热

5、排队等待

三、熔断降级

1、慢调用比例

2、异常比例

3、异常数

四、热点key限流

1、@SetinelReource指定别名

2、设置规则

3、进行测试

4、@SetinelReource指定ParamFlowException 异常降级方法

5、@SetinelReource指定 业务异常 降级方法

6、参数列外项

参数例外项

--------------------

学习中文官网：[Home · alibaba/Sentinel Wiki · GitHub][Home _ alibaba_Sentinel Wiki _ GitHub]

### 一、总体规则 ###

五大规则

*  流量规则--流量控制（flow control）
 *  降级规则--熔断降级
 *  热点规则--热点参数（Paramflow）
 *  系统规则--了解(见[官网][Link 1])
 *  授权规则--黑白名单控制规则

>  *  资源名： 唯一名称，默认请求路径
>  *  针对来源： Sentinel可以战队调用者进行限流，填写服务名。默认为default(不区分来源)
>  *  阈值类型/单击阈值
> 
> QPS(每秒中的请求数量): 当调用该api的QPS达到阈值的时候，进行限流
> 
> 线程数： 当调用该api的线程数达到阈值的时候，进行限流
> 
>  *  是否集群： 不需要集群
>  *  流控模式：
> 
> 直连： api达到限流条件时，直接限流
> 
> 关联： 当关联的资源达到阈值的时候，就限流自己
> 
> 链路： 指记录指定链路上的流量(指定资源从入口资源进来的流量，如果达到阈 值，如果达到阈值，就进行限流)【api级别的针对来源】
> 
>  *  流控效果：
> 
> 快速失败：　直接失败，抛异常 ＋ Warm Up: 根据codeFactor(冷加载因子，默认为3)的值，从阈值/codeFactor，经过预热时长，才打到设置的QPS的阈值。
> 
> 匀速排队： 匀速排队，让请求以匀速的速度通过，阈值类型必须设置为QPS，否则无效。

本章案例都是 基于第二十一章 中案例代码。

### 二、流量规则 ###

原理是监控应用流量的 QPS 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

#### 1、QPS ####

> 原理：每秒中的请求次数超过设定的[阈值][Link 2]的时候，进行限流。
> 
> 例如 设置保护资源为 订单服务中的 /order/buy/\{id\}，流控规则中阈值为2。如果没有配置规则，这1s内来多少个请求就要处理多少个请求。如果配置规则，例如阈值为1s内可以访问2个请求，若超出2个的第三个及以后的请求都会被拒接。

*  新建规则

![1f4ec70147f94235bec8a3760eba698e.png][]

*  选择阈值QPS、流控模式直接、流控效果快速失败

![08b8f6379f6149118950031e73a6dad1.png][]

![84bba3690eb14e0198f9bcfe58936289.png][]

*  进行测试

![702baaab4144498cb91da727032db5a8.png][]

![c1db2875c2114cd9afa5dbb8165f2073.png][]

#### 2、线程数 ####

> 原理： 当调用该[api][]的线程数达到设定的阈值，进行限流  
> **类似于在银行办业务，同一个窗口同一时间只有一个客户在办理，其他客户必须等该客户办理完之后才可以办理**

*  设置订单服务的 OrderController 中 buy 方法

在 buy 方法中设置延迟时间超过1s，模拟银行工作人员为顾客办理业务时间。

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            //每个线程进入后都要等待0.8s，例如银行业务人员给顾客办理业务时间
            try {
                Thread.sleep(800);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setId(id);
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置线程数请求阈值

![869b3cd683e14679aff2030be7166faf.png][]

*  请求测试

点击不断刷新

![68bd2144ba5b45818a9cef3c944d9299.png][]

#### 3、关联 ####

> 原理：当关联的资源达到阈值的时候，就限流自己
> 
> 例如订单的支付接口繁忙时候，则对下订单接口进行限流。本案例中订单服务中有两个资源 /order/buy/\{id\} 与 /order/select/\{id\}，因为在同一个controller中，因此是关联的。我们在 /order/buy/\{id\} 繁忙的时候，对 /order/select/\{id\} 限流，所以保护的资源是 /order/select/\{id\}，关联的资源是 /order/buy/\{id\}，流控规则中阈值为1。当关联的资源 /order/buy/\{id\}的请求超出1后，资源 /order/select/\{id\} 会被限流。

*  代码

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            Product product = orderFeignService.findOrderById(id);
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setId(id);
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置规则

![b63505b699264d6bad7b0f3f6089e817.png][]

*  进行测试

![56b4c89e32e14c9da8f442c09c780519.png][]

jmeter下载地址：[压力测试工具----JMeter\_爱吃面的猫的博客-CSDN博客][----JMeter_-CSDN]

压力测试访问关联资源 [http://localhost:9000/order/buy/1][http_localhost_9000_order_buy_1]

![7450cc43743745f185830e9d1de5a19e.png][]

![aa8f71a22b3e47928e9d98376788fd88.png][]

当关联资源http://localhost:9000/order/buy/1 请求超出阈值后，则[http://localhost:9000/order/select/1][http_localhost_9000_order_select_1] 被限流。

![c8e80127be2a40c99bfe0c711cb7628f.png][]

#### 4、预热 ####

> 定义：Warm Up ( RuleConstant.CONTROL\_BEHAVIOR\_MARA\_UP）方式，即预热/冷启动方式。当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统装压垮。
> 
> 应用场景：如：秒杀系统开启的瞬间，会有很多流量上来，很有可能会把系统打死，预热方式就是为了把系统保护起来， 可慢慢的把流量放进来，慢慢的把阈值增加到设定的值。
> 
> 原理：根据codeFactor(冷加载因子，默认的codeFactor为3)的值，从阈值/codeFactor，经过预热时长，才达到设置的QPS的阈值。
> 
> 案例：阈值10+，预热时间设置5秒，系统初始化的阈值为10/3约等于3，即阈值刚开始为3，经过了5秒后阈值才慢慢升高到10。

*  源码：

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            Product product = orderFeignService.findOrderById(id);
            System.out.println("/buy/{id} 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setId(id);
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置规则

![a730ff209bb049f1a6a35dffbda63069.png][]

*  进行测试

开始不行，后来慢慢就可以了，刚开始狂点 [http://localhost:9000/order/buy/1][http_localhost_9000_order_buy_1],会发现报错Blocked by Sentinel (flow limiting),然后5秒后，阈值从3->10后，会发现狂点刷新浏览器不会出现限流。

![6d7183edba3d402090d336be22230b96.png][]

#### 5、排队等待 ####

> **让请求以均匀的请求速度通过，阈值类型必须为QPS，否则无效**  
> 设定 /order/buy/\{id\} 每秒1次请求，请超时的话需要排队等待，等待的超时时间为2000毫秒(即2秒)

代码

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setId(id);
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置规则

![45f33028a34f4e529957431727acd7a1.png][]

*  进行测试

执行半秒后关闭。会看到控制台上依然在打印消息。

![60532a9eb5774598bc22857738dbf081.png][]

![acf8c26478b94d36b912d41e617a345b.png][]

![47247442d4af4901a06d6a17cbda6e14.png][]

### 三、熔断降级 ###

服务熔断作用：就是防止服务雪崩现象出现。

服务熔断：正常情况出现超时、异常、宕机等情况就是服务降级，只有当默认10秒内超过20个请求次数 或者 默认10内超过50%的请求失数 的情况，才是熔断，此时才开启熔断器。

Sentinel熔断降级会在调用链路中某个资源出现不稳定状态时（例如调用超时或异常比例升高)，对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联错误。

当资源被降级后，在接下来的降级时间窗口之内，对该资源的调用都自动熔断(默认行为是抛出 DegradeException)。

**Sentinel熔断降级是没有半开状态的。**

当资源被降级后，在接下来的降级时间窗口之内，对该资源的调用都自动熔断(默认行为是抛出 DegradeException)。

#### 1、慢调用比例 ####

*  1.RT：响应时间，指系统对请求作出响应的时间。
 *  2.统计时长：时间条件，在该时间段内发生的请求，单位毫秒。
 *  3.最小请求数：在统计时长内发出的请求次数。例如在统计时长1s内发出的QPS阈值是5个。
 *  4.慢调用次数：当调用的时间（响应的实际时间）>设置的RT的时间的请求次数。
 *  5.慢调用比例：在所以调用中，慢调用占有实际的比例，= 慢调用次数 / 调用次数
 *  6.比例阈值：自己设定的 ， 慢调用次数 / 调用次数=比例阈值

当平均响应时间 **超出阈值** **且** **在时间窗口通过的请求>=默认5个**，两个条件同时满足后，触发降级。窗口期过后关闭断路器。

*  设置规则

![bcef93cce34f46d38feceb4996a53aae.png][]

这里表示在在1000毫秒，也就是1秒内，发送请求 /order/buy/\{id\} 数超过5时，并且在这些请求中，平均响应时间RT超过200毫秒的有30%，则对请求进行熔断，熔断时长为20秒钟，10秒以后恢复正常。即触发条件：

*  1s内最小请求数必须大于5
 *  慢请求 ÷ 总请求 >= 0.3

*  代码

前面设置RT的最长响应时间是0.2s，此处代码中设置最长响应时间为1s。

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setId(id);
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  进行测试

通过JMeter测试，1秒钟发起10个线程请求 /order/buy/1 ，此时请求数>5，且每个请求的响应时间>RT的0.2s，因此触发熔断效果，停止测试以后，20秒钟以后恢复正常。

![241841bae402409ea7b5c9c681e9c386.png][]

![3312325ae3c44232ba2b7969cddd8975.png][]

浏览器刷新请求[ http://localhost:9000/order/buy/1][http_localhost_9000_order_buy_1]

![f8018e8c970f43fb903677dcde2b6dcd.png][]

#### 2、异常比例 ####

异常比例(DEGRADE\_GRADE\_EXCEPTION\_RATIo)：当资源的每秒请求量>=5，并且每秒异常总数占通过量的比值超过阈值（ DegradeRule中的count ）之后，资源进入降级状态，即在接下的时间窗口( DegradeRule中的timeWindow，以s为单位)之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是\[0.0,1.0\]。

*  代码

设置异常，如果id<=0则抛出异常。

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            if (id<=0){
                throw new RuntimeException("selectById 执行异常");
            }
            Product product = new Product();
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置规则

设置1000毫秒即1s内最小请求是5个，如果错误请求/总的请求数超过>=阈值0.3 则触发熔断。

> 触发条件：
> 
> 1s内最小请求数大于5
> 
> 异常数/总请求数 > 0.3

![31ad4d13cb604ac0a7d4eb0c1aa0b56d.png][]

*  进行测试

访问 [http://localhost:9000/order/select/-1][http_localhost_9000_order_select_-1]![87036700668545f39a818c4251e4b417.png][]

访问 [http://localhost:9000/order/select/1][http_localhost_9000_order_select_1]![1112788cbdb94fca8ccdf07f7e2dbad1.png][]

通过JMeter测试，1秒钟发起10个线程请求 /order/select/-1 ，此时请求数>5，且错误请求/总的请求数>0.3，因此触发熔断效果，停止测试以后，10秒钟以后恢复正常。 ![f7c913a523f54807bab8c1fd24b85bf3.png][]

![8f239f677f1a4f9692bd06548d2e850a.png][]

浏览器同时访问 [http://localhost:9000/order/select/1][http_localhost_9000_order_select_1]![f50e9a0c6a34402baf53fb6a8dff7491.png][]

#### 3、异常数 ####

异常数( DEGRADE\_GRADE\_EXCEPTION\_COUNT )：单位时间内异常数目超过阈值之后会进行熔断。

*  代码：

package com.hwadee.springcloud.controller;
    
    
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        public Product selectById(@PathVariable Long id) {
            if (id<=0){
                throw new RuntimeException("selectById 执行异常");
            }
            Product product = new Product();
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

*  设置规则

> 触发条件：
> 
> 每秒请求数必须大于5
> 
> 每秒的异常数必须大于3【我们设置的阈值】

![1752a024496348dca340e53fb12980d0.png][]

*  进行测试

不断刷新 [http://localhost:9000/order/select/-1][http_localhost_9000_order_select_-1]

![1a4b35e913a34a18bc7d65d19105cc8a.png][]

### 四、热点key限流 ###

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

> 比如：商品秒杀，在某一时间内对此秒杀的商品进行限流，如商品 ID 为参数，统计一段时间内最常购买的商品 ID 并进行限制。又如：用户 ID 为参数，针对一段时间内频繁访问的用户 ID 进行限制。

热点参数限流会统计传入参数中的热点参数，并根据配置的限流阈值与模式，对包含热点参数的资源调用进行限流。热点参数限流可以看做是一种特殊的流量控制，仅对包含热点参数的资源调用生效。

#### 1、@SetinelReource指定别名 ####

热点参数限流时候，不能使用资源路径，只能使用资源路径的别名。资源路径别名的指定是在注解@SetinelReource中使用value属性指定。 例如 对 selectById 方法 使用 @SentinelResource(value = "selectById") 指定别名为 selectById。

package com.hwadee.springcloud.controller;
    
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        @SentinelResource(value = "selectById")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    }

![59a06ed141a3425ebb161f0bf7b687a0.png][]

#### 2、设置规则 ####

![fd558607f39046aba53f4b3985cf964b.png][]

#### 3、进行测试 ####

![8b680a398dbb4c72ac663aacd5d91fcf.png][]

#### 4、@SetinelReource指定ParamFlowException 异常降级方法 ####

使用 @SetinelReource中 blockHandler 属性指定降级方法，如果不指定，blockHandler会抛出异常，即BlockException异常的子异常 ParamFlowException。

*  代码

package com.hwadee.springcloud.controller;
    
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.alibaba.csp.sentinel.slots.block.BlockException;
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        @SentinelResource(value = "selectById",blockHandler = "handle_selectById")
        public Product selectById(@PathVariable Long id) {
            Product product = new Product();
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    
        public Product handle_selectById(Long id, BlockException exception) {
            Product product = new Product();
            product.setName("哎吆，服务走神了，请稍后重试");
            System.out.println(product);
            return product;
        }
        
    }

*  指定规则

![ff7b56fb1688423ca946bab89ceced30.png][]

*  进行测试

![f1d72fe44a6942eea17229e1fc8857b8.png][]

#### 5、@SetinelReource指定 业务异常 降级方法 ####

使用 @SetinelReource中 fallback 或则 defaultFallback 指定业务中的异常降级，其中 fallback 用于指定业务报错时候的自定义方案，defaultFallback 用于指定业务报错时候的默认方案。如果二者同时有，则选择自定义，如果没有自定义，则选择默认。

*  代码

package com.hwadee.springcloud.controller;
    
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.alibaba.csp.sentinel.slots.block.BlockException;
    import com.hwadee.springcloud.entity.Product;
    import com.hwadee.springcloud.service.IOrderFeignService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cloud.context.config.annotation.RefreshScope;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.math.BigDecimal;
    import java.util.concurrent.TimeUnit;
    
    @RestController
    @RequestMapping("/order")
    @RefreshScope
    public class OrderController {
    
        @Autowired
        IOrderFeignService orderFeignService;
    
        @RequestMapping("/buy/{id}")
        public Product buy(@PathVariable Long id) {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            Product product = orderFeignService.findOrderById(id);
            System.out.println(Thread.currentThread().getName()+"\t"+"/buy/"+id+" 执行");
            return product;
        }
    
        @RequestMapping("/select/{id}")
        @SentinelResource(value = "selectById",blockHandler = "handle_selectById",
                fallback ="fallback__selectById",
                defaultFallback = "defaultFallback_selectById")
        public Product selectById(@PathVariable Long id) {
            if (id<=0){
                throw  new RuntimeException("selectById 执行异常");
            }
            Product product = new Product();
            product.setName("selectById 执行");
            System.out.println(product);
            return product;
        }
    
    
        public Product handle_selectById(Long id, BlockException exception) {
            Product product = new Product();
            product.setName("哎吆，服务走神了，请稍后重试");
            System.out.println(product);
            return product;
        }
    
        public Product fallback__selectById(Long id) {
            Product product = new Product();
            product.setName("哎吆，服务走神了，请稍后重试fallback__selectById");
            System.out.println(product);
            return product;
        }
    
        public Product defaultFallback_selectById() {
            Product product = new Product();
            product.setName("哎吆，服务走神了，请稍后重试defaultFallback_selectById");
            System.out.println(product);
            return product;
        }
    
    }

*  进行测试

先进行单次浏览，发现会发生异常，但会调用降级方法

![929027929752440fa221710fead318f8.png][]

1s内多次刷新，即使报错，达到热点参数的阈值也会触发热点参数的条件。

![bd616595eba24e5986ae049f9ed7185b.png][]

#### 6、参数列外项 ####

*  设置规则

当我们对华为手机秒杀进行限流的时候，希望对华为手机的id=5的品牌进行不限流，id=5即使例外项。

![52d6d0ca5fe64b54a16c04a276404e90.png][]

> 参数下标为第0个的参数(后台接收的时候知道是Long,需要选择对应的数据类型)，正常情况下QPS阈值为3，超过马上被限流，但是如果id的参数值是5(id=5)的时候，他的QPS阈值为200。

*  进行测试

![96f2fff38a9d48d6b73103206ab897f3.png][]

第二十一章：[alibaba sentinel详解-应用入门案例][alibaba sentinel_-]

第二十三章：[alibaba sentinel详解-sentinel持久化 ][alibaba sentinel_-sentinel_]

[Home _ alibaba_Sentinel Wiki _ GitHub]: https://github.com/alibaba/Sentinel/wiki
[Link 1]: https://github.com/alibaba/Sentinel/wiki/%E7%B3%BB%E7%BB%9F%E8%87%AA%E9%80%82%E5%BA%94%E9%99%90%E6%B5%81
[Link 2]: https://so.csdn.net/so/search?q=%E9%98%88%E5%80%BC&spm=1001.2101.3001.7020
[1f4ec70147f94235bec8a3760eba698e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/0710552794124ba0aa9a045c010a0199.png
[08b8f6379f6149118950031e73a6dad1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5ff771cde5884b9f9e1d2f07f17fc2c4.png
[84bba3690eb14e0198f9bcfe58936289.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/45277747d77043be8e1b942f8b64d38d.png
[702baaab4144498cb91da727032db5a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/421f2e452dd04de98a543894b569a2ad.png
[c1db2875c2114cd9afa5dbb8165f2073.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/efde21735d63463c8e74eb0c45a5f60a.png
[api]: https://so.csdn.net/so/search?q=api&spm=1001.2101.3001.7020
[869b3cd683e14679aff2030be7166faf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3cd8c1e05fb6447c8768a6e99b4a1efa.png
[68bd2144ba5b45818a9cef3c944d9299.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4ff4902e633c4651abdad6dd29031cb0.png
[b63505b699264d6bad7b0f3f6089e817.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2f9d945e37954279ac5725ac965f870f.png
[56b4c89e32e14c9da8f442c09c780519.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/22109ea3eb014b40aeeb15b6fd9f03d1.png
[----JMeter_-CSDN]: https://blog.csdn.net/qq_41946216/article/details/127652597?spm=1001.2014.3001.5502
[http_localhost_9000_order_buy_1]: http://localhost:9000/order/buy/1
[7450cc43743745f185830e9d1de5a19e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/b2cd10c2cc0145758ed4c967b1e3a3d0.png
[aa8f71a22b3e47928e9d98376788fd88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c6e76b2546fb41ff8da80ef235ec4b79.png
[http_localhost_9000_order_select_1]: http://localhost:9000/order/select/1
[c8e80127be2a40c99bfe0c711cb7628f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6f2c9b0e082e46269da55e93945bdcbe.png
[a730ff209bb049f1a6a35dffbda63069.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/f39b45cfcfef4e93b7f7de0026d9de3b.png
[6d7183edba3d402090d336be22230b96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/6df66c9d218640f09af3ee4b1a266b59.png
[45f33028a34f4e529957431727acd7a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/65cbf0d43d6b429a916a9c0e87abe3b3.png
[60532a9eb5774598bc22857738dbf081.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ce3de05586c546a29dade45bdd47a68b.png
[acf8c26478b94d36b912d41e617a345b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/642460a568484087a0d59d25a875db1b.png
[47247442d4af4901a06d6a17cbda6e14.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/97b265a3b6704da7bda8ad677fc96110.png
[bcef93cce34f46d38feceb4996a53aae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7ca97d3f2a2c4db4a0779f623e3862df.png
[241841bae402409ea7b5c9c681e9c386.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e3a0857398a44ffbb810c4e99ac7a410.png
[3312325ae3c44232ba2b7969cddd8975.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5c4fa0107255413593189f6dbdbcd1df.png
[f8018e8c970f43fb903677dcde2b6dcd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/16e912e153a74c4b81a2bb2b526f6e22.png
[31ad4d13cb604ac0a7d4eb0c1aa0b56d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/1d434a4653ba46c0845a6a67cbe99b99.png
[http_localhost_9000_order_select_-1]: http://localhost:9000/order/select/-1
[87036700668545f39a818c4251e4b417.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/296b98ba7dd1418bb04958445c599edf.png
[1112788cbdb94fca8ccdf07f7e2dbad1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3fb7c117e6b0420e9dbf8316d38bdf9a.png
[f7c913a523f54807bab8c1fd24b85bf3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/984cef762bd0400185dae5c91901508c.png
[8f239f677f1a4f9692bd06548d2e850a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/d8c9861346864b22852ddb6656edeba5.png
[f50e9a0c6a34402baf53fb6a8dff7491.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/7fab4fc98711453a8a8b9154745726d5.png
[1752a024496348dca340e53fb12980d0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/84c2e086a1df4ba6b0fef6458dd608c9.png
[1a4b35e913a34a18bc7d65d19105cc8a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/208354a57b5d4cea99b8940588dcc246.png
[59a06ed141a3425ebb161f0bf7b687a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2befb2a3e03a464fb43cf2a997756655.png
[fd558607f39046aba53f4b3985cf964b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8b58cd9b93e848f2b36ed90886e9e8a1.png
[8b680a398dbb4c72ac663aacd5d91fcf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5fb13aaa68d74d1bab6e27cdc3ca689b.png
[ff7b56fb1688423ca946bab89ceced30.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/8d23cc8b81de4e16a04dd1af608efc22.png
[f1d72fe44a6942eea17229e1fc8857b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/c146890196144fd18956f763bfac372c.png
[929027929752440fa221710fead318f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/64c3930437de44fd9561a7a85b095f31.png
[bd616595eba24e5986ae049f9ed7185b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5d5c8b96f21c4f019be5b769dcb1f500.png
[52d6d0ca5fe64b54a16c04a276404e90.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2337ffdb5634424e9187a1709923cf20.png
[96f2fff38a9d48d6b73103206ab897f3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/4e1e0390febd4b64b8e8dcd248ccf776.png
[alibaba sentinel_-]: https://blog.csdn.net/qq_41946216/article/details/127636660?spm=1001.2014.3001.5502
[alibaba sentinel_-sentinel_]: https://blog.csdn.net/qq_41946216/article/details/127686078?spm=1001.2014.3001.5502