【Spring Cloud Alibaba】008-Sentinel

- 日理万妓 2023-09-24 20:58 70阅读 0赞

## 【Spring Cloud Alibaba】008-Sentinel ##

#### 文章目录 ####

*  【Spring Cloud Alibaba】008-Sentinel
 *  一、服务雪崩
 *   *  1、概述
     *  2、解决方案
     *   *  常见的容错机制
 *  二、Sentinel：分布式系统的流量防卫兵
 *   *  1、\*\*Sentinel\*\* 概述
     *   *  简介
         *  特性
         *  Sentinel 的开源生态
         *  Sentinel 的历史
     *  2、Sentinel 基本概念
     *   *   *  资源
             *  规则
     *  3、Sentinel 功能和设计理念
     *   *  流量控制
         *  流量控制设计理念
     *  4、熔断降级
     *   *  什么是熔断降级
         *  熔断降级设计理念
         *  系统自适应保护
     *  5、Sentinel 是如何工作的
 *  三、Sentinel 使用
 *   *  1、基本使用
     *   *  第一步：引入依赖
         *  第二步：编写代码
         *  第三步：访问测试
         *  缺点
     *  2、@SentinelResource 注解
     *  3、注解开发
     *   *  第一步：引入依赖
         *  第二步：添加 bean
         *  第三步：编写代码
         *  第四步：访问测试
 *  四、降级规则初体验
 *   *  1、熔断降级规则 (DegradeRule)
     *   *  熔断策略
         *  属性说明
         *  熔断器事件监听
     *  2、初体验\*
 *  五、控制台部署
 *   *  1、启动控制台
     *   *  第一步：获取 Sentinel 控制台
         *  第二步：启动
     *  2、客户端接入控制台
     *   *  第一步：引入依赖
         *  第二步：配置启动参数
         *  第三步：重启，并访问资源
         *  第四步：查看控制台
 *  六、整合 Spring Cloud Alibaba
 *   *  1、引入依赖
     *  2、修改 yaml 配置
     *  3、启动 sentinel 和 项目
 *  七、流控规则
 *   *  1、概述
     *  2、QPS
     *   *  第一步：增加一个接口
         *  第二步：配置流控规则
         *  第三步：访问测试
         *  第四步：配置异常处理方法
         *  第五步：重启，并访问测试
     *  2、并发线程数
     *   *  概述
         *  第一步：修改代码，重启项目
         *  第二步：设置流控规则
         *  第三步：访问测试
 *  八、统一异常处理 BlockException
 *   *  1、定义统一返回类
     *  2、定义统一异常处理类
     *  3、修改接口代码
     *  4、设置流控，访问测试
 *  九、流控模式
 *   *  1、概述
     *  2、关联
     *   *  说明
         *  第一步：创建接口
         *  第二步：运行访问，设置限流策略
         *  第三步：访问测试
     *  3、链路
     *   *  第一步：编写代码
         *  第二步：修改 yaml 配置
         *  第三步：运行访问，设置限流策略
         *  第四步：访问测试
         *  备注
 *  十、流控效果
 *   *  1、概述
     *   *  快速失败
         *  Warm Up（激增流量/预热流控）
         *  排队等待（脉冲流量）
     *  2、预热流控
     *   *  第一步：创建接口
         *  第二步：运行访问，设置限流策略
         *  第三步：访问测试
     *  3、排队等待
     *   *  第一步：修改流控规则
         *  第二步：有规律刷新网页
         *  第三步：设置排队等待
         *  第四步：再次有规则刷新网页
 *  十一、整合 OpenFeign 降级
 *   *   *  参考文章
 *  十二、热点规则：热点参数限流
 *   *  1、概述
     *  2、演示
     *   *  第一步：创建接口
         *  第二步：新增热点规则
         *  第三步：编辑热点规则高级选项
         *  第四步：访问测试
 *  十三、系统规则：系统保护规则
 *   *  １、概述
     *  2、系统保护配置示例
 *  十四、规则持久化
 *   *  1、持久化配置的必要
     *  2、三种模式
     *   *  原始模式：
         *  拉模式
         *  推模式（生产环境常用）
     *  3、基于 Nacos 配置中心控制台实现推送\*
     *   *  第一步：引入依赖
         *  第二步：启动 Nacos ，并创建配置文件
         *  第三步：修改 yaml 配置文件
 *  十五、Gateway 整合 Sentinel

## 一、服务雪崩 ##

### 1、概述 ###

因**服务提供者**的不可用导致**服务调用者**的不可用，并将不可用**逐渐放大**的过程，就叫**服务雪崩效应**。

在**服务提供者不可用**的时候，会出现**大量重试**的情况：**用户重试、代码逻辑重试**，这些重试最终导致：**进一步加大请求**

**流量**。所以归根结底导致雪崩效应的**最根本原因**是：\*\*大量请求线程同步等待造成的资源耗尽。\*\*当服务调用者使用同步调

用时, 会产生大量的等待线程占用系统资源。一旦线程资源被耗尽，服务调用者提供的服务也将处于不可用状态,，于是服务

雪崩效应产生了。

### 2、解决方案 ###

> 稳定性 恢复性

#### 常见的容错机制 ####

*  **超时机制：** 在不做任何处理的情况下，服务提供者不可用会导致消费者请求线程**强制等待**，而造成系统资源耗尽。加入超时机制，**一旦超时，就释放资源**。由于释放资源速度较快，一定程度上可以抑制资源耗尽的问题。
 *  **服务限流：** 限制流量，直接拒绝部分请求。
 *  **线程隔离：** 用户的请求将**不再直接访问服务**，而是通过线程池中的**空闲线程来访问**服务，如果线程池已满，则会进行**降级**
    
    **处理**，用户的请求**不会被阻塞**，至少可以看到一个**执行结果**（例如返回友好的提示信息），而不是无休止的等待或者看
    
    到系统崩溃。
 *  **信号隔离：** 信号隔离也可以用于**限制并发访问**，防止阻塞扩散，与线程隔离最大不同在于执行依赖代码的线程依然是请求线程（该线程需要通过信号申请，如果客户端是可信的且可以快速返回，可以使用信号隔离替换线程隔离，降低开销。信号量的大小可以动态调整，线程池大小不可以。
 *  **服务熔断：** 远程服务不稳定或网络抖动时**暂时关闭**，就叫服务熔断。（就像日常生活中，电路跳闸，压力太大的时候自动关闭）。实时监测应用，如果发现在一定时间内失败次数/失败率达到**一定阈值**，就“跳闸”，断路器打开——此时，请求直接返回，而不去调用原本调用的逻辑。跳闸一段时间后（例如10秒），断路器会**进入半开状态**，这是一个瞬间态，此时**允许一次请求**调用该调的逻辑，如果成功，则**断路器关闭**，应用正常调用；如果调用依然不成功，**断路器**继续回到打开状态，过段时间再进入**半开状态**尝试——通过”跳闸“，应用可以保护自己，而且避免浪费资源；而通过半开的设计，可实现**应用的“自我修复“**。**当依赖的服务有大量超时时，在让新的请求去访问根本没有意义，只会无畏的消耗现有资源。**
 *  **服务降级：** 有服务熔断，必然要有服务降级。所谓降级，就是当某个服务熔断之后，服务将不再被调用，此时客户端可以自己准备一个**本地的 fallback（回退）回调，返回一个缺省值。** 例如：(备用接口/缓存/mock数据) 。这样做，虽然服务水平下降，但好歹可用，比直接挂掉要强，当然这也要看适合的业务场景。

## 二、Sentinel：分布式系统的流量防卫兵 ##

### 1、**Sentinel** 概述 ###

#### 简介 ####

Sentinel 是面向**分布式服务架构**的高可用**流量防护组件**，主要以流量为切入点，从**限流、流量整形、熔断降级、系统负载保护、热点防护**等多个维度来帮助开发者**保障微服务的稳定性**。

源码地址：https://github.com/alibaba/Sentinel

官方文档：https://github.com/alibaba/Sentinel/wiki

**Sentinel 的使用可以分为两个部分:**

*  核心库（Java 客户端）：不依赖任何框架/库，能够运行于 Java 8 及以上的版本的运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持（见 [主流框架适配][Link 1]）。
 *  控制台（Dashboard）：控制台主要负责**管理推送规则、监控、集群限流分配管理、机器发现**等。

#### 特性 ####

*  **丰富的应用场景**：Sentinel 承接了阿里巴巴近 10 年的**双十一大促流量**的核心场景，例如秒杀（即突发流量控制在系统容量可以承受的范围）、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
 *  **完备的实时监控**：Sentinel 同时提供**实时的监控功能**。您可以在控制台中看到接入应用的**单台机器秒级数据**，甚至 500 台以下规模的集群的汇总运行情况。
 *  **广泛的开源生态**：Sentinel 提供**开箱即用**的与其它开源框架 / 库的整合模块，例如与 Spring Cloud、Dubbo、gRPC 的整合。您只需要**引入相应的依赖并进行简单的配置**即可快速地接入 Sentinel。
 *  **完善的 SPI 扩展点**：Sentinel 提供**简单易用、完善**的 SPI 扩展接口。您可以通过实现扩展接口来快速地**定制逻辑**。例如定制规则管理、适配动态数据源等。

![img][]

#### Sentinel 的开源生态 ####

![img][img 1]

#### Sentinel 的历史 ####

*  2012 年，Sentinel 诞生，主要功能为**入口流量控制**。
    
    > 为流量而生！
 *  2013-2017 年，Sentinel 在**阿里巴巴集团内部**迅速发展，成为**基础技术模块**，覆盖了所有的核心场景。Sentinel 也因此积累了大量的**流量归整场景**以及生产实践。
    
    > 说白了，就是主要用来控制流量的！
 *  2018 年，Sentinel 开源，并持续演进。
    
    > 人是有强烈的表达欲的，特别是大师！只有自己知道了关于宝藏的秘密是不行的，你不分享出去别人还以为你啥也不知道呢！
    > 
    > 另外，开源也是逼迫内部进行架构、代码大整理的机会！
 *  2019 年，Sentinel 朝着多语言扩展的方向不断探索，推出 [C++ 原生版本][C_]，同时针对 Service Mesh 场景也推出了 [Envoy 集群流量控制支持][Envoy]，以解决 Service Mesh 架构下多语言限流的问题。
    
    > 逐渐完善，并走向成熟！
 *  2020 年，推出 [Sentinel Go 版本][Sentinel Go]，继续朝着云原生方向演进。

### 2、Sentinel 基本概念 ###

##### 资源 #####

资源是 Sentinel 的关键概念。它可以是 **Java 应用程序中的任何内容**，例如，由应用程序提供的服务，或由应用程序调用的其它应用提供的服务，甚至可以是一段代码。在接下来的文档中，我们都会**用资源来描述代码块**。

只要通过 Sentinel API 定义的代码，就是**资源**，能够被 Sentinel 保护起来。大部分情况下，可以使用**方法签名，URL，甚至服务名称**作为资源名来标示资源。

##### 规则 #####

围绕资源的**实时状态**设定的规则，可以包括**流量控制规则、熔断降级规则以及系统保护规则**。所有**规则可以动态实时调整**。

> 是规则，也是策略！根据策略，制定规则！

### 3、Sentinel 功能和设计理念 ###

#### 流量控制 ####

**什么是流量控制**

流量控制在网络传输中是一个常用的概念，它**用于调整网络包的发送数据**。然而，从系统**稳定性**角度考虑，在处理请求的**速度**上，也有非常多的讲究。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个**调配器**，可以根据需要把随机的请求调整成合适的形状，如下图所示：

![img][img 2]

#### 流量控制设计理念 ####

流量控制有以下几个角度:

*  **资源的调用关系**，例如资源的调用链路，资源和资源之间的关系；
 *  **运行指标**，例如 QPS、线程池、系统负载等；
    
    > QPS：每秒访问量。
 *  \*\*控制的效果，\*\*例如直接限流、冷启动、排队等。
    
    > 效果，也是策略，进而形成规则！
    > 
    > **目标 => 策略 => 规则！三步走！**

Sentinel 的设计理念是让您**自由选择控制的角度**，并进行**灵活组合**，从而达到想要的效果。

> **自由选择 + 灵活组合 + 动态调整 = 理想效果！**

### 4、熔断降级 ###

#### 什么是熔断降级 ####

除了**流量控制**以外，及时对调用链路中的不稳定因素进行**熔断**也是 Sentinel 的使命之一。由于调用关系的复杂性，如果调用链路中的某个资源出现了不稳定，可能会导致请求发生堆积，进而导致级联错误。

> \*\*一个服务常常会调用别的模块，可能是另外的一个远程服务、数据库，或者第三方 API 等。\*\*例如，支付的时候，可能需要远程调用银联提供的 API；查询某个商品的价格，可能需要进行数据库查询。然而，这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用服务的方法的响应时间也会变长，线程会产生堆积，最终可能耗尽业务自身的线程池，服务本身也变得不可用。

> **流量控制 + 熔断降级**

![img][img 3]

现代微服务架构都是**分布式**的，由非常多的服务组成。不同服务之间**相互调用**，组成**复杂的调用链路**。以上的问题在链路调用中会产生放大的效果。复杂链路上的某一环**不稳定**，就可能会**层层级联**，最终导致整个链路都不可用。因此我们需要对不稳定的**弱依赖服务调用**进行熔断降级，暂时切断不稳定调用，避免局部不稳定因素导致整体的雪崩。熔断降级作为保护自身的手段，通常在客户端（调用端）进行配置。

> **注意**：本文档针对 Sentinel 1.8.0 及以上版本。1.8.0 版本对熔断降级特性进行了全新的改进升级，请使用最新版本以更好地利用熔断降级的能力。

Sentinel 和 Hystrix 的原则是一致的：当检测到调用链路中某个资源出现**不稳定的表现**，例如请求响应时间长或异常比例升高的时候，则**对这个资源的调用进行限制**，让请求快速失败，避免影响到其它的资源而导致**级联故障**。

#### 熔断降级设计理念 ####

在限制的手段上，Sentinel 和 Hystrix 采取了**完全不一样**的方法。

Hystrix 通过 [线程池隔离][Link 2] 的方式，来对依赖（在 Sentinel 的概念中对应 `资源`）进行了隔离。这样做的好处是**资源和资源之间做到了最彻底的隔离**。缺点是除了**增加了线程切换的成本**（过多的线程池导致线程数目过多），还需要预先给各个资源做**线程池大小的分配**，并且对于一些使用了 **ThreadLocal** 的场景来说会有问题（如 Spring 事务）。

> **Hystrix 线程隔离：做到了资源之间的彻底隔离，但增加了成本和副作用！**

**Sentinel 对这个问题采取了两种手段：**

> **新的工具 = 吸收旧工具的优势 + 弥补旧工具的不足！**

*  **通过并发线程数进行限制：** 和资源池隔离的方法不同，Sentinel 通过**限制资源并发线程的数量**，来减少不稳定资源对其它资源的影响。这样不但没有**线程切换**的损耗，也不需要您预先分配**线程池的大小**。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。
 *  **针对慢调用和异常对资源进行降级：** 除了对**并发线程数**进行控制以外，Sentinel 还可以根据**响应时间和异常**等不稳定因素来快速对不稳定的调用进行**熔断**。当依赖的资源出现**响应时间过长**后，所有对该资源的访问都会被**直接拒绝**，直到过了指定的**时间窗口**之后才**重新渐进式地恢复**。

#### 系统自适应保护 ####

Sentinel 同时提供**系统维度**的自适应保护能力。防止**雪崩**，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求进入，可能会导致**系统崩溃**，无法响应。在**集群环境**下，网络负载均衡会把本应这台机器承载的流量**转发**到其它的机器上去。如果这个时候其它的机器也处在一个**边缘状态**的时候，这个增加的流量就会导致这台机器也崩溃，最后导致**整个集群**不可用。

针对这个情况，Sentinel 提供了对应的保护机制，让系统的**入口流量**和**系统的负载**达到一个平衡，保证系统在能力范围之内处理最多的请求。

### 5、Sentinel 是如何工作的 ###

**Sentinel 的主要工作机制如下：**

*  对主流框架提供适配或者显示的 API，来定义需要保护的资源，并提供设施对资源进行实时统计和调用链路分析。
    
    > 第一：告诉需要保护什么，我来提供对其实时分析和统计！
 *  根据预设的规则，结合对资源的实时统计信息，对流量进行控制。同时，Sentinel 提供开放的接口，方便您定义及改变规则。
    
    > 第二：根据您想要达到的效果，确定策略，并制定规则，我来执行！
 *  Sentinel 提供实时的监控系统，方便您快速了解目前系统的状态。
    
    > 第三：我可以提供系统运行的实时状态！

## 三、Sentinel 使用 ##

### 1、基本使用 ###

#### 第一步：引入依赖 ####

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

#### 第二步：编写代码 ####

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.Entry;
    import com.alibaba.csp.sentinel.SphU;
    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 jakarta.annotation.PostConstruct;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zibo
     * @date 2023/2/24 13:43
     */
    @RestController
    @RequestMapping("/sentinel")
    public class HelloController {
        
    
        private static final String RESOURCE_NAME = "hello";
    
        @RequestMapping("/hello")
        public String hello() {
        
            Entry entry = null;
            try {
        
                entry = SphU.entry(RESOURCE_NAME);
                // 被保护的逻辑
                return "hello sentinel";
            } catch (Exception e) {
        
                // 处理被流控的逻辑
                return "被流控了";
            } finally {
        
                if (entry != null) {
        
                    entry.exit();
                }
            }
        }
    
        @PostConstruct
        public void initFlowRules() {
        
            // 流控规则
            List<FlowRule> rules = new ArrayList<>();
            // 流控
            FlowRule flowRule = new FlowRule();
            // 设置资源
            flowRule.setResource(RESOURCE_NAME);
            // 设置规则类型
            flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
            // 设置阈值（每秒一次）
            flowRule.setCount(1);
            // 添加到规则列表
            rules.add(flowRule);
            // 加载规则
            FlowRuleManager.loadRules(rules);
        }
    
    }

#### 第三步：访问测试 ####

![image-20230224140729069][]

#### 缺点 ####

*  业务侵入性很强，需要在 controller 中写入非业务代码；
 *  配置不灵活，若需要添加新的受保护资源，需要手动添加 init 方法来添加流控规则。

### 2、@SentinelResource 注解 ###

> https://github.com/alibaba/Sentinel/wiki/%E6%B3%A8%E8%A7%A3%E6%94%AF%E6%8C%81

> **注意：注解方式埋点不支持 private 方法。**

`@SentinelResource` 用于定义资源，并提供可选的异常处理和 fallback 配置项。 `@SentinelResource` 注解包含以下属性：

*  `value`：**资源名称**，必需项（不能为空）
 *  `entryType`：entry 类型，可选项（默认为 `EntryType.OUT`）
 *  `blockHandler` / `blockHandlerClass`: `blockHandler` 对应处理 `BlockException` 的函数名称，可选项。blockHandler 函数访问范围需要是 `public`，返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 `BlockException`。blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 `blockHandlerClass` 为对应的类的 `Class` 对象，注意对应的函数必需为 static 函数，否则无法解析。
 *  `fallback`/`fallbackClass`：fallback 函数名称，可选项，用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常（除了`exceptionsToIgnore`里面排除掉的异常类型）进行处理。fallback 函数签名和位置要求：
    
     *  返回值类型必须与原函数返回值类型一致；
     *  方法参数列表需要和原函数一致，或者可以额外多一个 `Throwable` 类型的参数用于接收对应的异常。
     *  fallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 `fallbackClass` 为对应的类的 `Class` 对象，注意对应的函数必需为 static 函数，否则无法解析。
 *  `defaultFallback`（since 1.6.0）：默认的 fallback 函数名称，可选项，通常用于通用的 fallback 逻辑（即可以用于很多服务或方法）。默认 fallback 函数可以针对所有类型的异常（除了`exceptionsToIgnore`里面排除掉的异常类型）进行处理。若同时配置了 fallback 和 defaultFallback，则只有 fallback 会生效。defaultFallback 函数签名要求：
    
     *  返回值类型必须与原函数返回值类型一致；
     *  方法参数列表需要为空，或者可以额外多一个 `Throwable` 类型的参数用于接收对应的异常。
     *  defaultFallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 `fallbackClass` 为对应的类的 `Class` 对象，注意对应的函数必需为 static 函数，否则无法解析。
 *  `exceptionsToIgnore`（since 1.6.0）：用于指定哪些异常被排除掉，不会计入异常统计中，也不会进入 fallback 逻辑中，而是会原样抛出。

1.8.0 版本开始，`defaultFallback` 支持在类级别进行配置。

> 注：1.6.0 之前的版本 fallback 函数只针对降级异常（`DegradeException`）进行处理，**不能针对业务异常进行处理**。

特别地，若 blockHandler 和 fallback 都进行了配置，则被限流降级而抛出 `BlockException` 时只会进入 `blockHandler` 处理逻辑。若未配置 `blockHandler`、`fallback` 和 `defaultFallback`，则被限流降级时会将 `BlockException` **直接抛出**（若方法本身未定义 throws BlockException 则会被 JVM 包装一层 `UndeclaredThrowableException`）。

### 3、注解开发 ###

#### 第一步：引入依赖 ####

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-annotation-aspectj</artifactId>
        <version>1.8.6</version>
    </dependency>

#### 第二步：添加 bean ####

@Bean
    public SentinelResourceAspect sentinelResourceAspect() {
        
        return new SentinelResourceAspect();
    }

#### 第三步：编写代码 ####

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.Entry;
    import com.alibaba.csp.sentinel.SphU;
    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 jakarta.annotation.PostConstruct;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zibo
     * @date 2023/2/24 13:43
     */
    @RestController
    @RequestMapping("/sentinel")
    public class HelloController {
        
    
        // 原函数
        // blockHandler：指定限流处理方法！
        // fallback：指定异常熔断后的降级处理方法！
        @SentinelResource(value = "hello", blockHandler = "helloFallback", fallback = "exceptionHandler")
        @RequestMapping("/hello")
        public String hello() {
        
            return "Hello Sentinel";
        }
    
        // Fallback 函数，函数签名与原函数一致或加一个 Throwable 类型的参数.
        public String helloFallback() {
        
            return "被限流了";
        }
    
        // Block 异常处理函数，参数最后多一个 BlockException，其余与原函数一致.
        public String exceptionHandler(BlockException ex) {
        
            ex.printStackTrace();
            return "异常处理！";
        }
    
        @PostConstruct
        public void initFlowRules() {
        
            // 流控规则
            List<FlowRule> rules = new ArrayList<>();
            // 流控
            FlowRule flowRule = new FlowRule();
            // 设置资源
            flowRule.setResource("hello");
            // 设置规则类型
            flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
            // 设置阈值（每秒一次）
            flowRule.setCount(1);
            // 添加到规则列表
            rules.add(flowRule);
            // 加载规则
            FlowRuleManager.loadRules(rules);
        }
    
    }

#### 第四步：访问测试 ####

> 测试结果符合预期，如非注解开发结果一致！限流时打印的异常如下

com.alibaba.csp.sentinel.slots.block.flow.FlowException

## 四、降级规则初体验 ##

> 关注重点：每种规则的使用场景。

### 1、熔断降级规则 (DegradeRule) ###

#### 熔断策略 ####

Sentinel 提供以下几种**熔断策略**：

*  **慢调用比例** (`SLOW_REQUEST_RATIO`)：选择以慢调用比例作为**阈值**，需要设置允许的慢调用 RT（即**最大的响应时间**），请求的响应时间大于该值则统计为**慢调用**。当**单位统计时长**（`statIntervalMs`）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。
    
    > **一句话：慢调用比例就是调用时间较长的调用次数所占总调用次数的比例！**
    > 
    > 1.调用：一个请求发送到服务器，服务器给与响应，一个响应就是一个调用。  
    > 2.RT：响应时间，指系统对请求作出响应的时间。  
    > 3.**慢调用：当调用的时间（响应的实际时间）>设置的RT的时，这个调用叫做慢调用。**  
    > 4.**慢调用比例：在所以调用中，慢调用占有实际的比例，= 慢调用次数 / 调用次数**  
    > 5.比例阈值：自己设定的 ， 慢调用次数 / 调用次数=比例阈值
    > 
    > 统计时长：时间的判断依据  
    > 最小请求数：设置的调用最小请求数
 *  **异常比例** (`ERROR_RATIO`)：当单位统计时长（`statIntervalMs`）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入**探测恢复状态**（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 `[0.0, 1.0]`，代表 0% - 100%。
    
    > 探测恢复状态：尝试恢复到熔断前的正常状态的状态。
 *  **异常数** (`ERROR_COUNT`)：当单位统计时长内的**异常数目**超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入**探测恢复状态**（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

注意异常降级**仅针对业务异常**，对 Sentinel 限流降级本身的异常（`BlockException`）不生效。为了统计异常比例或异常数，需要通过 `Tracer.trace(ex)` 记录业务异常。

示例代码：

Entry entry = null;
    try {
        
      entry = SphU.entry(key, EntryType.IN, key);
    
      // Write your biz code here.
      // <<BIZ CODE>>
    } catch (Throwable t) {
        
      if (!BlockException.isBlockException(t)) {
        
        Tracer.trace(t);
      }
    } finally {
        
      if (entry != null) {
        
        entry.exit();
      }
    }

开源整合模块，如 Sentinel Dubbo Adapter, Sentinel Web Servlet Filter 或 `@SentinelResource` 注解会**自动统计业务异常**，无需手动调用。

#### 属性说明 ####

<table> 
 <thead> 
  <tr> 
   <th>更多操作Field</th> 
   <th>说明</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resource</td> 
   <td>资源名，即规则的<strong>作用对象</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>grade</td> 
   <td>熔断策略，支持<strong>慢调用比例/异常比例/异常数策略</strong></td> 
   <td>慢调用比例</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td><strong>慢调用比例模式</strong>下为慢调用临界 RT（超出该值计为慢调用）；<strong>异常比例/异常数模式</strong>下为对应的阈值</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>timeWindow</td> 
   <td>熔断<strong>时长</strong>，单位为 s</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>minRequestAmount</td> 
   <td>熔断触发的<strong>最小请求数</strong>，请求数小于该值时即使异常比率超出阈值也不会熔断（1.7.0 引入）</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>statIntervalMs</td> 
   <td>统计时长（单位为 ms），如 60*1000 代表分钟级（1.8.0 引入）</td> 
   <td>1000 ms</td> 
  </tr> 
  <tr> 
   <td>slowRatioThreshold</td> 
   <td><strong>慢调用比例阈值</strong>，仅慢调用比例模式有效（1.8.0 引入）</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

**同一个资源可以同时有多个降级规则。**

#### 熔断器事件监听 ####

Sentinel 支持注册自定义的事件监听器监听熔断器状态变换事件（state change event）。示例：

EventObserverRegistry.getInstance().addStateChangeObserver("logging",
        (prevState, newState, rule, snapshotValue) -> {
        
            if (newState == State.OPEN) {
        
                // 变换至 OPEN state 时会携带触发时的值
                System.err.println(String.format("%s -> OPEN at %d, snapshotValue=%.2f", prevState.name(),
                    TimeUtil.currentTimeMillis(), snapshotValue));
            } else {
        
                System.err.println(String.format("%s -> %s at %d", prevState.name(), newState.name(),
                    TimeUtil.currentTimeMillis()));
            }
        });

慢调用比例熔断示例：[SlowRatioCircuitBreakerDemo][]

### 2、初体验\* ###

> 问题待解决：上来就直接熔断了，不按照我的配置走！

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.alibaba.csp.sentinel.slots.block.RuleConstant;
    import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
    import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
    import jakarta.annotation.PostConstruct;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zibo
     * @date 2023/2/24 13:43
     */
    @RestController
    @RequestMapping("/sentinel")
    public class HelloController {
        
    
        // 原函数
        @SentinelResource(value = "hello", fallback = "fallbackExceptionHandler")
        @RequestMapping("/hello/{nickname}")
        public String hello(@PathVariable String nickname) {
        
            int a = 1 / 0;
            return "Hello Sentinel" + nickname;
        }
    
        // Fallback 函数，函数签名与原函数一致或加一个 Throwable 类型的参数.
        public String fallbackExceptionHandler(String nickname, Throwable t) {
        
            t.printStackTrace();
            return "服务被熔断了，不要调用！" + nickname;
        }
    
        /**
         * 降级规则
         */
        @PostConstruct
        public void initDegradeRules() {
        
            // 降级规则
            List<DegradeRule> rules = new ArrayList<>();
            // 降级
            DegradeRule degradeRule = new DegradeRule();
            // 设置资源
            degradeRule.setResource("hello");
            // 设置规则类型
            degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
            // 设置阈值（异常数）
            degradeRule.setCount(3);
            // 触发熔断的最小请求数
            degradeRule.setMinRequestAmount(3);
            // 单位统计时长：1分钟
            degradeRule.setStatIntervalMs(60 * 1000);
            // 上述条件综合说明：1分钟内，如果至少有3个请求，且异常数为3，则触发熔断降级
    
            // 设置时间窗口
            // 熔断后多少秒后进入半熔断状态（探测恢复状态）
            // 比如：熔断10秒后，进入半熔断状态，此时如果请求成功，则恢复正常，如果失败，则继续熔断
            degradeRule.setTimeWindow(10);
            // 添加到规则列表
            rules.add(degradeRule);
            // 加载规则
            DegradeRuleManager.loadRules(rules);
        }
    
    }

## 五、控制台部署 ##

> 官方文档：https://github.com/alibaba/Sentinel/wiki/%E6%8E%A7%E5%88%B6%E5%8F%B0

### 1、启动控制台 ###

#### 第一步：获取 Sentinel 控制台 ####

您可以从 [release 页面][release] 下载最新版本的控制台 jar 包。

您也可以从最新版本的源码自行构建 Sentinel 控制台：

*  下载 [控制台][Link 3] 工程
 *  使用以下命令将代码打包成一个 fat jar: `mvn clean package`

#### 第二步：启动 ####

> **注意**：启动 Sentinel 控制台需要 JDK 版本为 1.8 及以上版本。

使用如下命令启动控制台：

java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar

**其中 `-Dserver.port=8080` 用于指定 Sentinel 控制台端口为 `8080`。**

从 Sentinel 1.6.0 起，Sentinel 控制台引入基本的**登录**功能，默认用户名和密码都是 `sentinel`。可以参考 [鉴权模块文档][Link 4] 配置用户名和密码。

> 注：若您的应用为 Spring Boot 或 Spring Cloud 应用，您可以通过 Spring 配置文件来指定配置，详情请参考 [Spring Cloud Alibaba Sentinel 文档][Spring Cloud Alibaba Sentinel]。

# 启动控制台命令
    java -Dserver.port=8090 -jar sentinel-dashboard-1.8.5.jar

**用户可以通过如下参数进行配置：**

*  \-Dsentinel.dashboard.auth.username=sentinel 用于指定控制台的登录用户名为 sentinel；
 *  \-Dsentinel.dashboard.auth.password=123456 用于指定控制台的登录密码为 123456；
 *  **如果省略这两个参数，默认用户和密码均为 `sentinel`；**
 *  \-Dserver.servlet.session.timeout=7200 用于指定 Spring Boot 服务端 session 的过期时间，如 7200 表示 7200 秒；60m 表示 60 分钟，默认为 30 分钟；

![image-20230225150830345][]

访问`http://localhost:8090/`即可！

### 2、客户端接入控制台 ###

#### 第一步：引入依赖 ####

> 如果整合 spring cloud alibaba ，则使用其对应的版本！

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-transport-simple-http</artifactId>
        <version>1.8.5</version>
    </dependency>

#### 第二步：配置启动参数 ####

启动时加入 JVM 参数 `-Dcsp.sentinel.dashboard.server=consoleIp:port` 指定控制台地址和端口。若启动多个应用，则需要通过 `-Dcsp.sentinel.api.port=xxxx` 指定客户端监控 API 的端口（默认是 8719）。

从 1.6.3 版本开始，控制台支持网关流控规则管理。您需要在接入端添加 `-Dcsp.sentinel.app.type=1` 启动参数以将您的服务标记为 API Gateway，在接入控制台时您的服务会自动注册为网关类型，然后您即可在控制台配置网关规则和 API 分组。

除了修改 JVM 参数，也可以通过配置文件取得同样的效果。更详细的信息可以参考 [启动配置项][Link 5]。

![image-20230225152251069][]

#### 第三步：重启，并访问资源 ####

> 我这里刷新了好几次！

![image-20230225152320349][]

#### 第四步：查看控制台 ####

![image-20230225152356497][]

## 六、整合 Spring Cloud Alibaba ##

### 1、引入依赖 ###

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
    </dependency>

### 2、修改 yaml 配置 ###

spring:
      application:
        name: sentinel-demo
      cloud:
        sentinel:
          transport:
            dashboard: localhost:8090

### 3、启动 sentinel 和 项目 ###

> 访问接口

![image-20230226121459356][]

## 七、流控规则 ##

### 1、概述 ###

**流量控制**（flow control），其原理是监控应用流量的 **QPS** 或**并发线程数**等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。 ==== FlowRule RT(响应时间) 1/0.2s =5

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XQORsZq1-1677563371863)(https://gudu2019.oss-cn-beijing.aliyuncs.com/mdimg/6-2%E3%80%81Sentinel%E6%8E%A7%E5%88%B6%E5%8F%B0%E8%A7%84%E5%88%99%E9%85%8D%E7%BD%AE%E8%AF%A6%E8%A7%A3.png)\]

![VSD34TSDG][]

同一个资源可以创建**多条限流规则**。FlowSlot 会对该资源的**所有限流规则依次遍历**，直到有规则触发限流或者所有规则遍历完毕。一条限流规则主要由下面几个因素组成，我们可以组合这些元素来实现不同的限流效果。

> 参考文档：https://github.com/alibaba/Sentinel/wiki/%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6

<table> 
 <thead> 
  <tr> 
   <th>Field</th> 
   <th>说明</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resource</td> 
   <td>资源名，资源名是限流规则的作用对象</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>限流阈值</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>grade</td> 
   <td>限流阈值类型，QPS 模式（1）或并发线程数模式（0）</td> 
   <td>QPS 模式</td> 
  </tr> 
  <tr> 
   <td>limitApp</td> 
   <td>流控针对的调用来源</td> 
   <td>default，代表不区分调用来源</td> 
  </tr> 
  <tr> 
   <td>strategy</td> 
   <td>调用关系限流策略：直接、链路、关联</td> 
   <td>根据资源本身（直接）</td> 
  </tr> 
  <tr> 
   <td>controlBehavior</td> 
   <td>流控效果（直接拒绝/WarmUp/匀速+排队等待），不支持按调用关系限流</td> 
   <td>直接拒绝</td> 
  </tr> 
  <tr> 
   <td>clusterMode</td> 
   <td>是否集群限流</td> 
   <td>否</td> 
  </tr> 
 </tbody> 
</table>

### 2、QPS ###

> QPS（Query Per Second）：每秒请求数，就是说服务器在一秒的时间内处理了多少个请求。

#### 第一步：增加一个接口 ####

package com.zibo.sentinel.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zibo
     * @date 2023/2/26 12:29
     */
    @RestController
    public class HiController {
        
    
        @RequestMapping("/hi")
        public String hi() {
        
            return "hi";
        }
    
    }

#### 第二步：配置流控规则 ####

![image-20230226123346809][]

#### 第三步：访问测试 ####

![image-20230226123433904][]

#### 第四步：配置异常处理方法 ####

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.alibaba.csp.sentinel.slots.block.BlockException;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zibo
     * @date 2023/2/26 12:29
     */
    @RestController
    public class HiController {
        
    
        @RequestMapping("/hi")
        @SentinelResource(value = "hi", blockHandler = "blockExceptionHandler")
        public String hi() {
        
            return "hi";
        }
        
        public String blockExceptionHandler(BlockException e) {
        
            e.printStackTrace();
            return "限流了！";
        }
    
    }

#### 第五步：重启，并访问测试 ####

> 需要重新设置流控规则！因为存在内存中，项目重启后就失效了！后续可以将规则持久化！

![image-20230226124903545][]

### 2、并发线程数 ###

#### 概述 ####

并发数控制用于保护业务**线程池**不被慢调用耗尽。

Sentinel 并发控制**不负责创建和管理**线程池，而是**简单统计**当前请求上下文的线程数目（正在执行的调用数目），如果超出阈值，新的请求会被**立即拒绝**，效果类似于**信号量隔离**。并发数控制通常在**调用端**进行配置。

#### 第一步：修改代码，重启项目 ####

package com.zibo.sentinel.controller;
    
    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.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.PostConstruct;
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author zibo
     * @date 2023/2/26 12:29
     */
    @RestController
    public class HiController {
        
    
        @RequestMapping("/hi")
        @SentinelResource(value = "hi", blockHandler = "blockExceptionHandler")
        public String hi() {
        
            return "hi";
        }
    
        public String blockExceptionHandler(BlockException e) {
        
            e.printStackTrace();
            return "限流了！";
        }
    
        @RequestMapping("/hello")
        @SentinelResource(value = "hello", blockHandler = "blockExceptionHandler")
        public String hello() {
        
            // 睡眠 5 秒，模拟业务处理时间
            try {
        
                Thread.sleep(5000);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            }
            return "hello";
        }
    
    }

#### 第二步：设置流控规则 ####

![image-20230226125804648][]

#### 第三步：访问测试 ####

> 使用**两个浏览器**（或一个浏览器的正常模式 + 一个浏览器的无痕模式）前后迅速访问该地址！

![image-20230226130112480][]

## 八、统一异常处理 BlockException ##

### 1、定义统一返回类 ###

> 简化版！

package com.zibo.sentinel.domain;
    
    import lombok.Data;
    
    @Data
    public class R {
        
    
        /**
         * 返回码
         */
        private Integer code;
    
        /**
         * 返回消息
         */
        private String msg;
    
        /**
         * 私有化构造方法
         */
        private R() {
        
        }
    
        /**
         * 失败
         *
         * @param msg 返回消息
         * @return 统一返回结果类
         */
        public static R error(Integer code, String msg) {
        
            R r = new R();
            r.setCode(code);
            r.setMsg(msg);
            return r;
        }
    }

### 2、定义统一异常处理类 ###

package com.zibo.sentinel.common;
    
    import com.alibaba.csp.sentinel.adapter.spring.webmvc.callback.BlockExceptionHandler;
    import com.alibaba.csp.sentinel.slots.block.BlockException;
    import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
    import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
    import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
    import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
    import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import com.zibo.sentinel.domain.R;
    import org.springframework.http.MediaType;
    import org.springframework.stereotype.Component;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * @author zibo
     * @date 2023/2/26 13:13
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    @Component
    public class MyBlockExceptionHandler implements BlockExceptionHandler {
        
        @Override
        public void handle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws Exception {
        
            R r = null;
            if (e instanceof FlowException) {
        
                r = R.error(100,"接口限流了");
            } else if (e instanceof DegradeException) {
        
                r = R.error(101,"接口降级了");
            } else if (e instanceof ParamFlowException) {
        
                r = R.error(102,"热点参数限流了");
            } else if (e instanceof SystemBlockException) {
        
                r = R.error(103,"触发系统保护规则了");
            } else if(e instanceof AuthorityException) {
        
                r = R.error(104,"授权规则不通过");
            }
            // 返回 json
            httpServletResponse.setStatus(500);
            httpServletResponse.setCharacterEncoding("UTF-8");
            httpServletResponse.setContentType(MediaType.APPLICATION_JSON_VALUE);
            new ObjectMapper().writeValue(httpServletResponse.getWriter(), r);
        }
    }

### 3、修改接口代码 ###

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.zibo.sentinel.common.MyBlockExceptionHandler;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zibo
     * @date 2023/2/26 12:29
     */
    @RestController
    public class HiController {
        
    
        @RequestMapping("/hello")
        public String hello() {
        
            return "hello";
        }
    
    }

### 4、设置流控，访问测试 ###

![image-20230226133251579][]

## 九、流控模式 ##

### 1、概述 ###

基于**调用关系**的流量控制。调用关系包括调用方、被调用方；一个方法可能会调用其它方法，形成一个调用链路的层次关系。

*  **直接：资源调用达到设置的阈值后直接被流控抛出异常**。
 *  **关联：当两个资源之间具有资源争抢或者依赖关系**的时候，这两个资源便具有了关联。据此关系进行限流。
 *  **链路：根据调用链路入口限流。 资源之间的调用链路，这些资源通过调用关系**，相互之间构成一棵**调用树**。

### 2、关联 ###

#### 说明 ####

我们创建两个接口，一个是读取操作，一个是写入操作，用以模拟当需要写入操作的时候对读取进行过限流。

#### 第一步：创建接口 ####

@RequestMapping("/read")
    public String read() {
        
        return "read";
    }
    
    @RequestMapping("/write")
    public String write() {
        
        return "write";
    }

#### 第二步：运行访问，设置限流策略 ####

![image-20230226155431123][]

#### 第三步：访问测试 ####

![image-20230226155359619][]

### 3、链路 ###

#### 第一步：编写代码 ####

**服务**

package com.zibo.sentinel.service;
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import org.springframework.stereotype.Service;
    
    /**
     * @author zibo
     * @date 2023/2/26 16:12
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    @Service
    public class TestService {
        
    
        @SentinelResource("myService")
        public String myService() {
        
            return "test service";
        }
    
    }

**接口**

package com.zibo.sentinel.controller;
    
    import com.zibo.sentinel.service.TestService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class HiController {
        
    
        @Autowired
        private TestService testService;
    
        @RequestMapping("/test1")
        public String read() {
        
            return "test1 " + testService.myService();
        }
    
        @RequestMapping("/test2")
        public String write() {
        
            return "test2 " + testService.myService();
        }
    
    }

#### 第二步：修改 yaml 配置 ####

spring:
      application:
        name: sentinel-demo
      cloud:
        sentinel:
          transport:
            dashboard: localhost:8090
          web-context-unify: false # add this config

#### 第三步：运行访问，设置限流策略 ####

![image-20230226161734770][]

#### 第四步：访问测试 ####

![image-20230226161922007][]

#### 备注 ####

使用了 `@SentinelResource` 注解就不会出发统一异常处理了！

## 十、流控效果 ##

### 1、概述 ###

#### 快速失败 ####

RuleConstant.CONTROL\_BEHAVIOR\_DEFAULT）方式是**默认的**流量控制方式，当 QPS 超过任意规则的阈值后，新的请求就会**被立即拒绝**，拒绝方式为抛出FlowException。这种方式适用于**对系统处理能力确切已知**的情况下，比如通过压测确定了系统的**准确水位**时。

#### Warm Up（激增流量/预热流控） ####

Warm Up（RuleConstant.CONTROL\_BEHAVIOR\_WARM\_UP）方式，即预热/冷启动方式。当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。

冷加载因子: codeFactor 默认是 3，即请求 QPS 从 threshold / 3 开始，**经预热时长逐渐升至设定的 QPS 阈值。**

通常冷启动的过程系统允许通过的 QPS 曲线如下图所示

![VSD3234f4TSDG][]

#### 排队等待（脉冲流量） ####

匀速排队（`RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER`）方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是**漏桶算法**。

该方式的作用如下图所示：

![fs43gsdf34tr][]

这种方式主要用于处理**间隔性突发**的流量，例如消息队列。想象一下这样的场景，在某一秒有大量的请求到来，而接下来的几秒则处于空闲状态，我们希望系统能够在接下来的空闲期间逐渐处理这些请求，而不是在第一秒直接拒绝多余的请求。

> 注意：匀速排队模式暂时不支持 QPS > 1000 的场景。

![image-20230227130809222][]

### 2、预热流控 ###

> 前一小段时间限流，后逐渐放开到阈值。

#### 第一步：创建接口 ####

package com.zibo.sentinel.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zibo
     * @date 2023/2/27 12:47
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    @RestController
    public class TestController {
        
    
        @RequestMapping("/test")
        public String test() {
        
            return "test";
        }
    
    }

#### 第二步：运行访问，设置限流策略 ####

![image-20230227125344715][]

#### 第三步：访问测试 ####

![image-20230227125821888][]

> 控制台监控效果

![image-20230227130108598][]

### 3、排队等待 ###

#### 第一步：修改流控规则 ####

![image-20230227131055972][]

#### 第二步：有规律刷新网页 ####

> 快速刷新 5 次，间隔一段时间，再快速刷新 5 次；

![image-20230227131325358][]

#### 第三步：设置排队等待 ####

![image-20230227131403256][]

#### 第四步：再次有规则刷新网页 ####

![image-20230227131816377][]

> 监控

![image-20230227131928297][]

**备注：这里使用手动快速刷新方式测试，使用 JMeter 测试更精准！**

## 十一、整合 OpenFeign 降级 ##

#### 参考文章 ####

**分布式系统Sentinel整合Open-Feign限流**

https://blog.csdn.net/weixin\_46146718/article/details/119926035

**sentinel和openfeign整合**

https://blog.csdn.net/qq\_36575363/article/details/122794262

## 十二、热点规则：热点参数限流 ##

### 1、概述 ###

热点：热点即经常访问的数据。

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

![2023022753653463][]

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

![2023022753632463][]

注意：

1.  **热点规则需要使用 `@SentinelResource("resourceName")` 注解，否则不生效。**
2.  参数必须是 7 种**基本数据类型**才会生效。

**单机阈值： 针对所有参数的值进行设置的一个**公共的阈值\*\*

1.  假设当前参数**大部分的值都是热点流量**，单机阈值就是针对**热点流量**进行设置，额外针对普通流量进行参数值流控
2.  假设当前参数**大部分的值都是普通流量**，单机阈值就是针对**普通流量**进行设置，额外针对热点流量进行参数值流控

### 2、演示 ###

#### 第一步：创建接口 ####

package com.zibo.sentinel.controller;
    
    import com.alibaba.csp.sentinel.annotation.SentinelResource;
    import com.alibaba.csp.sentinel.slots.block.BlockException;
    import org.springframework.web.bind.annotation.PathVariable;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author zibo
     * @date 2023/2/27 13:44
     * @slogan 真正的大师永远怀着一颗学徒的心。——易大师
     */
    @RestController
    public class HotController {
        
    
        @RequestMapping("/hot/{name}")
        @SentinelResource(value = "hot", blockHandler = "hotBlockHandler")
        public String hot(@PathVariable String name) {
        
            return "正常访问热点：" + name;
        }
    
        public String hotBlockHandler(@PathVariable String name, BlockException e) {
        
            e.printStackTrace();
            return "热点流控：" + name;
        }
    
    }

#### 第二步：新增热点规则 ####

![image-20230227135407016][]

#### 第三步：编辑热点规则高级选项 ####

![image-20230227135455045][]

#### 第四步：访问测试 ####

![image-20230227135621080][]

## 十三、系统规则：系统保护规则 ##

### １、概述 ###

Sentinel **系统自适应限流**从整体维度对应用入口流量进行控制，结合应用的 **Load、CPU 使用率、总体平均 RT、入口 QPS 和并发线程数**等几个维度的监控指标，通过**自适应的流控策略**，让系统的**入口流量**和**系统的负载**达到一个平衡，让系统尽可能跑在最大吞吐量的同时保证系统**整体的稳定性**。

*  \*\*Load 自适应（仅对 Linux/Unixlike 机器生效）：\*\*系统的 load1 作为启发指标，进行自适应系统保护。当系统 load1 超过设定的启发值，且系统当前的并发线程数超过估算的系统容量时才会触发系统保护（BBR 阶段）。系统容量由系统的 maxQps \* minRt 估算得出。设定参考值一般是 CPU cores \* 2.5。
    
    > 参考文章：https://www.cnblogs.com/gentlemanhai/p/8484839.html
 *  \*\*CPU usage（1.5.0+ 版本）：\*\*当系统 **CPU 使用率**超过阈值即触发系统保护（取值范围 0.01.0），比较灵敏。
 *  **平均 RT：当单台机器上所有入口流量的平均 RT** 达到阈值即触发系统保护，单位是毫秒。
 *  **并发线程数：当单台机器上所有入口流量的并发线程数**达到阈值即触发系统保护。
 *  \*\*入口 QPS：\*\*当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。

### 2、系统保护配置示例 ###

> 演示略！

![image-20230227140705939][]

## 十四、规则持久化 ##

### 1、持久化配置的必要 ###

规则默认保存在内存中，服务重启需要重新配置，生产环境下无法接受，因此要进行持久化配置！

### 2、三种模式 ###

#### 原始模式： ####

如果不做任何修改，Dashboard 的推送规则方式是通过 API 将规则推送至客户端并直接更新到内存中：

![20230424632463][]

这种做法的好处是简单，无依赖；坏处是应用重启，规则就会消失，仅用于简单测试，不能用于生产环境。

#### 拉模式 ####

pull 模式的数据源（如本地文件、RDBMS 等）一般是可写入的。使用时需要在客户端注册数据源：将对应的读数据源注册至对应的 RuleManager，将写数据源注册至 transport 的WritableDataSourceRegistry 中。从文件中拉过来，这种模式需要阅读一定的源码，在源码的基础上进行扩展。

#### 推模式（生产环境常用） ####

\*\*生产环境下一般更常用的是 push 模式的数据源。\*\*对于 push 模式的数据源,如远程配置中心（ZooKeeper, Nacos, Apollo等等），推送的操作不应由 Sentinel 客户端进行，而应该经控制台统一进行管理，直接进行推送，数据源仅负责获取配置中心推送的配置并更新到本地。因此推送规则正确做法应该是 配置中心控制/Sentinel 控制台 → 配置中心 →Sentinel 数据源 → Sentinel，而不是经 Sentinel 数据源推送至配置中心。

### 3、基于 Nacos 配置中心控制台实现推送\* ###

> 可能由于我使用的版本比较新，这么配置无法获取到 Nacos 里面的配置。
> 
> 参考文章：https://blog.csdn.net/MrHaoo/article/details/124169653

#### 第一步：引入依赖 ####

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
    </dependency>

#### 第二步：启动 Nacos ，并创建配置文件 ####

![image-20230227143259483][]

#### 第三步：修改 yaml 配置文件 ####

spring:
      application:
        name: sentinel-demo
      cloud:
        sentinel:
          transport:
            dashboard: localhost:8090
          web-context-unify: false
          datasource:
            flow-rule:
              nacos:
                server-addr: localhost:8848
                username: nacos
                password: nacos
                dataId: sentinel-demo-flow-rule
                groupId: DEFAULT_GROUP
                data-type: json
                rule-type: flow

## 十五、Gateway 整合 Sentinel ##

Spring Cloud Gateway 整合 sentinel 实现流控熔断

https://blog.csdn.net/a745233700/article/details/122917160

spring cloud alibaba-gateway使用以及整合sentinel

https://blog.csdn.net/weixin\_38612401/article/details/126174715

[Link 1]: https://github.com/alibaba/Sentinel/wiki/%E4%B8%BB%E6%B5%81%E6%A1%86%E6%9E%B6%E7%9A%84%E9%80%82%E9%85%8D
[img]: https://img-blog.csdnimg.cn/img_convert/6e6b40c30a7d11e39cf012f2aa69f289.png
[img 1]: https://img-blog.csdnimg.cn/img_convert/907f47158ed1a66e8b66c58029f45b5f.png
[C_]: https://github.com/alibaba/sentinel-cpp
[Envoy]: https://github.com/alibaba/Sentinel/tree/master/sentinel-cluster/sentinel-cluster-server-envoy-rls
[Sentinel Go]: https://github.com/alibaba/sentinel-golang
[img 2]: https://img-blog.csdnimg.cn/img_convert/9a30d97d62923c15fd666f9894739d07.jpeg
[img 3]: https://img-blog.csdnimg.cn/img_convert/1a14ae5fee4736212321634ab9149f9f.png
[Link 2]: https://github.com/Netflix/Hystrix/wiki/How-it-Works#benefits-of-thread-pools
[image-20230224140729069]: https://img-blog.csdnimg.cn/img_convert/603fec54f66d692bc97eee763940aa91.png
[SlowRatioCircuitBreakerDemo]: https://github.com/alibaba/Sentinel/blob/master/sentinel-demo/sentinel-demo-basic/src/main/java/com/alibaba/csp/sentinel/demo/degrade/SlowRatioCircuitBreakerDemo.java
[release]: https://github.com/alibaba/Sentinel/releases
[Link 3]: https://github.com/alibaba/Sentinel/tree/master/sentinel-dashboard
[Link 4]: https://github.com/alibaba/Sentinel/wiki/%E6%8E%A7%E5%88%B6%E5%8F%B0#%E9%89%B4%E6%9D%83
[Spring Cloud Alibaba Sentinel]: https://github.com/spring-cloud-incubator/spring-cloud-alibaba/wiki/Sentinel
[image-20230225150830345]: https://img-blog.csdnimg.cn/img_convert/c658917921a0c82b79551a25f20ea847.png
[Link 5]: https://github.com/alibaba/Sentinel/wiki/%E5%90%AF%E5%8A%A8%E9%85%8D%E7%BD%AE%E9%A1%B9
[image-20230225152251069]: https://img-blog.csdnimg.cn/img_convert/d95cc9519ff2e03f5ab6a55aa5d5f631.png
[image-20230225152320349]: https://img-blog.csdnimg.cn/img_convert/6305561e09c0455c80dadaa1e64f412a.png
[image-20230225152356497]: https://img-blog.csdnimg.cn/img_convert/53f9f1b1251f856e4fb8981fea03869f.png
[image-20230226121459356]: https://img-blog.csdnimg.cn/img_convert/38f49f38a072f6688faba25b27706403.png
[VSD34TSDG]: https://img-blog.csdnimg.cn/img_convert/25738a01b09ad94b24712d8fb45267ad.png
[image-20230226123346809]: https://img-blog.csdnimg.cn/img_convert/03288511736600417d2e59e9bd055c7e.png
[image-20230226123433904]: https://img-blog.csdnimg.cn/img_convert/29ae60260934e4dac7bd2c513fe1499f.png
[image-20230226124903545]: https://img-blog.csdnimg.cn/img_convert/dae1603da385fdc71a16c5231cc64c9d.png
[image-20230226125804648]: https://img-blog.csdnimg.cn/img_convert/d7aabe154b0c38ed6b51f685832630c2.png
[image-20230226130112480]: https://img-blog.csdnimg.cn/img_convert/76d47415adc7246e920a83c01e5d3206.png
[image-20230226133251579]: https://img-blog.csdnimg.cn/img_convert/056b558879991fcd35512a5081218ec6.png
[image-20230226155431123]: https://img-blog.csdnimg.cn/img_convert/291663ff1d29f9122af44a09d70a25ff.png
[image-20230226155359619]: https://img-blog.csdnimg.cn/img_convert/60b1eaa74672e4614e6973b0780d443f.png
[image-20230226161734770]: https://img-blog.csdnimg.cn/img_convert/b771a84762e880aae8da6f93faf5e378.png
[image-20230226161922007]: https://img-blog.csdnimg.cn/img_convert/8defd80f9619232f0156734d1c786aec.png
[VSD3234f4TSDG]: https://img-blog.csdnimg.cn/img_convert/75efcbb1000a3bdd348b3ad64affc729.png
[fs43gsdf34tr]: https://img-blog.csdnimg.cn/img_convert/73ff5b4f867e7e7fc91697a31282d67e.png
[image-20230227130809222]: https://img-blog.csdnimg.cn/img_convert/4161bad55c675f6637a70cf9707d6195.png
[image-20230227125344715]: https://img-blog.csdnimg.cn/img_convert/a391688fd8487380e1aa135ee2306e25.png
[image-20230227125821888]: https://img-blog.csdnimg.cn/img_convert/e14e6489f33258da7202e6c3e3558e45.png
[image-20230227130108598]: https://img-blog.csdnimg.cn/img_convert/c266d5c4f9241e5c5b88296a78b22f0a.png
[image-20230227131055972]: https://img-blog.csdnimg.cn/img_convert/34179f80f1778f3f447ce66f4dd89e0d.png
[image-20230227131325358]: https://img-blog.csdnimg.cn/img_convert/d8ebe8019574d9011a9b212f6094c892.png
[image-20230227131403256]: https://img-blog.csdnimg.cn/img_convert/dc31c5afcfd83ad87593b4dceb1f1f5d.png
[image-20230227131816377]: https://img-blog.csdnimg.cn/img_convert/bf3e1a846dbd575d5c0c2c8fd0f73093.png
[image-20230227131928297]: https://img-blog.csdnimg.cn/img_convert/652647e9a22667eaa49ad187e968eca1.png
[2023022753653463]: https://img-blog.csdnimg.cn/img_convert/70c5c0a0e2caae0f77760b5a4ef83041.png
[2023022753632463]: https://img-blog.csdnimg.cn/img_convert/5bd14e03e4fa2124eaf240e76557e336.png
[image-20230227135407016]: https://img-blog.csdnimg.cn/img_convert/1b260022ad699e09efd2c6a4323bb1ba.png
[image-20230227135455045]: https://img-blog.csdnimg.cn/img_convert/093108e2ad9e80ab204add3226c7ef46.png
[image-20230227135621080]: https://img-blog.csdnimg.cn/img_convert/ef2c4fa92efd500c4e5077d8c6f77e32.png
[image-20230227140705939]: https://img-blog.csdnimg.cn/img_convert/1e78bf6be664432fc8cbdb05e6e7db1c.png
[20230424632463]: https://img-blog.csdnimg.cn/img_convert/1ddc3c84713f8e7570e94b15dd6d35a9.png
[image-20230227143259483]: https://img-blog.csdnimg.cn/img_convert/cbba0e8d3823a5f4e3bf712d31463c1f.png