1、JMeter压力测试

1.1、安装启动

JMeter 依赖于JDK，所以必须确保当前计算机上已经安装了 JDK，并且配置了环境变量。

Apache Jmeter官网下载，地址：http://jmeter.apache.org/download_jmeter.cgi

解压缩即可使用，目录结构如下：

进入 bin 目录，执行命令：sh jmeter，即可启动 JMeter：

1.2 修改中文

默认 JMeter 的语言是英文，需要设置：

效果：

上面的配置只能保证本次运行是中文，如果要永久中文，需要修改 JMeter 的配置文件。

打开 JMeter 文件夹，在 bin 目录中找到 jmeter.properties，添加下面配置：

language=zh_CN

1.3、基本使用

在测试计划上点鼠标右键，选择「添加 > 线程（用户） > 线程组」：

在新增的线程组中，填写线程信息：

在线程组这里点鼠标右键，添加 http 请求：

编写取样器内容：

添加监听报告：

汇总报告结果：

添加监听结果树：

查看结果树：

2、初识Sentinel

2.1、雪崩问题及解决方案

微服务调用链路中的某个服务发生故障，引起整个链路中的所有微服务都不可用，这就是雪崩。

微服务中，服务间调用关系错综复杂，一个微服务往往依赖于多个其它微服务。

如图，如果服务提供者I发生了故障，当前应用的部分业务因为依赖于服务I，因此也会被阻塞。此时，其它不依赖于服务I的业务似乎不受影响。

但是，依赖服务I的业务请求被阻塞，用户不会得到响应，则tomcat的这个线程不会得到释放，于是越来越多的用户请求到来，越来越多的线程被阻塞：

服务器支持的线程数和并发数是有限的，请求一直阻塞，会导致服务器资源耗尽，从而导致所有其它服务都不可用，那么当前服务也就不可用了。

那么，依赖于当前服务的其它服务随着时间的推移，最终也都会变成不可用，形成级联失败，雪崩就发生了：

解决雪崩问题的常见方式有四种：

1. 超时处理
2. 线程隔离
3. 降级熔断
4. 限流

超时处理

超时处理：设定超时时间，请求超过一定时间没有响应就返回错误信息，不会无休止等待

缺点：高并发不可用时，等待时间内有可能大量请求直接把资源耗尽了，所以设置超时时间只能起到缓解的作用，但并不能从根本上解决雪崩问题。

舱壁模式

舱壁模式来源于船舱的设计：

船舱会被隔板分离为多个独立空间，当船体破损时，只会导致部分空间进水，将故障控制在一定范围内，避免整个船体都被淹没。

于此类似，我们可以限定每个业务能使用的线程数，避免耗尽整个 tomcat 的资源，因此也叫线程隔离。

降级熔断

降级熔断是一种断路器模式，由断路器统计业务执行的异常比例，如果超出阈值则会熔断该业务，拦截访问该业务的一切请求。

断路器会统计访问某个服务的请求数量和异常比例：

当发现访问服务D的请求异常比例过高时，断路器会认为服务D有导致雪崩的风险，那么就会拦截访问服务D的一切请求，形成熔断：

限流

流量控制：限制业务访问的QPS，避免服务因流量的突增而发生故障。

QPS指的是每秒钟处理的请求数量

总结

什么是雪崩问题？

微服务之间相互调用，因为调用链中的一个服务故障，引起整个链路都无法访问的情况。

如果避免因瞬间高并发流量而导致服务故障呢？

限流是对服务的保护，避免因瞬间高并发流量而导致服务故障，进而避免雪崩。是一种预防措施。

如果避免因服务故障引起的雪崩问题呢？

超时处理、线程隔离、降级熔断是在部分服务故障时，将故障控制在一定范围，避免雪崩。是一种补救措施。

2.2、服务保护技术对比

在 SpringCloud 当中支持多种服务保护技术：

• Netfix Hystrix
• Sentinel
• Resilience4J

早期比较流行的是 Hystrix 框架，但目前国内使用最广泛的还是阿里巴巴的 Sentinel 框架，这里我们做下对比：

什么是信号量隔离、线程池隔离？

1、线程池隔离：当业务请求进入 tomcat 以后，会给每个隔离的业务创建一个独立的线程池，这样子会造成线程数量成倍增长，对 CPU 的压力会比较大，所以整个服务的性能会有一定的损失。

2、信号量隔离：当业务请求进入 tomcat 以后，不会给每个隔离的业务创建一个独立的线程池，而是会限制每个业务能使用的线程数量，减少了线程池的创建，对整个服务的性能不会有太大的影响，但是隔离性相比于线程池隔离会差点。

2.3、Sentinel介绍和安装

Sentinel 是阿里巴巴开源的一款微服务流量控制组件。官网地址：https://sentinelguard.io/zh-cn/index.html

Sentinel 具有以下特征:

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

安装 Sentinel 控制台：

1、下载

sentinel 官方提供了 UI 控制台，方便我们对系统做限流设置。大家可以在 GitHub 下载。

2、运行

下载完 jar 包后，将 jar 包放到任意非中文目录，执行命令：

java -jar sentinel-dashboard-1.8.1.jar

3、访问

访问 http://localhost:8080 页面，就可以看到sentinel的控制台了：

账号和密码默认都是：sentinel

此时页面空白一片，还需要我们来整合进 SpringCloud

4、如果需要修改 Sentinel 的默认端口、账户、密码，可以通过下列配置：

配置项	默认值	说明
server.port	8080	服务端口
sentinel.dashboard.auth.username	sentinel	默认用户名
sentinel.dashboard.auth.password	sentinel	默认密码

例如，修改端口为 8090：

java -jar sentinel-dashboard-1.8.1.jar -Dserver.port=8090

2.4、微服务整合Sentinel

cloud-demo 项目结构如下：

我们在 order-service 中整合 Sentinel，并连接 Sentinel 的控制台，步骤如下：

1、引入 Sentinel 依赖

<!-- 引入sentinel依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

2、配置控制台

修改 application.yml 文件，添加下面内容：

server:
  port: 8088
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # sentinel控制台地址

3、访问 order-service 的任意端点

打开浏览器，访问 http://localhost:10010/order/101，多访问几次，多点几次刷新，这样才能触发 Sentinel 的监控。

然后再访问 Sentinel 的控制台，查看效果。

3、流量控制

雪崩问题虽然有四种方案，但限流是避免服务因突发的流量而发生故障，是对微服务雪崩问题的预防。学过毛中特的都知道，《预判风险是防范风险的前提》，我们先学习流量控制。

3.1、簇点链路

当请求进入微服务时，首先会访问DispatcherServlet，然后进入Controller、Service、Mapper，这样的一个调用链就叫做簇点链路。

簇点链路中被监控的每一个接口就是一个资源。默认情况下 sentinel 会监控 SpringMVC 的每一个端点（Endpoint，也就是 Controller 中的方法），因此SpringMVC 的每一个端点（Endpoint）就是调用链路中的一个资源。

例如，我们访问的 order-service 中的 OrderController 中的端点：/order/{orderId}

流控、熔断等都是针对簇点链路中的资源来设置的，因此我们可以点击对应资源后面的按钮来设置规则：

• 流控：流量控制
• 降级：降级熔断
• 热点：热点参数限流，是限流的一种
• 授权：请求的权限控制

点击资源 /order/{orderId} 后面的流控按钮，就可以弹出表单。

表单中可以填写限流规则，如下：

其含义是限制 /order/{orderId} 这个资源的单机 QPS 为 1，即每秒只允许 1 次请求，超出的请求会被拦截并报错。

测试

需求：给 /order/{orderId} 这个资源设置流控规则，QPS 不能超过 5，然后测试。

1、首先在 sentinel 控制台添加限流规则

2、利用 Jmeter 进行测试：

20 个用户，2 秒内运行完，这样的话 QPS 就是 10，超过了我们在 sentinel 设置的 5

右键运行：

注意，不要点击菜单中的执行按钮来运行。

结果：

可以看到，成功的请求每次只有 5 个。

3.2、流控模式

在添加限流规则时，点击高级选项，可以选择三种流控模式：

• 直接：统计当前资源的请求，触发阈值时对当前资源直接限流，也是默认的模式
• 关联：统计与当前资源相关的另一个资源，另一个资源触发阈值时，对当前资源进行限流
• 链路：统计从指定链路访问到本资源的请求，触发阈值时，对指定链路进行限流

上面我们测试的就是直接模式，默认就是直接模式。

关联模式

统计与当前资源相关的另一个资源，另一个资源触发阈值时，对当前资源进行限流

使用场景：

比如用户支付时需要修改订单状态，同时用户需要查询订单。查询和修改操作会争抢数据库锁，产生竞争。业务需求是优先支付和更新订单的业务，因此当修改订单业务触发阈值时，需要对查询订单业务进行限流。

配置规则：

当 /write 资源访问量触发阈值时，就会对 /read 资源进行限流，避免影响 /write 资源。

需求：

在 OrderController 新建两个端点：/order/query 和 /order/update，无需实现业务

配置流控规则，当 /order/update 资源被访问的 QPS 超过5时，对 /order/query 请求限流

1、定义 /order/query 端点，模拟订单查询

		/**
     * 模拟订单查询
     *
     * @return
     */
    @GetMapping("/query")
    public String queryOrder() {
        return "查询订单成功";
    }

2、定义 /order/update 端点，模拟订单更新

		/**
     * 模拟订单更新
     *
     * @return
     */
    @GetMapping("/update")
    public String updateOrder() {
        return "更新订单成功";
    }

重启服务，查看 sentinel 控制台的簇点链路：

3、配置流控规则

想要对哪个端点限流，就点击哪个端点后面的按钮。我们是对订单查询 /order/query 进行限流，因此点击它后面的按钮：

在表单中填写流控规则：

4、在 JMeter 测试

选择《流控模式-关联》：

可以看到 1000 个用户，100 秒，因此 QPS 为10，超过了我们设定的阈值：5

查看 http 请求

请求的目标是 /order/update，但限流的目标是 /order/query，这就是关联模式；我们在浏览器访问 /order/query，可以发现确实被限流了。

满足下面条件可以使用关联模式：

1、两个有竞争关系的资源

2、一个优先级较高，一个优先级较低

链路模式

只针对从指定链路访问到本资源的请求做统计，判断是否超过阈值。

配置示例：

例如有两条请求链路：

• /test1 --> /common
• /test2 --> /common

如果只希望统计从 /test2 进入到 /common 的请求，则可以这样配置：

需求：有查询订单和创建订单业务，两者都需要查询商品。针对于从查询订单进入到查询商品的请求进行统计，并设置限流。

1. 在 OrderService 中添加一个 queryGoods 方法，不用实现业务
2. 在 OrderController 中，修改 /order/query 端点，调用 OrderService 中的 queryGoods 方法
3. 在 OrderController 中添加一个 /order/save 端点，调用 OrderService 的 queryGoods 方法
4. 给 queryGoods 设置限流规则，从 /order/query 进入 queryGoods 的方法限制 QPS 必须小于 2

操作

1、添加查询商品方法

在 order-service 服务中，给 OrderService 类添加一个 queryGoods 方法

		/**
     * 模拟查询商品
     */
    public void queryGoods() {
        System.out.println("查询商品");
    }

2、查询订单时，查询商品

在 order-service 服务的 OrderController 中，修改 /order/query 端点的业务逻辑

		/**
     * 模拟订单查询
     *
     * @return
     */
    @GetMapping("/query")
    public String queryOrder() {
        // 先去查询商品
        orderService.queryGoods();
        // 再去查询订单
        System.out.println("查询订单");
        return "查询订单成功";
    }

3、创建订单时，查询商品

在 order-service 服务的 OrderController 中，修改 /order/save 端点，模拟创建订单：

		/**
     * 模拟订单创建
     *
     * @return
     */
    @GetMapping("/save")
    public String saveOrder() {
        // 先去查询商品
        orderService.queryGoods();
        // 再去创建订单
        System.out.println("创建订单");
        return "创建订单成功";
    }

4、给查询商品添加资源标记

默认情况下，OrderService 中的方法是不被 Sentinel 监控的，需要我们自己通过注解来标记要监控的方法。

给 OrderService 的 queryGoods 方法添加 @SentinelResource 注解。

		/**
     * 模拟查询商品
     */
    @SentinelResource("goods")
    public void queryGoods() {
        System.out.println("查询商品");
    }

在链路模式中，我们是对不同来源的两个链路做监控。但是 Sentinel 默认会给进入 SpringMVC 的所有请求设置同一个 root 资源，这样会导致链路模式失效。所以我们需要关闭对 SpringMVC 的资源聚合，修改 order-service 服务的 application.yml 文件

spring:
  cloud:
    sentinel:
      web-context-unify: false # 关闭context整合

重启服务，访问 /order/query 和 /order/save，可以看到在 Sentinel 的簇点链路规则中，出现了新的资源：

6、添加流控规则

点击 goods 资源后面的流控按钮，在弹出的表单中填写下面信息：

只统计从 /order/query 进入 /goods 的资源，QPS 阈值为 2，超出则被限流。

7、Jmeter 测试

可以看到这里200个用户，50秒内发完，QPS为4，超过了我们设定的阈值2

一个 http 请求是访问 /order/save

运行的结果是 /order/save 完全不受影响。

访问 /order/query

运行结果是 /order/query，每次只有2个通过。

总结

流控模式有哪些？

• 直接：对当前资源进行限流
• 关联：高优先级资源触发阈值时，对低优先级资源进行限流
• 链路：阈值统计时，只统计从指定资源进入当前资源的请求，是对请求来源的限流

3.3、流控效果

在流控的高级选项中，还有一个流控效果选项：

前面我们的测试都是基于快速失败的。

流控效果是指请求达到流控阈值时应该采取的措施，包括三种：

1、快速失败：达到阈值后，新的请求会被立即拒绝并抛出 FlowException 异常，这是默认的处理方式。

2、Warm Up：预热模式，对超出阈值的请求同样是拒绝并抛出异常。但这种模式的阈值会动态变化，从一个较小值逐渐增加到最大阈值。

3、排队等待：让所有的请求按照先后次序排队执行，两个请求的间隔不能大于指定时长。

Warm Up

阈值一般是一个微服务能承担的最大 QPS，但是一个服务刚启动时，一切资源尚未初始化（冷启动），如果直接将 QPS 跑到最大值，可能会导致服务瞬间宕机。

Warm Up 也叫预热模式，是应对服务冷启动的一种方案。请求阈值的初始值是 maxThreshold / coldFactor，持续指定时长后，逐渐提高到 maxThreshold 值。而 coldFactor 的默认值是 3.

例如，我设置 QPS 的 maxThreshold 为 10，预热时间为 5 秒，那么初始阈值就是 10 / 3 = 3，然后在 5 秒后逐渐增加到 10

需求：给 /order/{orderId} 这个资源设置限流，最大 QPS 为 10，利用 Warm Up 效果，预热时长为 5 秒。

1、配置流控规则

2、JMeter 测试

选择《流控效果，warm up》：

刚刚启动时，大部分请求失败，成功的只有 3 个，说明 QPS 被限定在 3

随着时间推移，成功比例越来越高：

到 Sentinel 控制台查看实时监控：

一段时间后：

用官方的话讲，该方式主要用于系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间会把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免出现冷系统被压垮的情况。

排队等待

当请求超过 QPS 阈值时，「快速失败」和 「Warm Up」会拒绝新的请求并抛出异常。

而排队等待则是让所有请求进入到一个队列中，然后按照阈值允许的时间间隔依次执行。后来的请求必须等待前面的请求执行完成才能继续执行，如果请求预期的等待时间超过最大时长，则会被拒绝。这种方式严格控制了请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。

工作原理

例如：QPS = 5，意味着每 200ms 处理一个队列中的请求；timeout = 2000，意味着预期等待时长超过 2000ms 的请求会被拒绝并抛出异常。

什么是预期等待时长 ?

比如现在一下子来了 12 个请求，因为每 200ms 执行一个请求，那么预期等待时长就是：

• 第6个请求的预期等待时长 = 200 * (6 - 1) = 1000ms
• 第12个请求的预期等待时长 = 200 * (12-1) = 2200ms

现在，第 1 秒同时接收到 10 个请求，但第 2 秒只有 1 个请求，此时 QPS 的曲线是这样的：

如果使用排队等待的流控效果，所有进入的请求都要排队，以固定 200ms 的间隔执行，QPS 会变的很平滑：

平滑的 QPS 曲线，对于服务器来说是更友好的。

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

需求：给 /order/{orderId} 这个资源设置限流，最大 QPS 为 10，利用排队等待的流控效果，超时时长设置为 5s

1、添加流控规则

2、JMeter 测试

选择《流控效果，队列》：

QPS 为 15，已经超过了我们设定的 10，如果是之前的「快速失败」 、「Warm Up」模式，超出的请求应该会直接报错。

但是我们看看「排队等待」的运行结果：

再去 Sentinel 查看实时监控的 QPS 曲线：

QPS 非常平滑，一直保持在 10，但是超出的请求没有被拒绝，而是放入队列。因此响应时间（等待时间）会越来越长。

当队列满了以后，才会有部分请求失败：

总结

流控效果有哪些？

• 快速失败：QPS超过阈值时，拒绝新的请求
• warm up： QPS超过阈值时，拒绝新的请求；QPS阈值是逐渐提升的，可以避免冷启动时高并发导致服务宕机。
• 排队等待：请求会进入队列，按照阈值允许的时间间隔依次执行请求；如果请求预期等待时长大于超时时间，直接拒绝

3.4、热点参数限流

之前的限流是统计访问某个资源的所有请求，判断是否超过 QPS 阈值。而「热点参数限流」是分别统计参数值相同的请求，判断是否超过 QPS 阈值。

全局参数限流

例如，一个根据 id 查询商品的接口：

访问 /goods/{id} 的请求中，id 参数值会有变化，「热点参数限流」会根据参数值分别统计 QPS，统计结果：

当 id=1 的请求触发阈值被限流时，id值不为1的请求则不受影响。

配置示例：

对 hot 这个资源的 0 号参数（也就是第一个参数）做统计，每 1s 内相同参数值的请求数不能超过 5

热点参数限流

假设上面的例子是一个商品查询接口，那么在刚才的配置中，对这个接口的所有商品都一视同仁，QPS 都限定为 5

而在实际开发中，可能部分商品是热点商品，例如秒杀商品，我们希望这部分商品的 QPS 限制与其它商品不一样，尽量高一些。那就需要配置「热点参数限流」的高级选项了。

结合上一个配置，这里的含义是对 0 号的 long 类型参数进行限流，每 1s 内相同参数的 QPS 不能超过 5，有两个例外：

• 如果参数值是 101，则每 1s 允许的 QPS 为 15
• 如果参数值是 100，则每 1s 允许的 QPS 为 10

需求：给 /order/{orderId} 这个资源添加「热点参数限流」，规则如下：

• 默认的热点参数规则是每 1s 请求量不超过 2
• 给 102 这个参数设置例外：每 1s 请求量不超过 4
• 给 103 这个参数设置例外：每 1s 请求量不超过 10

注意事项：热点参数限流对默认的 SpringMVC 资源是无效的，需要利用 @SentinelResource 注解标记资源。

1、标记资源

给 order-service 服务中的 OrderController 中的 /order/{orderId} 资源添加注解：

2、热点参数限流规则

重启服务，访问该接口，可以看到我们标记的 hot 资源出现了：

注意：这里不要点击hot后面的按钮，页面有BUG。

点击左侧热点规则菜单：

点击新增，填写表单：

3、JMeter 测试

选择《热点参数限流 QPS1》：

这里发起请求的 QPS 为 5，包含 3 个 http 请求

普通参数，QPS阈值为 2：

运行结果：

例外项，QPS 阈值为 4：

运行jie’g

例外项，QPS 阈值为 10：

运行结果：

4、隔离和降级

限流只是一种预防措施，虽然限流可以尽量避免因高并发而引起的服务故障，但服务还是会因为其它原因而出现故障。

而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级的手段了。

线程隔离：调用者在调用服务提供者时，给每个调用的请求分配独立线程池，出现故障时，最多消耗这个线程池内的资源，避免把调用者的所有资源耗尽。

熔断降级：是在调用方这边加入断路器，统计对服务提供者的调用，如果调用的失败比例过高，则熔断该业务，不允许再访问该服务的提供者了。

可以看到，不管是线程隔离还是熔断降级，都是对客户端（调用方）的保护。需要在调用方发起远程调用时做线程隔离、或者服务熔断。

而我们的微服务远程调用都是基于 Feign 来完成的，因此我们需要将 Feign 与 Sentinel 进行整合，在 Feign 里面实现线程隔离和服务熔断。

4.1、Feign整合Sentinel

SpringCloud中，微服务调用都是通过Feign来实现的，因此做客户端保护必须整合 Feign 和 Sentinel

修改配置，开启 Sentinel 功能

修改 OrderService 服务的 application.yml 文件，开启 Feign 的 Sentinel 功能

feign:
  sentinel:
    enabled: true # 开启feign对sentinel的支持

编写失败降级逻辑代码

业务失败后，不能直接报错，而应该返回用户一个友好提示或者默认结果，这个就是失败降级逻辑。

给 FeignClient 编写失败后的降级逻辑

• 方式一：FallbackClass，但无法对远程调用的异常做处理。
• 方式二：FallbackFactory，可以对远程调用的异常做处理，我们选择这种

这里我们演示方式二的失败降级处理

1、步骤一：在 feing-api 项目中定义类，实现 FallbackFactory

@Slf4j
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {

    @Override
    public UserClient create(Throwable throwable) {
        // 创建UserClient接口的实现类，实现其中的方法，编写失败降级的处理逻辑
        return new UserClient() {
            @Override
            public User findById(Long id) {
                // 记录异常信息
                log.error("查询用户异常", throwable);
                // 根据业务需求返回默认的数据，这里是返回空用户
                return new User();
            }
        };
    }

}

2、步骤二：在 feing-api 项目中的 DefaultFeignConfiguration 类中将 UserClientFallbackFactory 注册为一个Bean

		@Bean
    public UserClientFallbackFactory userClientFallbackFactory() {
        return new UserClientFallbackFactory();
    }

3、步骤三：在 feing-api 项目中的 UserClient 接口中使用 UserClientFallbackFactory

// value表示要发送http请求的服务名称
@FeignClient(value = "userservice", fallbackFactory = UserClientFallbackFactory.class) 
public interface UserClient {

    @GetMapping("/user/{id}")
    User findById(@PathVariable("id") Long id);

}

4、注意：此时重启 order-service 服务会出现循环依赖问题，我们将 spring-cloud 的版本改成 Hoxton.SR9

然后在 order-service 服务的 OrderApplication 启动类上的 @EnableFeignClients 注解扫描工具类的class

5、重启后，访问一次订单查询业务，然后查看 Sentinel 控制台，可以看到新的簇点链路：

4.2、线程隔离（舱壁模式）

线程隔离（舱壁模式）有两种实现方式：

• 线程池隔离：给每个服务调用业务分配一个线程池，利用线程池本身实现隔离效果。
• 信号量隔离（Sentinel默认采用）：不创建线程池，而是采用计数器模式，记录业务使用的线程数量，达到信号量上限时，禁止新的请求。

两者的优缺点：

• 线程池隔离：基于线程池模式，有额外开销，但隔离控制更强
• 信号量隔离：基于计数器模式，简单，开销小

什么是扇出呢?

请求到我这个服务了，我这个服务依赖于其他 N 个服务，这个叫做扇出，从我这里来了一个，出去了好几个。

如果我依赖的服务越多，那么扇出也就越多。而扇出越多，开启的线程也就越多，额外的开销会越大。

sentinel实现线程隔离（信号量隔离）

用法说明：

在添加限流规则时，可以选择两种阈值类型

• QPS：就是每秒的请求数，之前已经演示过。
• 线程数：是该资源能使用的 Tomcat 线程数的最大值。也就是通过限制线程数量，实现线程隔离（舱壁模式）。

需求：给 order-service 服务中的 UserClient 的查询用户接口设置流控规则，线程数不能超过 2，然后利用 JMeter 测试。

1、配置隔离规则，选择 feign 接口后面的流控按钮

填写表单：

2、JMeter 测试

选择《阈值类型-线程数<2》：

一次发生 10 个请求，有较大概率并发线程数超过 2，而超出的请求会走之前定义的失败降级逻辑。

查看运行结果：

发现虽然结果都是通过了，不过部分请求得到的响应是「降级」返回的 null 信息。也就是我们写的降级方法。

总结

线程隔离的两种手段是？

• 信号量隔离（Sentinel用这种）
• 线程池隔离

信号量隔离的特点是？

• 基于计数器模式，简单，开销小

线程池隔离的特点是？

• 基于线程池模式，有额外开销，但隔离控制更强

4.3、熔断降级

熔断降级是解决雪崩问题的重要手段。其思路是由断路器统计服务调用的异常比例、慢请求比例，如果超出阈值则会熔断该服务。即拦截访问该服务的一切请求；而当服务恢复时，断路器会放行访问该服务的请求。

断路器控制熔断和放行是通过状态机来完成的，如下图就是一个断路器的状态机：

状态机包括三个状态：

• closed：关闭状态，断路器放行所有请求，并开始统计异常比例、慢请求比例。会去判断是否达到熔断条件，这一步我们叫做「熔断策略」，达到该条件则切换到 open 状态，打开断路器。
• open：打开状态，服务调用被熔断，访问被熔断服务的请求会被拒绝，快速失败，直接走降级逻辑。Open 状态 5 秒后会进入 half-open 状态。
• half-open：半开状态，会尝试放行一次请求，根据执行结果来判断接下来的操作。请求成功：则切换到 closed 状态；请求失败：则切换到 open 状态。

断路器熔断策略有三种：慢调用、异常比例、异常数

慢调用

业务的响应时间（RT）大于指定时长的请求就认定为慢调用请求。在指定时间内，如果请求数量超过设定的最小数量，慢调用比例大于设定的阈值，则触发熔断。

例如下图：

设置 RT 超过 500ms 的调用是慢调用，统计最近 10000ms 内的请求，如果请求量超过 10 次，并且慢调用比例超过 0.5，则触发熔断，熔断时长为 5s，然后进入 half-open 状态，放行一次请求做测试。

需求：给 UserClient 的查询用户接口设置降级规则，慢调用的 RT 阈值为 50ms，统计时间为 1s ，最小请求数量为 5，失败阈值比例为 0.4，熔断时长为 5s

1、设置慢调用

修改 user-service 中的 /user/{id} 这个接口的业务。通过休眠模拟一个延迟时间：

此时，orderId = 101 的订单，关联的是 id 为 1 的用户，调用时长为 111ms

orderId = 102 的订单，关联的是 id 为 2 的用户，调用时长为非常短

2、设置熔断规则

下面，给 feign 接口设置降级规则，超过 50ms 的请求都会被认为是慢请求。

规则：

3、测试

在浏览器访问：http://localhost:8088/order/101，快速刷新5次，可以发现，触发了熔断，请求时长缩短至 19ms，快速失败了，并且走降级逻辑，返回的是 null

此时在浏览器访问：http://localhost:8088/order/102，也被熔断了

异常比例、异常数

统计指定时间内的调用，如果调用次数超过指定请求数，并且出现异常的比例达到设定的比例阈值（或超过指定异常数），则触发熔断。

例如：

异常比例设置如下，统计最近 1000ms 内的请求，如果请求量超过 10 次，并且异常比例不低于 0.4，则触发熔断。

异常数设置如下，统计最近 1000ms 内的请求，如果请求量超过 10 次，并且异常比例不低于 2 次，则触发熔断。

需求：给 UserClient 的查询用户接口设置降级规则，统计时间为 1s，最小请求数量为 5，失败阈值比例为 0.4，熔断时长为 5s

1、设置异常请求

首先，修改 user-service 服务中的 /user/{id} 这个接口的业务。手动抛出异常，以触发异常比例的熔断，也就是说，id 为 2时，就会触发异常。

2、设置熔断规则

给 feign 接口设置降级规则：

规则：

在 5 次请求中，只要异常比例超过 0.4，也就是有 2 次以上的异常，就会触发熔断。

3、测试

在浏览器快速访问：http://localhost:8088/order/102，快速刷新 5 次，触发熔断降级。

此时，我们去访问本应该正常的 103，发现也被降级了。

总结

Sentinel熔断降级的策略有哪些？

• 慢调用比例：超过指定时长的调用为慢调用，统计单位时间内慢调用的比例，超过阈值则熔断
• 异常比例：统计单位时间内异常调用的比例，超过阈值则熔断
• 异常数：统计单位时间内异常调用的次数，超过阈值则熔断

5、授权规则

5.1、授权规则

授权规则可以对调用方的来源做控制，有白名单和黑名单两种方式。

• 白名单：来源（origin）在白名单内的调用者允许访问
• 黑名单：来源（origin）在黑名单内的调用者不允许访问

点击左侧菜单，可以看到授权规则：

• 资源名：就是受保护的资源，例如 /order/{orderId}
• 流控应用：是来源者的名单
  • 如果是勾选白名单，则名单中的来源被许可访问。
  • 如果是勾选黑名单，则名单中的来源被禁止访问。

比如：我们只允许请求从 gateway 到 order-service，不允许浏览器访问 order-service，那么白名单中就要填写网关的来源名称（origin）。

如何获取origin

Sentinel 是通过 RequestOriginParser 这个接口的 parseOrigin() 方法来获取请求的来源的。

public interface RequestOriginParser {
    /**
     * 从请求request对象中获取origin，获取方式自定义
     */
    String parseOrigin(HttpServletRequest request);
}

这个方法的作用就是从 request 对象中，获取请求者的 origin 值并返回。但是在默认情况下，Sentinel 不管请求者从哪里来，返回值永远都是 default，也就是说一切请求的来源都被认为是一样的值 default

因此，我们需要自定义这个接口的实现，让不同的请求，返回不同的 origin

例如在 order-service 服务中，我们定义一个 RequestOriginParser 的实现类

@Component
public class HeaderOriginParser implements RequestOriginParser {

    @Override
    public String parseOrigin(HttpServletRequest request) {
        // 1、获取请求头
        String origin = request.getHeader("origin");
        // 2、非空判断
        if (StringUtils.isEmpty(origin)) {
            origin = "blank";
        }
        return origin;
    }

}

我们会尝试从 request-header 中获取 origin 值。

给网关添加请求头

既然我们是从 reques-header 中获取 origin 值的，那么就必须让所有从 Gateway 路由到微服务的请求都带上 origin 头。

这个需要利用之前学习的一个 GatewayFilter 来实现，使用 AddRequestHeaderGatewayFilter。

修改 gateway 服务中的 application.yml，添加一个 defaultFilter：

spring:
  application:
    name: gateway # 服务名称
  cloud:
    gateway:
      default-filters: # 默认过滤器，会对所有的路由请求都生效
        - AddRequestHeader=origin,gateway # 添加名为origin的请求头，值为gateway，注意origin前面不能带空格

这样，从 Gateway 路由的所有请求都会带上 origin 头，值为 gateway。而从其它地方到达微服务的请求一般没有这个头。

配置授权规则

接下来，我们添加一个授权规则，放行 origin 值为 gateway 的请求。

配置如下：

现在，我们直接跳过网关，访问 order-service 服务：

通过网关访问：

5.2、自定义异常结果

默认情况下，发生限流、降级、授权拦截时，都会抛出异常到调用方。异常结果都是 flow limmiting（限流）。这样不够友好，无法得知是限流还是降级还是授权拦截。

异常类型

如果要自定义异常时的返回结果，需要实现 BlockExceptionHandler 接口：

public interface BlockExceptionHandler {
    /**
     * 处理请求被限流、降级、授权拦截时抛出的异常：BlockException
     */
    void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception;
}

这个方法有三个参数：

• HttpServletRequest request：request 对象
• HttpServletResponse response：response 对象
• BlockException e：被 Sentinel 拦截时抛出的异常

BlockException 包含多个不同的子类：

自定义异常处理

我们在 order-service 服务中定义一个自定义异常处理类，实现 BlockExceptionHandler 接口：

@Component
public class SentinelExceptionHandler implements BlockExceptionHandler {
    
    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, BlockException e) throws Exception {
        String msg = "未知异常";
        int status = 429;

        if (e instanceof FlowException) {
            msg = "请求被限流了";
        } else if (e instanceof ParamFlowException) {
            msg = "请求被热点参数限流";
        } else if (e instanceof DegradeException) {
            msg = "请求被降级了";
        } else if (e instanceof AuthorityException) {
            msg = "没有权限访问";
            status = 401;
        }

        response.setContentType("application/json;charset=utf-8");
        response.setStatus(status);
        response.getWriter().println("{\"msg\": " + msg + ", \"status\": " + status + "}");
    }

}

重启测试，在不同场景下，会返回不同的异常消息。

限流：

授权拦截时：

6、规则持久化

现在，Sentinel 的所有规则都是内存存储，重启后所有规则都会丢失。在生产环境下，我们必须确保这些规则的持久化，避免丢失。

6.1、规则管理模式

规则能否持久化，取决于规则管理模式，Sentinel 支持三种规则管理模式：

• 原始模式：Sentinel 的默认模式，将规则保存在内存，重启服务会丢失。
• pull 模式
• push 模式

pull 模式

控制台将配置的规则推送到 Sentinel 客户端，而客户端会将配置规则保存在本地文件或数据库中。以后会定时去本地文件或数据库中查询，更新本地规则。

push 模式

控制台将配置规则推送到远程配置中心，例如 Nacos，Sentinel 客户端监听 Nacos，获取配置变更的推送消息，完成本地配置更新。这种模式是比较推荐的一种。

6.2、实现 push 模式

修改 order-service 服务

修改 OrderService 服务，让其监听 Nacos 中的 sentinel 规则配置。

1、引入依赖

在 order-service 服务中引入 Sentinel 监听 Nacos 的依赖：

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

2、配置 Nacos 地址

在 order-service 中的 application.yml 文件配置 Nacos 地址及监听的配置信息：

spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080 # sentinel控制台地址
      web-context-unify: false # 关闭context整合
      datasource:
        # sentinel限流规则
        flow:
          nacos:
            server-addr: *.*.*.*:8848 # nacos服务地址
            dataId: orderservice-flow-rules
            groupId: SENTINEL_GROUP
            rule-type: flow # 还可以是：degrade、authority、param-flow
        # sentinel降级规则
        degrade:
          nacos:
            server-addr: *.*.*.*:8848 # nacos服务地址
            dataId: orderservice-degrade-rules
            groupId: SENTINEL_GROUP
            rule-type: degrade

修改 sentinel-dashboard 源码

SentinelDashboard 默认不支持 Nacos 的持久化，需要修改源码。

1、用 IDEA 打开这个项目

结构如下：

2、修改nacos依赖

在 sentinel-dashboard 源码的 pom 文件中，nacos 的依赖默认的 scope 是 test，只能在测试时使用，这里要去除：

将 sentinel-datasource-nacos 依赖的 scope 去掉，改成下面这样：

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

3、添加 nacos 支持

在 sentinel-dashboard 的 test 包下，已经编写了对 nacos 的支持，我们需要将其拷贝到 main 中。

4、修改 nacos 地址

然后，还需要修改 nacos 包下的 NacosConfig 类：

修改其中的 Nacos 地址，让其读取 application.properties 中的配置：

在 sentinel-dashboard 的 application.properties 中添加 Nacos 地址配置

# nacos服务地址
nacos.addr=*.*.*.*:8848

5、配置 nacos 数据源

另外，还需要修改 com.alibaba.csp.sentinel.dashboard.controller.v2 包下的 FlowControllerV2 类：

让我们添加的 Nacos 数据源生效：

6、修改前端页面

接下来，还要修改前端页面，添加一个支持 nacos 的菜单。

修改 src/main/webapp/resources/app/scripts/directives/sidebar/ 目录下的 sidebar.html 文件

将其中的这部分注释打开：

修改其中的文本：

7、重新编译、打包项目

运行 IDEA 中的 maven 插件，编译和打包修改好的 sentinel-dashboard：

8、启动

启动方式跟官方一样：

java -jar sentinel-dashboard.jar

如果想要修改 Nacos 地址，可以添加参数：

java -jar -Dnacos.addr=localhost:8848 sentinel-dashboard.jar