SpringCloud微服务-----服务容错sentinel

码农终将翻身

已于 2022-08-26 14:19:24 修改

阅读量1.1k

点赞数

分类专栏： springcloud 文章标签：微服务 spring cloud java

于 2022-08-24 21:20:40 首次发布

本文链接：https://blog.csdn.net/weixin_68509156/article/details/126505336

版权

springcloud 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

1. 高并发带来的问题

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。

例如: 对于一个依赖于30个服务的应用程序，每个服务都有99.99%的正常运行时间，你可以期望如下：

99.9930 = 99.7% 可用

也就是说一亿个请求的0.3% = 3000000 会失败

接下来，我们来模拟一个高并发的场景

1 编写java代码

@GetMapping("/order/prod/{pid}")
public Order order(@PathVariable("pid")Integer pid){
    log.info(">>客户下单，这时候要调用商品微服务查询商品信息");
    //这里直接使用productFeign调用接口中的方法，和我们原来controller调用service一样啊
    Product product = productFeign.findById(pid);
    //这里模拟shop-product 响应时间为2秒
    try {
        Thread.sleep(2000L);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

    log.info(">>商品信息,查询结果:" + JSON.toJSONString(product));
    Order order = new Order();
    order.setPid(product.getPid());
    order.setPname(product.getPname());
    order.setPprice(product.getPprice());
    order.setNumber(1);

    order.setUid(1);
    order.setUsername("张三");

    //为了不产生大量冗余数据 我们把添加订单的调用注释
    //orderService.save(order);

    return order;
}

@RequestMapping("order/ceshi")
public String ceshi(){
    return "这是测试数据";
}

2 修改application.yml

server:
  port: 8091
  tomcat:  # 为了测试方便 我们把Tomcat中最大的线程数改为10个
    max-threads: 10

3 接下来使用压测工具,对请求进行压力测试

下载地址https://jmeter.apache.org/

第一步：修改配置，并启动软件

进入bin目录,修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter.bat

启动软件。

第二步：添加线程组

第三步：配置线程并发数

第四步：添加Http取样

第五步：配置取样，并启动测试

4 访问ceshi方法观察效果

结论:

此时会发现, 由于a方法囤积了大量请求, 导致b方法的访问出现了问题，这就是服务雪崩的雏形。

2. 服务学崩效应

在分布式系统中,由于网络原因或自身的原因,服务一般无法保证 100% 可用。如果一个服务出现了问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等待，进而导致服务瘫痪。

由于服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的 “雪崩效应” 。

雪崩问题

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

雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问题，不会影响到其它服务的正常运行。也就是＂雪落而不雪崩＂。

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

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

舱壁模式：限定每个业务能使用的线程数，避免耗尽整个tomcat的资源，因此也叫线程隔离。

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

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

2.1 什么是雪崩问题？

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

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

流量控制

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

超时处理
线程隔离
降级熔断

2.2 服务保护技术对比

常见的容错组件 hystrix sentinel

Hystrix

Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止级联失败，从而提升系统的可用性与容错性。

Resilience4J

Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和 prometheus等多款主流产品进行整合。

Sentinel

Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定。

下面是三个组件在各方面的对比：

3 认识Sentinel

Sentinel是阿里巴巴开源的一款微服务流量控制组件。

官网地址：https://sentinelguard.io/zh-cn/index.html

Sentinel 具有以下特征:

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

3.1 什么是Sentinel

Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量为切入点, 从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

Sentinel 分为两个部分:

核心库（Java 客户端微服务）不依赖任何框架/库,能够运行于所有 Java 运行时环境，同时对 Dubbo /Spring Cloud 等框架也有较好的支持。

控制台（Dashboard==sentinel服务）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

3.2 安装Sentinel控制台

Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能。

1 下载jar包,解压到文件夹

https://github.com/alibaba/Sentinel/releases

2 启动控制台，在jar包所在目录搜索cmd

java -jar sentinel-dashboard-1.8.1.jar

3.然后访问：localhost:8080 即可看到控制台页面，默认的账户和密码都是sentinel

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

# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目) 
java -Dserver.port=8090 -jar sentinel-dashboard-1.8.1.jar

输入密码以后就会来到这个界面.

3.3 微服务集成Sentinel

为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可

我们可以给需要的微服务中都整合上sentinel,网关服务可以不用加.

1 在微服务pom.xml中加入下面依赖

<!--引入sentinal的依赖jar文件-->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

2 修改配置文件

# 指定sentinel控制台的地址
spring.cloud.sentinel.transport.dashboard=localhost:8080

3 访问微服务的任意端点，触发sentinel监控，访问localhost:7000/order/buy/1/1

4 查看Sentinel控制台

可以看到我们的微服务已经整合上了sentinel.

4 流控规则

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

4.1 簇点链路

簇点链路：就是项目内的调用链路，链路中被监控的每个接口就是一个资源。默认情况下sentinel会监控SpringMVC的每一个端点（Endpoint），因此SpringMVC的每一个端点（Endpoint）就是调用链路中的一个资源。流控、熔断等都是针对簇点链路中的资源来设置的，因此我们可以点击对应资源后面的按钮来设置规则：

4.2 快速入门

点击资源/order/buy/1/10后面的流控按钮，就可以弹出表单。表单中可以添加流控规则，如下图所示：

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

资源名：唯一名称，默认是请求路径，可自定义

针对来源：指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制

阈值类型/单机阈值：

QPS（每秒请求数量）: 当调用该接口的QPS达到阈值的时候，进行限流
线程数：当调用该接口的线程数达到阈值的时候，进行限流

是否集群：暂不需要集群

4.3 流控规则入门案例

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

1.设置流控规则：

我们先做一个简单配置，设置阈值类型为QPS，单机阈值为5。即每秒请求量大于5的时候开始限流

接下来，在流控规则页面就可以看到这个配置

2. jemeter测试（测压软件）：

察看结果树，2秒20请求20次，理论上应该有10个请求失败

可以证明我们的流控规则已经生效了,可以看到前五个请求可以正常发出,但是第六个开始就请求失败了,有时候可能并不符合自己的理想值，也许这些失败的请求导致Jemeter的并发出现了问题,让这10个请求没有在同一秒内发出,所以并不是理想值.

在jemeter测试过程中，我们迅速访问, 观察效果，此时发现，当QPS > 5的时候，服务就不能正常响应，而是返回Blocked by Sentinel (flflow limiting)结果。

4.4 配置流控模式

点击上面设置流控规则的编辑按钮，然后在编辑页面点击高级选项，会看到有流控模式一栏。

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

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

下面呢分别演示三种模式：

4.4.1.直接流控模式

直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流。上面案例使用的就是直接流控模式。

上边演示的就是直接流控模式。

4.4.2.流控模式-关联

关联模式：统计与当前资源相关的另一个资源，触发阈值时，对当前资源限流
使用场景：比如用户支付时需要修改订单状态，同时用户要查询订单。查询和修改操作会争抢数据库锁，产生竞争。业务需求是有限支付和更新订单的业务，因此当修改订单业务触发阈值时，需要对查询订单业务限流。

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

两个有竞争关系的资源
一个优先级较高，一个优先级较低

案例:当修改的并发请求量大时,限制对查询的请求(我们可以理解为修改的优先级要大于查询的优先级).

目的：当/update资源访问量触发阈值时，就会对/query资源限流，避免影响/update资源。
1.在OrderController新建两个端点：/order/query和/order/update，无需实现业务

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

要明确,对谁限流,就对谁设置,所以我们应该对/order/query进行设置.

3. 在Jemeter中对/order/update进行压测,让他每秒的请求量大于5,然后在浏览器中访问/order/query,查看是否可以访问

此时，我们可以看到/order/query被限流,证明关联模式流控规则生效.

4.4.3.流控模式-链路

链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细。

例如有两条请求链路：
/test1 -> /common
/test2 -> /common

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

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

步骤：

1.在OrderController中创建两个端口都去调用OrderService中的queryGoods方法，不用实现业务

2.在OrderController中，添加/order/queryOrder端点，调用OrderService中的queryGoods方法

3.在OrderController中添加一个/order/saveOrder的端点，调用OrderService的queryGoods方法

这里我们要注意一点,Sentinel默认只会标记Controller中的方法为资源,如果想要将service中的方法标记为资源,则需要在service层对应的方法上加@SentinelResource注解,并且在配置文件中追加配置,关闭context整合,才能使该注解生效:

Sentinel默认只标记Controller中的方法为资源，如果要标记其它方法，需要利用@SentinelResource注解

修改配置文件

Sentinel默认会将Controller方法做context整合，导致链路模式的流控失效，需要修改application.yml，添加

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

然后重启该服务.在Sentinel控制台中就可以看到我们新添加的资源:"getGoodsMsg".(记得先访问一次才能在控制台中显示)

4.给queryGoods设置限流规则，从/order/queryOrder进入queryGoods的方法限制QPS必须小于2

使用压测工具Jemeter同时对/order/queryOrder 和 /order/saveOrder两条链路做压测,让他们5秒内都请求20次.

因为上边对queryOrder限流，并发量大于2的时候queryOrder会请求失败，saveOrder不影响

察看queryOrder结果树:

察看saveOrder结果树:

实验结果表示流控规则----链路模式设置成功.

流控模式有哪些？

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

4.5. 流控效果

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

快速失败：达到阈值后，新的请求会被立即拒绝并抛出FlowException异常。是默认的处理方式。
warm up：预热模式，对超出阈值的请求同样是拒绝并抛出异常。但这种模式阈值会动态变化，从一个较小值逐渐增加到最大阈值。
排队等待：让所有的请求按照先后次序排队执行，两个请求的间隔不能小于指定时长

4.5.1 流控效果-warm up（预热模式）

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

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

案例：给/order/getOrder这个资源设置限流，最大QPS为10，利用warm up效果，预热时长为5秒

1.设置流控规则:

2.在Jemeter中进行压测该资源,让他每秒发送10次请求,持续10秒:

查看结果树

图中可以看出,一开始,每秒发送的10次请求只能通过三个,到中间慢慢的每秒通过的请求逐渐增多,到最后每秒发送的10次请求全部通过.这符合我们一开始设置的预热效果.

4.5.2 流控效果-排队等待

当请求超过QPS阈值时，快速失败和warm up 会拒绝新的请求并抛出异常。而排队等待则是让所有请求进入一个队列中，然后按照阈值允许的时间间隔依次执行。后来的请求必须等待前面执行完成，如果请求预期的等待时间超出最大时长，则会被拒绝。

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

排队等待适合处理脉冲型的流量:当流量波形为脉冲形式时(即一阵流量大一阵流量小,形成脉冲的形式),我们可以利用起流量少的时间,作为排队等待时间.让QPS过滤掉的请求在等待时间内去处理,等待时间过了没有处理的请求都让他直接失败.

案例：给/order/getOrder这个资源设置限流，最大QPS为5，利用排队的流控效果，超时时长设置为5s

1.设置流控规则:

2.在Jemeter中进行压测该资源,让他每秒发送20次请求,持续5秒:

查看结果树

4.6 热点参数限流

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

配置示例：

代表的含义是：对hot这个资源的0号参数（第一个参数）做统计，每1秒相同参数值的请求数不能超过5

在热点参数限流的高级选项中，可以对部分参数设置例外配置：

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

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

案例:

给/order/buy/{pid}/{num}这个资源添加热点参数限流，规则如下：

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

注意:

热点参数限流对默认的SpringMVC资源无效
热点参数默认不会对springmvc的资源进行限制，我们可以使用@SentinelResourse自定义资源

所以我们在设置之前,要先给该资源设置@SentinelResource.让热点参数能够对该资源起作用.

1.在OrderController端口上加注解@SentinelResourse

配置文件不要忘了关闭context整合

这时我们重启服务,并按照要求设置热点资源限流规则
我们不能直接点该资源右边的热点,这样点没有高级设置.我们需要在左侧菜单热点规则---->新建热点规则.

2. 设置热点规则：

配置已经完成,我们继续使用我们的压测工具Jmeter实验一下.

我们2秒请求20次，理论上pid=1时1秒通过5次参数请求;pid=2设置1秒通过10次请求.其他情况通过5次请求。根据我们设置的热点参数规则, 他们都会有一个请求被判定失败.让我们直接看看结果是不是这样:

当pid为1时，查看结果树

当pid为2时，查看结果树

其他情况下，

我们想象的结果达到了，有时候会有一定偏差，不过无伤大雅。

5. 隔离和降级

FeignClient整合
Sentinel 线程隔离（舱壁模式）
熔断降级

虽然限流可以尽量避免因高并发而引起的服务故障，但服务还会因为其它原因而故障。而要将这些故障控制在一定范围，避免雪崩，就要靠线程隔离（舱壁模式）和熔断降级手段了。不管是线程隔离还是熔断降级，都是对客户端（调用方）的保护。

5.1 OpenFeign整合Sentinel

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

1.修改spring-order微服务的配置文件，开启Feign的Sentinel功能

# 整合sentinel和openfeign
feign.sentinel.enabled=true

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

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

①在springcloud-order微服务中创建FallbackFactory工厂类，实现FallbackFactory

package com.wzh.feign;

import com.wzh.pojo.Product;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;


@Component
@Slf4j
public class ProductFeignFactory implements FallbackFactory {
    @Override
    public Object create(Throwable throwable) {
        // 创建ProductFeign接口实现类，实现其中的方法，编写失败降级的处理逻辑
        ProductFeign productFeign = new ProductFeign() {
            //这是getById方法的兜底方案
            @Override
            public Product getById(Integer pid) {
                // 记录异常信息
                log.error("出现了问题,调用该兜底方法");
                Product p = new Product();
                //返回文字描述和异常信息
                p.setPname("服务器正忙,请稍后再试"+throwable.getMessage());
                return p;
            }
        };
        return productFeign;
    }
}

我们可以使用@Component注解把该类交给spring容器管理，也可以使用@Bean

②在feignClient指定fallbackFactory工厂类的反射

配置完成后重启项目,访问一遍该路径,在Sentinel控制台中就可以看到这个资源:

我们之后的降级操作都是对该资源进行操作的.

Sentinel支持的雪崩解决方案：

线程隔离（仓壁模式）
降级熔断

Feign整合Sentinel的步骤：

在application.yml中配置：feign.sentienl.enable=true
给FeignClient编写FallbackFactory并注册为Bean
将FallbackFactory配置到FeignClient

5.2 线程隔离

线程隔离有两种方式实现：

线程池隔离
信号量隔离（Sentinel默认采用）

线程池隔离会创建出新的线程,而信号量隔离是增加一个计数器,没有额外增加新的线程.

使用Sentinel设置线程隔离（舱壁模式）

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

QPS：就是每秒的请求数，在快速入门中已经演示过
线程数：是该资源能使用用的tomcat线程数的最大值。也就是通过限制线程数量，实现舱壁模式。

案例:

1.我们给GET:http://springcloud-product/product/getById/{pid}设置线程隔离,线程数不能超过2.

我们用Jemeter进行测试.

我们给/order/buy/1/1这个请求进行测试,他同样会调取我们设置线程隔离的这个资源.我们设置0秒发送10次请求.

可以看到,我们请求只通过了两个,剩下的8个线程都被拒绝掉了.

5.3 熔断降级

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

断路器熔断策略有三种：慢调用、异常比例、异常数
慢调用：业务的响应时长（RT）大于指定时长的请求认定为慢调用请求。在指定时间内，如果请求数量超过设定的最小数量，慢调用比例大于设定的阈值，则触发熔断。例如：

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

5.3.1 熔断策略-慢调用

为了方便演示,我们给host资源的业务代码增加100ms的睡眠时间

这样远程调用我们这个方法时,如果传入的id=1,那么就睡眠100ms.其他的正常运行.

传入id=1时,耗时在100ms以上.

其他情况，正常在100以内

这样我们就可以以100ms为界限规定是否为慢调用.10s内如果发送请求大于5个,那么如果发送的这些请求中,慢调用的比例大于0.5,就让断路器对该服务进行熔断.

我们在浏览器中疯狂刷新一下http://localhost:8091/order/buy/1/2的请求,让其熔断.

可以看到,已经被熔断了.我们这时就算访问不是慢调用的请求一样是显示熔断效果

对于熔断的半开请求,注意,当熔断的时间到了以后,会使熔断处于半开状态.这时第一个访问的请求如果还是慢调用的请求,那么该服务继续熔断.如果是正常请求,那么就关闭熔断状态.

5.3.2 熔断策略----异常比例、异常数

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

解读：统计最近1000ms内的请求，如果请求量超过10次，并且异常比例不低于0.5，则触发熔断，熔断时长为5秒。然后进入half-open状态，放行一次请求做测试。

我们再演示一个异常比例的熔断策略.我们修改一下业务代码,让其pid=2时产生一个异常.

然后设置降级规则.当 10s内发送请求大于5个时,发送的请求中如果发生异常的比例大于0.5就熔断.

熔断前:

疯狂请求一波，,熔断后:

6 自定义异常

默认情况下，发生限流、降级、授权拦截时，都会抛出异常到调用方。如果要自定义异常时的返回结果，需要实现BlockExceptionHandler接口：

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

而BlockException包含很多个子类，分别对应不同的场景：

我们在springcloud-order服务中定义类，实现BlockExceptionHandler接口：

package com.wzh.handler;
 
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 org.springframework.stereotype.Component;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@Component
public class SentinelBlockHandler implements BlockExceptionHandler {
    @Override
    public void handle(
            HttpServletRequest httpServletRequest,
            HttpServletResponse httpServletResponse, BlockException e) throws Exception {
        String msg = "未知异常";
        int status = 429;
        if (e instanceof FlowException) {
           msg = "请求被限流了！";
        } else if (e instanceof DegradeException) {
            msg = "请求被降级了！"; 
        } else if (e instanceof ParamFlowException) {
            msg = "热点参数限流！";
        } else if (e instanceof AuthorityException) {
            msg = "请求没有权限！";
           status = 401;
       }
       httpServletResponse.setContentType("application/json;charset=utf-8");
        httpServletResponse.setStatus(status);
        httpServletResponse.getWriter().println("{\"message\": \"" + msg + "\", \"status\": " + status + "}");
   }
}

随后重启服务.我们测试一个限流异常:

7. 持久化规则

Sentinel的控制台规则管理有三种模式：

原始模式：控制台配置的规则直接推送到Sentinel客户端，也就是我们的应用。然后保存在内存中，服务重启则丢失

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

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

7.1 实现pull模式

1 编写处理类

package com.wzh.config;
 
import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
import com.alibaba.csp.sentinel.datasource.*;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.springframework.beans.factory.annotation.Value;
 
import java.io.File;
import java.io.IOException;
import java.util.List;
public class FilePersistence implements InitFunc {
 
    @Value("${spring.application.name}")
    private String appcationName;
 
    @Override
    public void init() throws Exception {
        String ruleDir = System.getProperty("user.home") + "/sentinel-rules/" + appcationName;
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";
        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";
 
        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);
 
        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);
 
        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);
 
        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);
 
        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);
 
        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }
 
    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );
 
    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );
 
    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );
 
    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }
 
    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }
 
    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

2 添加配置

在resources下创建配置目录 META-INF/services ,然后添加文件

com.alibaba.csp.sentinel.init.InitFunc

在文件中添加配置类的全路径