Sentinel之服务熔断与限流

一. Sentine是什么?

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

二. Sentinel 具有的特征

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

三. Sentinel 的主要特性

四. Sentinel的开源生态

五. Sentinel与Hystrix的对比

Hystrix:

• 需要我们开发者自己手工搭建监控平台
• 没有一套web界面可以给我们进行更加细粒度化的配置流控、速率控制、服务熔断、服务降级…

Sentinel :

• 单独一个组件，可以独立出来。
• 直接界面化的细粒度统一配置。

六. 下载:

1.通过下载地址下载Sentinel

#本次以1.7举例说明:
https://github.com/alibaba/Sentinel/releases/download/1.7.0/sentinel-dashboard-1.7.0.jar

Sentinel 分为两个部分:

• 核心库（Java 客户端）不依赖任何框架/库，能够运行于所有 Java 运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。
• 控制台（Dashboard）基于 Spring Boot 开发，打包后可以直接运行，不需要额外的 Tomcat 等应用容器。

2. 运行我们刚才下载的jar包

java -jar sentinel-dashboard-1.7.0.jar

3.访问

//账号密码默认为sentinel
http://localhost:8080/#/dashboard    

七. 初体验Sentinel

1. 新建cloud-alibaba-sentinel-service8401工程

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2020artifactId>
        <groupId>com.fastgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloudalibaba-sentinel-service8401artifactId>

    <dependencies>
        <dependency>
            <groupId>com.fastgroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>${project.version}version>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cspgroupId>
            <artifactId>sentinel-datasource-nacosartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-openfeignartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>cn.hutoolgroupId>
            <artifactId>hutool-allartifactId>
            <version>4.6.3version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

    dependencies>

project>

2. 编写application.yml配置文件:

server:
  port: 8401

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

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

3. 创建启动类:

@SpringBootApplication
@EnableDiscoveryClient
public class MainApp8401 {
     

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

4. 编写业务类:

@RestController
@Slf4j
public class FlowLimitController
{
     
    @GetMapping("/testA")
    public String testA()
    {
     
        return "------testA";
    }

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

5. 启动8401查看sentienl控制台:

我们会发现,空空如也,这是因为sentienl采用懒加载,需要我们执行一次访问:

http://localhost:8401//testA

http://localhost:8401//testB

此时,我们就可以看到我们的服务了.

八. 流控规则

1. 流控规则属性

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

2. 创建QPS流控规则

⑴. 点击新建按钮

⑵. 编辑流控规则

QPS:每秒访问次数,这里我们设定的值为1,即每秒只能有一个访问.

⑶. 测试

当我们超过了限定的次数,即每秒访问多次,前台会给出报错提示:

3. 创建线程流控规则

⑴. 修改业务代码

    @GetMapping("/testA")
    public String testA()
    {
     
        try {
     
        	//我们让每个线程进来之后休眠5秒.
            TimeUnit.MILLISECONDS.sleep(5000);
        } catch (InterruptedException e) {
     
            e.printStackTrace();
        }
        return "------testA";
    }

⑵. 编辑流控规则

⑶. 测试

同时开两个浏览器窗口,都访问http://localhost:8401//testA

当线程休眠的时候,其他线程进来访问,会超过我们所规定的限制,前台报错.

关联:

当关联的资源达到阈值时，就限流自己,比如:当与A关联的资源B达到阀值后，就限流A自己

采用postman来模拟多次访问:

这时候访问A:

4. 创建链路流控规则

⑴. 我们打开簇点链路查看调用链路:

我们发现在sentinel_web_servlet_context节点下有两个节点,/testA和/testA/testC.

⑵. 创建流控规则

如果想对这条链路限流,我们只需要对sentinel_web_servlet_context这个父节点进行限制,那么/testA一样会被限制.

⑶. 测试:

九. 流控效果之Warm Up

1. 什么是Warm Up:

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

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

2. 设定:

默认coldFactor为3，即请求QPS从单击阈值/ 3开始，经预热时长逐渐升至设定的QPS阈值。

也就是说,我们首先设定的单击阈值为9,9/3=3,初始单击阈值为3.经过5秒预热时长,逐渐上升至单击阈值至9.

3. 测试:

访问http://localhost:8401/testA

快速访问此链接,前几次我们发现,系统会报异常,因为初始的阈值为3,但是经过5秒预热过后,系统能够承受9次并发.

十. 流控效果之排队等待:

1. 什么是排队等待?

排队等待（RuleConstant.CONTROL_BEHAVIOR_RATE_LIMITER）方式会严格控制请求通过的间隔时间，也即是让请求以均匀的速度通过，对应的是漏桶算法。它的中心思想是，以固定的间隔时间让请求通过。当请求到来的时候，如果当前请求距离上个通过的请求通过的时间间隔不小于预设值，则让当前请求通过；否则，计算当前请求的预期通过时间，如果该请求的预期通过时间小于规则预设的 timeout 时间，则该请求会等待直到预设时间到来通过（排队等待处理）；若预期的通过时间超出最大排队时长，则直接拒接这个请求。

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

2. 配置:

3. 测试:

当你每隔一秒匀速访问的时候,都是没问题的,

但是如果你在postman运行的同时,打开浏览器进行访问,就会出错.

十一. 熔断降级:

除了流量控制以外，对调用链路中不稳定的资源进行熔断降级也是保障高可用的重要措施之一。一个服务常常会调用别的模块，可能是另外的一个远程服务、数据库，或者第三方 API 等。例如，支付的时候，可能需要远程调用银联提供的 API；查询某个商品的价格，可能需要进行数据库查询。然而，这个被依赖服务的稳定性是不能保证的。如果依赖的服务出现了不稳定的情况，请求的响应时间变长，那么调用服务的方法的响应时间也会变长，线程会产生堆积，最终可能耗尽业务自身的线程池，服务本身也变得不可用。

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

1. 降级规则:

熔断降级规则包含下面几个重要的属性：

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

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

• 平均响应时间 (DEGRADE_GRADE_RT)：当资源的平均响应时间超过阈值（DegradeRule 中的 count，以 ms 为单位）之后，资源进入准降级状态。接下来如果持续进入 5 个请求，它们的 RT 都持续超过这个阈值，那么在接下的时间窗口（DegradeRule 中的 timeWindow，以 s 为单位）之内，对这个方法的调用都会自动地返回（抛出 DegradeException）。在下一个时间窗口到来时, 会接着再放入5个请求, 再重复上面的判断.
• 异常比例 (ERROR_RATIO)：当单位统计时长（statIntervalMs）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 [0.0, 1.0]，代表 0% - 100%。
• 异常数 (ERROR_COUNT)：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。

3. 平均响应时间

首先我们来看第一个,RT,即平均响应时间:

平均响应时间 (DEGRADE_GRADE_RT)：当 1s 内持续进入 N 个请求，对应时刻的平均响应时间（秒级）均超过阈值（count，以 ms 为单位），那么在接下的时间窗口（DegradeRule 中的 timeWindow，以 s 为单位）之内，对这个方法的调用都会自动地熔断（抛出 DegradeException）。注意 Sentinel 默认统计的 RT 上限是 4900 ms，超出此阈值的都会算作 4900 ms，若需要变更此上限可以通过启动配置项 -Dcsp.sentinel.statistic.max.rt=xxx 来配置。

⑴. 修改业务代码:

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

⑵. 配置:

⑶. 创建压力测试:

⑶. 启动压力测试

访问http://localhost:8401/testD

我们在业务中,让线程睡眠一秒钟,并设置为平均响应时间为200毫秒,在Jmeter压力测试工具中,一秒钟十个线程,大于五个请求,且每个请求处理时间都超过了一秒(线程休眠),至此,断路器断开.

4. 异常比例:

⑴. 修改业务代码:

    @GetMapping("/testD")
    public String testD()
    {
     
        log.info("testD 异常比例");
        int age = 10/0;
        return "------testD";
    }

⑵. 配置

⑶. 启动压测,访问查看效果:

5. 异常数:

⑴. 配置:

⑵. 启动测试:

前几次会报 by zero错误,但是在世界窗口期内,异常数到了阈值,就会抛Blocked by Sentinel (flow limiting)异常.

6. 热点参数限流:

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

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

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

⑴. 点击热点规则按钮

⑵. 配置:

⑶. 编写业务代码:

    @GetMapping("/testHotKey")
    //value 相当于唯一标识,blockHandler兜底方法,如果违背了热点参数限流,则执行我们设定的方法
    @SentinelResource(value = "testHotKey",blockHandler = "deal_testHotKey")
    public String testHotKey(@RequestParam(value = "p1",required = false) String p1,
                             @RequestParam(value = "p2",required = false) String p2)
    {
     
        return "------testHotKey";
    }

    //该方法与需要熔断的方法参数一致即可,只不过多出一个BlockException参数.
    public String deal_testHotKey (String p1, String p2, BlockException exception)
    {
     
        return "------deal_testHotKey,触发热点参数限流";  //sentinel系统默认的提示：Blocked by Sentinel (flow limiting)
    }

}

⑷. 配置说明

资源名,即我们在代码中定义的@SentinelResource(value = "testHotKey"),参数索引0即public String testHotKey( String p1, String p2) 中第一个参数,p1

⑸. 访问测试:

⑹. 如果不配置兜底方法会如何?

修改业务代码:

@SentinelResource(value = "testHotKey")

测试:

7. 参数例外项:

⑴. 什么是参数例外项?

现在有这样一个需求,我们期望p1参数当它是某个特殊值时，它的限流值和平时不一样,比如当p1的值等于5时，它的阈值可以达到200

⑵. 配置

⑶. 访问测试

http://localhost:8401/testHotKey?p1=5

当p1=5的时候,不会被热点参数给限制.

⑷. 如果我们加个异常信息会怎么样?

    @GetMapping("/testHotKey")
    @SentinelResource(value = "testHotKey")
    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)
    {
     
        //省略代码...
    }

⑸. 运行测试

⑹. 分析:

@SentinelResource:处理的是Sentinel控制台配置的违规情况，有blockHandler方法配置的兜底处理;
RuntimeException: int age = 10/0,这个是java运行时报出的运行时异常RunT imeException, @SentinelResource不负责
总结:
@Sent inelResource主负责配置出错，运行出错该走异常走异常

8. 系统自适应限流:

⑴. 什么是系统自适应限流?

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

系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量生效。入口流量指的是进入应用的流量（EntryType.IN），比如 Web 服务或 Dubbo 服务端接收的请求，都属于入口流量。

系统规则支持以下的模式：

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

⑵. 配置全局QPS:

⑶. 访问测试

http://localhost:8401/testB  
http://localhost:8401/testA 

⑷. 修改RateLimitController:

@RestController
public class RateLimitController
{
     
    @GetMapping("/byResource")
    @SentinelResource(value = "byResource",blockHandler = "handleException")
    public CommonResult byResource()
    {
     
        return new CommonResult(200,"按资源名称限流测试OK",new Payment(2020L,"serial001"));
    }
    public CommonResult handleException(BlockException exception)
    {
     
        return new CommonResult(444,exception.getClass().getCanonicalName()+"\t 服务不可用");
    }
}

⑸. 按照资源名称+后续处理配置流控规则:

①. 新建规则

②.访问测试

 http://localhost:8401/byResource 

多次点击刷新,查看页面效果:

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

①. 修改代码

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

②. 创建配置

②.访问测试

 http://localhost:8401/rateLimit/byUrl 

⑺. 上面兜底方案面临的问题:

• 系统默认的，没有体现我们自的业务要求。
• 依照现有条件，我们自定义的处理方法又和业务代码耦合在一块,不直观。
• 每个业务方法都添加一个兜底的，那代码膨胀加剧。
  全局统一的处理方法没有体现。

9. 自定义限流处理逻辑:

⑴. 创建CustomerBlockHandler用于自定义限流处理逻辑:

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

⑵. 创建RateLimitController:

@RestController
public class RateLimitController
{
     
    //blockHandlerClass = CustomerBlockHandler.class  自定义限流处理类,blockHandler = "handlerException2"该类中的哪个方法兜底
    @GetMapping("/rateLimit/customerBlockHandler")
    @SentinelResource(value = "customerBlockHandler",
            blockHandlerClass = CustomerBlockHandler.class,
            blockHandler = "handlerException2")
    public CommonResult customerBlockHandler()
    {
     
        return new CommonResult(200,"按用户自定义",new Payment(2020L,"serial003"));
    }
}

⑶. 新增流控规则:

⑷. 多次访问链接测试

http://localhost:8401/rateLimit/customerBlockHandler 

10. @SentinelResource介绍

注意：注解方式埋点不支持 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 逻辑中，而是会原样抛出。

11. ribbon集成服务熔断功能:

⑴. 创建工程

创建cloudalibaba-provider-payment9003,cloudalibaba-provider-payment9004两个工程.

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2020artifactId>
        <groupId>com.fastgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>\cloudalibaba-provider-payment9003artifactId>

    <dependencies>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
        <dependency>
            <groupId>com.fastgroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>
project>

⑵. 配置文件:

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,"bba8c1e3bc2742d8848569891ac32182"));
        hashMap.put(3L,new Payment(3L,"6ua8c1e3bc2742d8848569891xt92183"));
    }

    @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;
    }

}

测试访问正常.

⑸. 新建cloudalibaba-consumer-nacos-order84工程:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>cloud2020artifactId>
        <groupId>com.fastgroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>cloudalibaba-consumer-nacos-order84artifactId>

    <dependencies>
        
        <dependency>
            <groupId>org.springframework.cloudgroupId>
            <artifactId>spring-cloud-starter-openfeignartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
        dependency>
        
        <dependency>
            <groupId>com.alibaba.cloudgroupId>
            <artifactId>spring-cloud-starter-alibaba-sentinelartifactId>
        dependency>
        
        <dependency>
            <groupId>com.fastgroupId>
            <artifactId>cloud-api-commonsartifactId>
            <version>1.0-SNAPSHOTversion>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-actuatorartifactId>
        dependency>
        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-devtoolsartifactId>
            <scope>runtimescope>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <optional>trueoptional>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
    dependencies>
project>

⑹. 配置文件:

server:
  port: 84


spring:
  application:
    name: nacos-order-consumer
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
    sentinel:
      transport:
        #配置Sentinel dashboard地址
        dashboard: localhost:8080
        #默认8719端口，假如被占用会自动从8719开始依次+1扫描,直至找到未被占用的端口
        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);
    }
}

⑻. RestTemplate配置类:

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

⑼. 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<Payment> 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(value = “fallback”)定义了一个相当于名字的东西,没有做限流等配置,这样的话,如果代码出错,会直接跳转Error Page页面:

⑾. 只配置fallback:

@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",fallback = "handlerFallback") //fallback只负责业务异常
    public CommonResult<Payment> fallback(@PathVariable Long id)
    {
     
        CommonResult<Payment> 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/5
或者
http://localhost:84/consumer/fallback/4

结论:fallback管运行异常

⑿. 只配置blockHandler:

@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",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
    public CommonResult<Payment> fallback(@PathVariable Long id)
    {
     
        CommonResult<Payment> 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);
    }
}

配置降级规则:

访问测试:

当在时间窗口期内,只有一个异常,就会跳转Error Page页面,但是如果在时间窗口期内,超过了我们指定的异常次数,就会走我们定义的方法.

总结:blockHandler管配置违规

⒀. fallback和blockHandler都配置:

我们通过刚才的示例了解到,fallback管运行异常,blockHandler管配置违规.那如果我们两个都配置了呢?

@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",fallback = "handlerFallback",blockHandler = "blockHandler")
    public CommonResult<Payment> fallback(@PathVariable Long id)
    {
     
        CommonResult<Payment> 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);
    }
    //本例是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进行处理,如果QPS高于1,但是又会发生运行时异常的时候,blockHandler会生效.

**结论:**若blockHandler和fallback都进行了配置， 则被限流降级而抛出BlockException时只会进入blockHandler处理逻辑。

忽略属性:

由exceptionsToIgnore = {IllegalArgumentException.class}配置.代码如下:

@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",fallback = "handlerFallback",blockHandler = "blockHandler",
            exceptionsToIgnore = {
     IllegalArgumentException.class})
    public CommonResult<Payment> fallback(@PathVariable Long id)
    {
     
        CommonResult<Payment> 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);
    }
    //本例是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);
    }

}

12. 整合feign:

⑴. 修改配置文件:

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

⑵. 修改主启动类:

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

⑶. 创建PaymentService:

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

⑷. 创建PaymentFallbackService:

//兜底方法
@Component
public class PaymentFallbackService implements PaymentService
{
     
    @Override
    public CommonResult<Payment> paymentSQL(Long id)
    {
     
        return new CommonResult<>(44444,"服务降级返回,---PaymentFallbackService",new Payment(id,"errorSerial"));
    }
}

⑸. Controller:

@RestController
@Slf4j
public class CircleBreakerController
{
     
    @Resource
    private PaymentService paymentService;

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

⑹. 测试访问

http://localhost:84/consumer/paymentSQL/1 :

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

13. 持久化规则:

⑴. 为什么要做持久化?

一旦我们重启应用，sentinel规则将消失， 生产环境需要将配置规则进行持久化

⑵. 怎么做?

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

⑶. 修改cloudalibaba-sentinel-service8401工程:

<dependency>
    <groupId>com.alibaba.cspgroupId>
    <artifactId>sentinel-datasource-nacosartifactId>
dependency>

⑷. 添加Nacos数据源配置:

server:
  port: 8401

spring:
  application:
    name: cloudalibaba-sentinel-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848 #Nacos服务注册中心地址
    sentinel:
      transport:
        dashboard: localhost:8080 #配置Sentinel dashboard地址
        port: 8719
      datasource: #添加Nacos数据源配置
        ds1:
          nacos:
            server-addr: localhost:8848  #Nacos地址
            dataId: cloudalibaba-sentinel-service #服务名
            groupId: DEFAULT_GROUP #分组
            data-type: json
            rule-type: flow

⑸. 添加Nacos业务规则配置:

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

⑹. 参数说明:

• resource: 资源名称
• limitApp: 来源应用
• grade: 阈值类型，0 为线程数，1 为 QPS
• count: 单机阈值
• strategy: 流控模式，0 为直接，1 为关联，2 为链路
• controlBehavior: 流控效果，0 为快速失败，1 为 Warm Up，2 为排队等待
• clusterMode: 是否为集群

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

ps:sentienl采用懒加载,需要我们执行一次访问

⑺. 测试规则是否生效:

http://localhost:8401/rateLimit/byUrl