SpringCloud Alibaba 之Sentinel

实现熔断和限流

Sentinel是什么

官网 https://github.com/alibaba/Sentinel

中文 https://github.com/alibaba/Sentinel/wiki/%E4%BB%8B%E7%BB%8D

Hystrix 缺点

需要我们程序员自己手工搭建监控平台
没有一套web界面可以给我们进行更加细粒化的配置

流控、速率控制、服务熔断、服务降级…

Sentinel 单独一个组件，可以独立出来。

直接界面化的细粒度统一配置。

去哪儿下？ https://github.com/alibaba/Sentinel/releases

此次下载 1.7.0 版本

能干嘛？

怎么玩？

查看github上官方文档可以看How to Use Sentinel

服务使用中的各种问题

服务雪崩

服务降级

服务熔断

服务限流

安装Sentinel控制台

sentinel组件由2部分构成：

后台

前台8080

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

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

安装步骤

下载 https://github.com/alibaba/sentinel/releases

下载到本地 sentinel-dashboard-1.7.0.jar

运行命令

前提： java8环境OK 8080端口不能被占用

命令： java -jar sentinel-dashboard-1.7.0.jar 在jar包文件夹cmd,输入

访问sentinel管理界面

http://localhost:8080

登录账号密码为sentinel

初始化演示工程

1、启动Nacos8848成功： http://localhost:8848/nacos/#/login

2、Module cloudalibaba-sentinel-service8401

POM

<dependencies>
    <!--SpringCloud alibaba nacos -->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--SpringCloud alibaba sentinel - datasource-nacos  后续做持久化用到-->
    <dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-datasource-nacos</artifactId>
    </dependency>

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

    <!--openfeign 后续要用-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

    <!--SpringBoot 整合Web组件+actuator-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>


</dependencies>

YML

server:
  port: 8401

spring:
  application:
    name: cloudalibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描，直至找到未被占用的端口
        port: 8719

management:
  endpoints:
    web:
      exposure:
        include: '*'

主启动类

@EnableDiscoveryClient
@SpringBootApplication
public class MainApp8401 {

    public static void main(String[] args) {
        SpringApplication.run(MainApp8401.class, args);
    }

}

业务类 FlowLimitController

@RestController
public class FlowLimitController {

    @GetMapping("/testA")
    public String testA() {
        return "------testA";
    }

    @GetMapping("/testB")
    public String testB() {
        return "-----testB";
    }
    
}

3、启动Sentinel8080

java -jar sentinel-dashboard-1.7.0.jar

4、启动微服务8401

5、启动8401微服务后查看sentinel控制台

会发现后台空空如也，啥都没有

Sentinel采用懒加载说明

执行一次访问即可：http://localhost:8401/testA

http://localhost:8401/testB

效果：应用开始出现在后台

结论：Sentinel8080正在监控

流控规则

流控规则简介

资源名：唯一名称，默认请求路径

针对来源：Sentinel可以针对调用者进行限流，填写微服务名，默认default(不区分来源)

阈值类型/单机阈值：

QPS(每秒钟的请求熟路)：当调用该api的QPS达到阈值的时候，进行限流

线程数：当调用该api的线程数达到阈值时候，进行限流

是否集群：不需要集群

流控模式：

直接：api达到限流条件时，直接限流

关联：当关联的资源达到阈值时，就限流自己

链路：只记录指定链路上的流量（指定资源从入口资源进来的流量，如果达到阈值，就进行限流）

流控效果：

快速失败：直接失败，抛异常

Warm Up: 根据codeFactor （冷加载因子，默认3）的值，从阈值/codeFactor，经过预热时长，才达到设置的QPS阈值

排队等待：匀速排队，让请求以匀速通过，阈值类型必须设置为QPS,否则无效

QPS直接失败

直接->快速失败系统默认：表示1秒钟查询次数在单机阈值以内就是OK，超过就直接失败，报默认错误

默认设置的阈值类型是QPS

报错信息：Blocked by Sentinel (flow limiting)

访问频率降低后可以自动恢复。

思考：直接调用默认报错信息，技术方面OK，但是but，是否应该有我们自己的后续处理？

应该有个fallback方法，自己配置

线程数直接失败

改造controller

@RestController
public class FlowLimitController {

    @GetMapping("/testA")
    public String test001(){
        try {
            TimeUnit.MILLISECONDS.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "testA";
    }

    @GetMapping("/testB")
    public String test002() {

        return "testB";
    }

}

中间犯得一次错误：注意：MICROSECONDS 和MILLSECONDS的区别微秒和毫秒

重启后访问一次testA 和testB ,链路出现后设置流控：

设置链路流控：

设置testA 为阈值类型：线程数，单机阈值 1

返回访问多次点击后出现blocked by sentinel

线程数和QPS的区别：

QPS是直接拒绝，关在大门外，而线程数是放进来，但是同时只能执行阈值数，多了就不行了

关联

是什么：当关联的资源达到阈值时，就限流自己

当与A关联的资源B达到阈值后，就限流A自己

B惹事，A挂了

如何配置：在高级选项里设置 /testA和/testB的关联

设置效果：当关联资源/testB的qbs阈值达到1时，就限流/testA的Rest访问地址，当关联资源达到阈值后闲置配置好的资源名

postman模拟并发秘籍访问testB

先试着访问testB ,可以访问，点击框的最右侧的save as ,保存进folder,

第二步：点击文件夹右边三个点上方的右向箭头，出现collection信息，点击相应的请求后，点击上方的Run按钮

第三步：上面步骤点击Run后出现Collection Runner界面，可以设置请求的信息，可以设置多少次访问，间隔多长时间

run: 大批量线程高并发访问B，导致A失效了

点击访问 testA 结果发现：blocked by sentinel (flow limiting)

注意（容易错的地方）：谁关联谁?谁出错？

在监控中，设置资源名 /testA 关联 /testB,也就是下方的那个

在postman中大批量密集访问 /testB,然后去访问/testA，发现/testA失效，常犯错误就是设置反了

流控效果

直接

直接-> 快速失败（默认的流控处理）

直接失败，抛出异常 blocked by Sentinel(flow limiting)

源码 com.alibaba.csp.sentinel.slots.block.flow.controller.DefaultController

预热

说明：公式：阈值除以coldFactor(默认是3)，经过预热时长后才会达到阈值

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

解释：默认 coldFactor为3，即请求 QPS 从 threshold / 3 开始，经过预热时长逐渐升到设定的QPS阈值。具体可以看官网。

案例：阈值为10 ，并且预热时长设置为5秒

系统初始化的阈值为 10 / 3约等于3，即阈值开始为3；然后过了5秒后阈值才慢慢升高恢复到10.

具体实现可以看源码 WarmUpController

试验：设置WarmUp , QPS,阈值为10.预热时长为5，

操作：快速点击，开始还有失败，5秒后便不再失败，因为阈值升高了。

应用场景：秒杀系统在开始的瞬间，会有很多流量，可能把系统打崩，预热可以保护系统，慢慢提高到设定的阈值。

排队等待

匀速排队，让请求以均匀的速度通过，阈值类型必须设置成QPS,否则无效。

可以设置单机阈值1 表示每秒1次请求，超过的话就排队等待，超时时间设置为20000，表示等待的超时时间为20000毫米。

匀速排队会严格控制请求通过的间隔时间，让请求以均匀的速度通过，对应的是漏桶算法。

这种方式主要用来处理间隔性突发的流量，如消息队列。

降级规则

降级简介

官网：熔断降级： https://github.com/alibaba/Sentinel/wiki/%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7

Sentinel后台点击降级规则可进行设置

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

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

Sentinel 的断路器是没有半开状态的 **

半开的状态系统去检测是否请求有异常，没有异常就关闭断路器恢复使用，有异常则继续打开断路器不可用，具体可以参考Hystrix

复习Hystrix

RT

平均响应时间，秒级

a)平均响应时间，超出阈值且 b)在时间窗口内通过的请求 >= 5, 两个条件同时满足后 --> 触发发降级

窗口期过后 —> 关闭断路器

RT最大4900 （更大的需要通过 -Dcsp.sentinel.statistic.max.rt=xxxx才能生效）

测试

代码：

@GetMapping("/testD")
public String testD() {
    //暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.info("testD 测试RT");
    return "------testD";
}

降级设置：

点击链路的降级

jemeter压力测试

启动方式： jemeter解压文件夹bin目录，点击jemeter命令文件

设置为10 个，永远，这样每次都是一秒进来10个，超过默认的5个

异常比例（秒级）

是什么：QPS >=5 且异常比例（秒级统计）超过阈值时，触发降级；时间窗口结束后，关闭降级

详细介绍：每秒请求量 >= 5，并且每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下来的时间窗口之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是[1.0,1.0]代表0%~100%。

/testD里加个

这样就会报错。

设置在降级规则中设置 /testD 异常比例，为0.2 时间窗口为 3秒

jemeter测试：发现被降级

手速快也可以实现测试，手速慢，次数不够，会报错，但是手速快，次数多后，就不再报错，而是blocked,表明被降级

异常数（分钟级）

异常数（分钟统计）超过阈值时，触发降级；时间窗口结束后，关闭降级

解释：当资源近1分钟的异常数目超过阈值之后会进行熔断。注意由于统计时间窗口是分钟级别的，若timeWindow 小于60s，则结束熔断状态后仍可能再肌肉怒熔断状态。

流程：异常数（分钟统计）超过阈值 -> 触发降级（断路器打开） -> 时间窗口结束 -> 关闭降级

异常数按分钟统计

时间窗口设置一定要大于60s

测试：

@GetMapping("/testE")
    public String testE() {
        log.info("testE 测试异常数");
        int age = 10/0;
        return "-------testE 测试异常数";
    }

设置异常数为 5 ，时间窗口为70 ，浏览器连续访问 5次后，第6次blocked，注意时间窗口

热点key限流

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

商品 ID 为参数，统计一段时间内最常购买的商品 ID 并进行限制
用户 ID 为参数，针对一段时间内频繁访问的用户 ID 进行限制

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

官网 https://github.com/alibaba/Sentinel/wiki/%E7%83%AD%E7%82%B9%E5%8F%82%E6%95%B0%E9%99%90%E6%B5%81

承上启下复习start

兜底方法：分为系统默认和客户自定义，两种

之前的case，限流出问题后，都是用sentinel系统默认的提示： Blocked by Sentinel (flow limiting)

我们能不能自定义？类似hystrix, 谋个方法出问题了，就找对应的兜底降级方法？

结论：从HystrixCommand 到 @SentinelResource

代码

@GetMapping("/testHotKey")
    @SentinelResource(value = "testHotKey",blockHandler = "deal_testHotKey")//违反了sentinel规则就找那个兜底方法
//前面的value是标识，后面的是指定自定义的兜底方法
    public String testHotKey(@RequestParam(value = "p1",required = false) String p1,
                             @RequestParam(value = "p2",required = false) String p2) {
        //int age = 10/0;
        return "------testHotKey";
    }

    //兜底方法
    public String deal_testHotKey (String p1, String p2, BlockException exception){
        return "------deal_testHotKey,o(╥﹏╥)o";
    }

犯的两个错误： 1，兜底方法里是BlockException，不是BlockedException,

2. 兜底方法参数个数应该包含被限流的方法的参数，即：被限流的方法里有p1,p2两个参数，兜底方法里也该有，之前写的只有p1,导致抛出一个关于参数的 FlowException

配置

点击热点规则，点击新增热点限流规则，进行设置

资源名：@SentinelResource注解里的value,这里是testHotKey,

设置参数索引 0，单机阈值 1，统计窗口时长 1

意思：假如请求带的参数下标为0，在统计时长1秒内，访问次数超过1次，即触发限流，直接调用blockHandler方法。

假如不设置blockHandler,会直接将ErrorPage放到前台。

测试

先做个测试，索引数设置为0，带p1 参数，可以触发，同时带p1和p2，也触发，但是只带p2，狂点都不会触发。因为没限制第二个参数

这里涉及参数例外项，在高级选项里

参数例外项

特殊情况：我们期望当p1是某个特殊值的时候，它的限流和平时不一样

特例：假如当p1的值等于5时，它的阈值可以达到200

设置：在参数例外项里，参数类型 java.lang.String ，参数值为5，阈值为200，就是指针对p1的参数，当值为5时，阈值为200

其他

可以试着在程序里加个 int age = 10/0;

发现，blockHandler不会去兜底，

因为@SentinelResource处理的是Sentinel控制台配置的违规情况，有blockHandler方法配置的兜底处理，

对于程序运行时产生的RuntimeException,@SentinelResource是不管的。

fallback才管运行时产生的异常

系统规则

是什么：系统自适应限流

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

前面的限流都是对某个链路例如 /testA, 甚至某个方法进行限流，但是，现在想在整个系统入口层面进行限制

设置：系统规则

有阈值类型 LOAD 自适应：超过估算的系统容量触发，设定参考值一般是CPU cores * 2.5

线程数

入口 QPS

CPU使用率

示例：配置全局QPS 阈值设置为2 ，然后发现各个入口，都可以触发，因为它是系统层面的

@SentinelResource配置

按资源名称限流 + 后续处理

a.启动Nacos成功

b.启动Sentinel成功

c.Module 引入cloud-api-commons通用包

<!--引入自定义的api通用包，可以使用Payment支付Entity-->
<dependency>
    <groupId>com.huawei.springcloud</groupId>
    <artifactId>cloud-api-commons</artifactId>
    <version>${project.version}</version>
</dependency>

d. 新建controller类来测试

@RestController
public class RateLimitController {

    @GetMapping("/byResource")
    @SentinelResource(value = "byResource",blockHandler = "handleException")
    public CommonResult byResource() {
        return new CommonResult(200,"按资源名称限流测试OK",new Payment(2021L,"serial001"));
    }

    public CommonResult handleException(BlockException exception) {
        return new CommonResult(444,exception.getClass().getCanonicalName() + "\t 服务不可用");
    }

}

e.配置流控规则

配置步骤：

点击流控规则

图形配置和代码关系

点击簇点链路，点击列表视图，对 byResource 点击流控设置（这里没有左斜杠）

单机阈值设置为 1；

表示1秒钟内查询次数大于1，就跑到我们自定义处，限流

与上面的流控相比，这里的流控有处理方法

按照Url地址限流+后续处理

通过访问的URL来限流，会返回Sentinel自带默认的限流处理信息

业务类ReteLimitController信息

@GetMapping("/rateLimit/byUrl")
@SentinelResource(value = "byUrl")
public CommonResult byUrl() {
    return new CommonResult(200,"按url限流测试OK",new Payment(2021L,"serial002"));
}

访问一次：http://localhost:8401/rateLimit/byUrl 成功

Sentinel控制台设置

对 /rateLimit/byUrl 进行流控 (这里有左斜杠)

QPS 阈值设置为 1

测试发现，会直接进入Blocked by Sentinel (flow limiting),这里走默认的处理方法

对/byResource和/rateLimit/byUrl 进行流控，不会进入blockHandler,

但是对 byUrl 和 byResource 进行流控，也就是 @SentinelResource进行流控，则会进入blockHandler，可见，只有对 @SentinelResource 的value进行流控，才生效，而对这个路径地址url进行设置，则会直接进入系统默认的处理方法

上述兜底方案面临的问题

问题：1.系统默认的，没有体现我们自己的业务要求

2. 依照现在的条件，自定义的处理方法和业务代码耦合到一块，不直观
		3. 每个业务方法都添加一个兜底的，那代码膨胀加剧
		4. 全局统一的处理方法没有体现。

客户自定义限流处理逻辑

创建CustomerBlockHandler类用于自定义限流处理逻辑 (解决耦合问题)

自定义限流处理类

a)创建CoustomerBlockHandler

public class CustomerBlockHandler {
    public static CommonResult handlerException(BlockException exception) {
        return new CommonResult(444,"按客户自定义,global handlerException----1");
    }
    public static CommonResult handlerException2(BlockException exception) {
        return new CommonResult(404,"按客户自定义，global handlerException ------2");
    }
}

RateLimitController

@GetMapping("/rateLimit/customerBlockHandler")
@SentinelResource(value = "customerBlockHandler",
        blockHandlerClass = CustomerBlockHandler.class,  //指定客户自定义的兜底方法流泪
        blockHandler = "handlerException2")    //指定具体的客户自定义方法
public CommonResult customerBlockHandler() {
    return new CommonResult(200,"按客户自定义",new Payment(2021L,"serial003"));
}

启动微服务后先调用一次 ,返回前台

{“code”:200,“message”:“按客户自定义”,“data”:{“id”:2021,“serial”:“serial003”}}

Sentinel控制台配置

这里是对 customerBlockHandler 进行流控，没有左斜杠

阈值设置为 1 进行测试

测试后我们自定义的出来了

{“code”:404,“message”:“按客户自定义，global handlerException ------2”,“data”:null}

进一步说明

blockHandlerClass 配置的为处理类的信息，blockHandler 配置的是具体的某个处理方法的名字

其实也可以用代码来解决，但是侵入性强，这里不介绍

服务熔断功能

sentinel整合ribbon + openFeign + fallback

Sentinel服务熔断Ribbon环境

Ribbon系列

a)启动nacos和sentinel

b)提供者9003/9004

新建cloudalibaba-provider-payment9003/9004两个一样的做法

POM

<dependencies>

    <!--SpringCloud alibaba nacos-->
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>

    <!--SpringBoot整合Web组件-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>

</dependencies>

YML

server:
  port: 9003

spring:
  application:
    name: nacos-payment-provider
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #配置nacos地址

management:
  endpoints:
    web:
      exposure:
        include: '*'

主启动类

@SpringBootApplication
@EnableDiscoveryClient
public class PaymentMain9003 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentMain9003.class, args);
    }
}

业务类

@RestController
public class PaymentController {

    @Value("${server.port}")
    private String serverPort;

    public static HashMap<Long, Payment> hashMap = new HashMap<>();

    static {
        hashMap.put(1L, new Payment(1L,"28a8c1e3bc2742d8848569891fb42181"));
        hashMap.put(2L, new Payment(2L,"BBA8C133bc2742d8848569891ac32182"));
        hashMap.put(3L, new Payment(3L,"6ua8c1e3bc2743d8848569891xt92183"));
    }

    @GetMapping(value = "/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id) {
        Payment payment = hashMap.get(id);
        CommonResult<Payment> result = new CommonResult(200, "from mysql,serverPort: " + serverPort, payment);
        return result;
    }

}

测试地址： http://localhost:9003/paymentSQL/1

c)消费者84

新建cloudalibaba-consumer-nacos-order84

POM

<dependencies>

        <!--SpringCloud alibaba nacos-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>

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

        <dependency>
            <groupId>com.huawei.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>

        <!--SpringBoot整合Web组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

YML

server:
  port: 84

spring:
  application:
    name: nacow-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        # 配置Sentinel dashboard地址
    dashboard: localhost:8080
        # 默认8719端口，假如被占用会自动从8719开始扫描，直至找到未被占用的端口
    port: 8719

# 消费者将要去访问的微服务名称（注册成功进nacos的微服务提供者）
service-url:
  nacos-user-service: http://nacos-payment-provider

主启动

@EnableDiscoveryClient
@SpringBootApplication
public class OrderNacosMain84 {
    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain84.class, args);
    }

}

业务类

config:

@Configuration
public class ApplicationContextConfig {

    @Bean
    @LoadBalanced
    public RestTemplate getRestTemplate() {
        return new RestTemplate();
    }

}

上面的都和83差不多，代码比较常见

下面的是重点：

CircleBreakerController

@RestController
@Slf4j
public class CircleBreakerController {

    public static final String SERVICE_URL = "http://nacos-payment-provider";

    @Resource
    private RestTemplate restTemplate;

    @RequestMapping("/consumer/fallback/{id}")
    @SentinelResource(value = "fallback") //没有配置
    public CommonResult<Payment> fallback(@PathVariable Long id) {

        CommonResult result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/" + id, CommonResult.class, id);

        if (id == 4) {
            throw new IllegalArgumentException("IllegalArgumentException,非法参数异常。。。。");
        }else if ( result.getData() == null ) {
            throw new NullPointerException("NullPointerException,该ID没有对应记录，空指针异常");
        }

        return result;
    }

}

后续操作：

修改后请重启微服务：对@SentinelResource注解内属性有时效性

目的： fallback管运行异常

blockHandler管配置违规

Sentile服务熔断无配置

接上面：进行测试，

测试地址： http://localhost:84/consumer/fallback/1

结果，出现轮询了

{"code":200,"message":"from mysql,serverPort: 9003","data":{"id":1,"serial":"28a8c1e3bc2742d8848569891fb42181"}}

9003和9004实现了轮询

登录Sentinel ,登录Nacos，都成功了，都能发现服务。

测试：当发送请求带的参数变成 4 ,即 http://localhost:84/consumer/fallback/4

按照 if (id == 4) {

throw new IllegalArgumentException(“IllegalArgumentException,非法参数异常。。。。”);

这段代码，系统抛出了异常

而且返回前台的是error页面，非常不友好，现在，我们需要进行配置，

服务熔断只配置fallback

根据上面的进行改进，需要对报的错误进行处理了，不让返回error页面

@RequestMapping("/consumer/fallback/{id}")
//    @SentinelResource(value = "fallback") //没有配置
    @SentinelResource(value = "fallback",fallback = "handlerFallback") //fallback只负责业务异常
    public CommonResult<Payment> fallback(@PathVariable Long id) {

        CommonResult result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/" + id, CommonResult.class, id);

        if (id == 4) {
            throw new IllegalArgumentException("IllegalArgumentException,非法参数异常。。。。");
        }else if ( result.getData() == null ) {
            throw new NullPointerException("NullPointerException,该ID没有对应记录，空指针异常");
        }

        return result;
    }

    //本例是fallback
    public CommonResult handlerFallback(@PathVariable Long id,Throwable e) {
        Payment payment = new Payment(id, "null");
        return new CommonResult<>(444,"兜底异常handlerFallback,exception内容 " + e.getMessage(),payment);
    }

启动后再次访问：http://localhost:84/consumer/fallback/4

返回结果

{"code":444,"message":"兜底异常handlerFallback,exception内容 IllegalArgumentException,非法参数异常。。。。","data":{"id":4,"serial":"null"}}

这样就有个兜底方法了，比报错误页面好多了

服务熔断只配置blockHandler

代码改进

@RequestMapping("/consumer/fallback/{id}")
//    @SentinelResource(value = "fallback") //没有配置
//    @SentinelResource(value = "fallback",fallback = "handlerFallback") //fallback只负责业务异常
    @SentinelResource(value = "fallback",blockHandler = "blockHandler")//blockHandler只负责sentinel只负责sentinel控制台配置违规
    public CommonResult<Payment> fallback(@PathVariable Long id) {

        CommonResult result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/" + id, CommonResult.class, id);

        if (id == 4) {
            throw new IllegalArgumentException("IllegalArgumentException,非法参数异常。。。。");
        }else if ( result.getData() == null ) {
            throw new NullPointerException("NullPointerException,该ID没有对应记录，空指针异常");
        }

        return result;
    }

    //本例是blockHandler
    public CommonResult blockHandler(@PathVariable Long id, BlockException blockException) {
        Payment payment = new Payment(id, "null");
        return new CommonResult<>(445,"blockHandler-sentinel限流，无此流水：blockException " + blockException.getMessage(),payment);
    }

由于配置了sentinel,所以需要sentinel重新配置，对fallback进行配置，阈值为2，然后，第一次访问

http://localhost:84/consumer/fallback/4

依然报错，快速点击两次达到阈值，然后点击，发现

{"code":445,"message":"blockHandler-sentinel限流，无此流水：blockException null","data":{"id":4,"serial":"null"}}

思考这个和上个的配置的区别，效果有啥不同

第二个只负责业务的异常，业务出异常就触发，第三个则是当达到sentinel配置的违规时才触发。

fallback和blockHandler都配置

@RequestMapping("/consumer/fallback/{id}")
//    @SentinelResource(value = "fallback") //没有配置
//    @SentinelResource(value = "fallback",fallback = "handlerFallback") //fallback只负责业务异常
//    @SentinelResource(value = "fallback",blockHandler = "blockHandler")//blockHandler只负责sentinel只负责sentinel控制台配置违规
    @SentinelResource(value = "fallback",fallback = "handlerFallback",blockHandler = "blockHandler") //两个都配，谁生效？
    public CommonResult<Payment> fallback(@PathVariable Long id) {

        CommonResult result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/" + id, CommonResult.class, id);

        if (id == 4) {
            throw new IllegalArgumentException("IllegalArgumentException,非法参数异常。。。。");
        }else if ( result.getData() == null ) {
            throw new NullPointerException("NullPointerException,该ID没有对应记录，空指针异常");
        }

        return result;
    }

    //本例是blockHandler
    public CommonResult blockHandler(@PathVariable Long id, BlockException blockException) {
        Payment payment = new Payment(id, "null");
        return new CommonResult<>(445,"blockHandler-sentinel限流，无此流水：blockException " + blockException.getMessage(),payment);
    }

    //本例是fallback
    public CommonResult handlerFallback(@PathVariable Long id,Throwable e) {
        Payment payment = new Payment(id, "null");
        return new CommonResult<>(444,"兜底异常handlerFallback,exception内容 " + e.getMessage(),payment);
    }

sentinel不配置时候，触发的是fallback

{"code":444,"message":"兜底异常handlerFallback,exception内容 IllegalArgumentException,非法参数异常。。。。","data":{"id":4,"serial":"null"}}

对sentinel进行配置，配置sentinel 中fallback 阈值为2，点击一次还是上面那个fallback，但是达到阈值后，就触发blockHandler,即，被限流降级而抛出了 BlockException时，只会进入blockHandler的处理逻辑。

{"code":445,"message":"blockHandler-sentinel限流，无此流水：blockException null","data":{"id":4,"serial":"null"}}

服务熔断exceptionsToIgnore

异常忽略

在上面例子上加以改造

再次访问：http://localhost:84/consumer/fallback/4

看看会不会触发fallback

结果：直接将非法参数异常打印给了前台，也就是说，配置Ignore后，再次出现这个异常，将不会走fallback

服务熔断OpenFeign

Feign系列

修改84模块： 84消费者调用提供者9003 Feign组件一般是消费侧

POM

添加：OpenFeign依赖 8401的OpenFeign依赖一开始创建时就加了

<!--SpringCloud openfeign-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

YML

# 激活Sentinel对Feign的支持
feign:
  sentinel:
    enabled: true

业务类

带@FeignClient注解的业务接口

@FeignClient(value = "nacos-payment-provider",fallback = PaymentFallbackService.class)
public interface PaymentService {
    @GetMapping(value= "/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id);
}

fallback = PaymentFallbackService.class

@Component
public class PaymentFallbackService implements PaymentService {

    @Override
    public CommonResult<Payment> paymentSQL(Long id) {
        return new CommonResult<>(444,"服务降级返回，----PaymentFallbackService",new Payment(id,"serialError"));
    }
}

Controller

//----------OpenFeign
    @Resource
    private PaymentService paymentService;

    @GetMapping(value = "/consumer/paymentSQL/{id}")
    public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id) {
        return paymentService.paymentSQL(id);
    }

主启动

@EnableDiscoveryClient
@EnableFeignClients
@SpringBootApplication
public class OrderNacosMain84 {
    public static void main(String[] args) {
        SpringApplication.run(OrderNacosMain84.class, args);
    }

}

开始测试时，一直都是直接服务降级，后来发现是主启动类没有加 @EnableFeignClients

测试：http://localhost:84/consumer/paymentSQL/1

{"code":200,"message":"from mysql,serverPort: 9003","data":{"id":1,"serial":"28a8c1e3bc2742d8848569891fb42181"}}

测试84调用9003，此时故意关闭9003微服务提供者，看84消费侧自动降级

{"code":444,"message":"服务降级返回，----PaymentFallbackService","data":{"id":1,"serial":"serialError"}}

服务降级，可以和Hystrix比较下

规则持久化

之前的遗留问题，8401每次重启都要重新设置Sentinel流控规则

临时/持久？

生产环境需要将配置规则持久化

怎么玩？

将限流配置规则持久化进Nacos保存，只要刷新8401某个rest地址，sentinel控制台的流控规则就能看到，只要Nacos里面的配置不删除，针对8401上sentinel的流控规则持续有效

为啥可以，因为Nacos = eureka + config + bus

开始操作

a) 修改cloudalibaba-sentinel-service8401

b)POM

<!--SpringCloud alibaba sentinel - datasource-nacos  后续做持久化用到-->
<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

C)YML

spring:
  application:
    name: cloudalibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        #Nacos服务注册中心地址
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描，直至找到未被占用的端口
        port: 8719
        # 以下为该功能需要的
        datasource:
          ds1:
            nacos:
              server-addr: localhost:8848
              dataId: cloudalibaba-sentinel-service #就是application.name
              groupId: DEFAULT_GROUP
              data-type: json
              rule-type: flow

d) 添加Nacos业务规则配置

配置列表点 + 号：

内容解析

Data Id : 就写dataId

配置格式选 json

[
    {
        "resource": "/rateLimit/byUrl",
        "limitApp": "default",
        "grade": 1,
        "count": 1,
        "strategy": 0,
        "controlBehavior": 0,
        "clusterMode": false
    }
]

解释：

resource: 资源名称；

limitApp: 来源应用;

grade: 阈值类型，0表示线程数，1表示QPS;

count: 单机阈值;

stratgy: 流控模式，0表示直接，1表示关联，2表示链路；

controlBehavior: 流控效果，0表示快速失败，1表示Warm Up, 2表示排队等待；

clusterMode: 是否集群。

发布保存

在sentinel的cloudalibaba-sentinel-service 即8401 里设置/rateLimit/byUrl的流控

e) 启动8401后刷新sentinel发现业务规则有了

快速访问测试接口：localhost:8401/rateLimit/byUrl 发现被限流

测试能否将设置的规则持久化：停止8401再看sentinel 没有

重新启动8401，再次访问localhost:8401/rateLimit/byUrl ，再看看sentinel，发现规则仍在，证明规则被持久化了。

SpringCloud Alibaba 之SentinelSpringCloud Alibaba 之SentinelSentinel是什么安装Sentinel控制台初始化演示工程流控规则流控效果降级规则热点key限流系统规则@SentinelResource配置服务熔断功能规则持久化