qidao123.com ToB IT社区-企服评测·应用市场»论坛 › 大数据 › 数据仓库与分析 › 03-13、SpringCloud Alibaba第十三章，升级篇，服务降级 ...

03-13、SpringCloud Alibaba第十三章，升级篇，服务降级、熔断和限流Sentinel

[复制链接]
发表于 2025-12-13 01:39:52 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

×
SpringCloud Alibaba第十三章，升级篇，服务降级、熔断和限流Sentinel
一、Sentinel概述

1、Sentinel是什么
  1. 随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。
  3. 一句话概括：sentinel即Hystrix的替代品
  5. 官网： https://sentinelguard.io/zh-cn/
  7. 下载：https://github.com/alibaba/Sentinel/releases
复制代码

2、Sentinel根本概念

2.1、资源：
  1. 资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，例如，由应用程序提供的服务，或由应用程序调
  2. 用的其它应用提供的服务，甚至可以是一段代码。在接下来的文档中，我们都会用资源来描述代码块。
  4. 只要通过 Sentinel API 定义的代码，就是资源，能够被 Sentinel 保护起来。大部分情况下，可以使用方法签名，
  5. URL，甚至服务名称作为资源名来标示资源。
复制代码
2.2、规则：
  1. 围绕资源的实时状态设定的规则，可以包括流量控制规则、熔断降级规则以及系统保护规则。所有规则可以动态实时调整。
复制代码
2.3、流量控制：
  1. 流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。然而，从系统稳定性角度考虑，在处理请求的速度
  2. 上，也有非常多的讲究。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能
  3. 力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状.
  5. 流量控制有一下几个角度：
  6. 1、资源的调用关系，例如资源的调用链路，资源和资源之间的关系；
  7. 2、运行指标，例如 QPS、线程池、系统负载等；
  8. 3、控制的效果，例如直接限流、冷启动、排队等。
复制代码
2.4、熔断降级：
  1. 降低调用链路中的不稳定资源也是 Sentinel 的使命之一。由于调用关系的复杂性，如果调用链路中的某个资源出现了不稳
  2. 定，最终会导致请求发生堆积。这个问题和 Hystrix 里面描述的问题是一样的。
  4. Sentinel 和 Hystrix 的原则是一致的: 当调用链路中某个资源出现不稳定，例如，表现为 timeout，异常比例升高的
  5. 时候，则对这个资源的调用进行限制，并让请求快速失败，避免影响到其它的资源，最终产生雪崩的效果。
  7. Sentinel和Hystrix在限制手段上，采取了不一样的方法：
  9. 1、Hystrix通过线程池的方式：
  10. Hystrix 通过线程池的方式，来对依赖进行了隔离。
  12. 2、Sentinel 对这个问题采取了两种手段:
  13. a、通过并发线程数进行限制
  14. b、通过响应时间对资源进行降级
复制代码
2.5、体系负载掩护：
  1. Sentinel 同时对系统的维度提供保护。防止雪崩，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求
  2. 进入，可能会导致系统崩溃，无法响应。在集群环境下，网络负载均衡会把本应这台机器承载的流量转发到其它的机器上去。
  3. 如果这个时候其它的机器也处在一个边缘状态的时候，这个增加的流量就会导致这台机器也崩溃，最后导致整个集群不可用。
  5. 针对这个情况，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之
  6. 内处理最多的请求。
复制代码
二、Sentinel控制台安装
  1. Sentinel分为两个部分：
  2. 1、核心库
  3. 2、控制台dashboard，基于Springboot开发，打包后可直接运行，不需要Tomcat等额外的容器
复制代码
下载：
  1. https://github.com/alibaba/Sentinel/releases
复制代码
运行：
  1. Sentinel Dashboard默认的端口是8080
  3. java -jar sentinel-dashboard-1.7.0.jar
复制代码
访问：
  1. http://localhost:8080/
  3. 账号：sentinel  密码：sentinel
复制代码
三、Sentinel案例

3.1、初始化演示工程

创建cloudalibaba-sentinel-service-8401
  1. <parent>
  2.     <artifactId>cloud_2020</artifactId>
  3.     <groupId>com.lee.springcloud</groupId>
  4.     <version>1.0-SNAPSHOT</version>
  5. </parent>
  6. <modelVersion>4.0.0</modelVersion>
  8. <artifactId>cloudalibaba-sentinel-service-8401</artifactId>
复制代码
POM
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud_2020</artifactId>
  7.         <groupId>com.lee.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloudalibaba-sentinel-service-8401</artifactId>
  14.     <dependencies>
  16.         <!--SpringCloud ailibaba sentinel-datasource-nacos 后续做持久化用到-->
  17.         <dependency>
  18.             <groupId>com.alibaba.csp</groupId>
  19.             <artifactId>sentinel-datasource-nacos</artifactId>
  20.         </dependency>
  21.         <!--SpringCloud ailibaba sentinel -->
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  25.         </dependency>
  27.         <!--SpringCloud ailibaba nacos -->
  28.         <dependency>
  29.             <groupId>com.alibaba.cloud</groupId>
  30.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  31.         </dependency>
  33.         <dependency>
  34.             <groupId>com.lee.springcloud</groupId>
  35.             <artifactId>cloud-api-commons</artifactId>
  36.             <version>${project.version}</version>
  37.         </dependency>
  38.         <!--openfeign-->
  39.         <dependency>
  40.             <groupId>org.springframework.cloud</groupId>
  41.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  42.         </dependency>
  43.         <!-- SpringBoot整合Web组件+actuator -->
  44.         <dependency>
  45.             <groupId>org.springframework.boot</groupId>
  46.             <artifactId>spring-boot-starter-web</artifactId>
  47.         </dependency>
  48.         <dependency>
  49.             <groupId>org.springframework.boot</groupId>
  50.             <artifactId>spring-boot-starter-actuator</artifactId>
  51.         </dependency>
  52.         <!--日常通用jar包配置-->
  53.         <dependency>
  54.             <groupId>org.springframework.boot</groupId>
  55.             <artifactId>spring-boot-devtools</artifactId>
  56.             <scope>runtime</scope>
  57.             <optional>true</optional>
  58.         </dependency>
  59.         <dependency>
  60.             <groupId>cn.hutool</groupId>
  61.             <artifactId>hutool-all</artifactId>
  62.             <version>4.6.3</version>
  63.         </dependency>
  64.         <dependency>
  65.             <groupId>org.projectlombok</groupId>
  66.             <artifactId>lombok</artifactId>
  67.             <optional>true</optional>
  68.         </dependency>
  69.         <dependency>
  70.             <groupId>org.springframework.boot</groupId>
  71.             <artifactId>spring-boot-starter-test</artifactId>
  72.             <scope>test</scope>
  73.         </dependency>
  75.     </dependencies>
  77. </project>
复制代码
application.yml
  1. server:
  2.   port: 8401
  4. spring:
  5.   application:
  6.     name: cloudalibaba-sentinel-service
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: localhost:8848
  11.     sentinel:
  12.       transport:
  13.         dashboard: localhost:8080
  14.         port: 8719  #默认8719，假如被占用了会自动从8719开始依次+1扫描。直至找到未被占用的端口
  16. management:
  17.   endpoints:
  18.     web:
  19.       exposure:
  20.         include: '*'
复制代码
主启动类：
  1. @SpringBootApplication
  2. @EnableDiscoveryClient
  3. public class SentinelMain8401 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SentinelMain8401.class,args);
  7.     }
  8. }
复制代码
业务类：
  1. @Slf4j
  2. @RestController
  3. public class FlowLimitController {
  5.     @GetMapping("/testA")
  6.     public String testA(){
  7.         return "=======>testA";
  8.     }
  10.     @GetMapping("/testB")
  11.     public String testB(){
  12.         return "=======>testB";
  13.     }
  14. }
复制代码
测试：
  1. 1、启动nacos server、Sentinel-Dashboard、CloudAlibaba-sentinel-service-8401
  2. 2、查看sentinel控制台 http://localhost:8080/
  4. 结果：空空如也
  5. （因为：Sentinel采用的是懒加载模式）
  6. 3、浏览：http://localhost:8401/testA和http://localhost:8401/testB
  7. 4、再查看sentinel控制台 http://localhost:8080/
复制代码

3.2、流控规则
  1. 资源新增流控，可以通过两个地方来添加：
  2. 1、簇点链路-点击”+流控“
  3. 2、流控规则-点击"新增流控规则"
  5. 阈值类型：
  6. QPS：系统每秒钟处理完成的请求次数
  8. （QPS是在请求进入应用之前就处理，线程数是在请求进入应用之后处理）
复制代码
3.2.1、流控模式
  1. 流控3种模式分为：直接、关联、链路
复制代码
3.2.1.1、直接


测试：
  1. 1、直接的配置如上
  2. 2、每秒访问一次http://localhost:8401/testA
  3.         正常
  4. 3、每秒多次快速的访问http://localhost:8401/testA
  5.     Blocked by Sentinel (flow limiting)
  6. (当再次恢复每秒1次的访问频率时，又可正常访问)
  8. 思考：
  9. 访问频次不符合配置规则后直接显示sentinel的默认处理Blocked by Sentinel,我们如何自定义规则不匹配的情况呢？
  10. (后续会介绍：@SentinelResource去做方法的兜底处理，类似Hystrix的@HystrixCommand)
复制代码
3.2.1.2、关联
  1. 什么是关联？即当与testA相关的资源testB达到阈值时，就挂testA
复制代码

测试：
  1. 1、配置规则如上
  2. 2、postman模拟并发密集的访问http://localhost:8401/testB
  3. 3、浏览器访问http://localhost:8401/testA
  5. 结果：Blocked by Sentinel (flow limiting)
  7. （当对testB密集访问停止后，testA访问恢复正常）
复制代码

3.2.1.3、链路

新增代码：service
  1. @Slf4j
  2. @Service
  3. public class FlowLimitService {
  5.     @SentinelResource("findOrder")
  6.     public String findOrder(){
  7.         log.info("----order----");
  8.         return "order";
  9.     }
  10. }
复制代码
controller
  1. @Slf4j
  2. @RestController
  3. public class FlowLimitController {
  5.     @Resource
  6.     private FlowLimitService flowLimitService;
  8.     @GetMapping("/testA")
  9.     public String testA(){
  10.         flowLimitService.findOrder();
  11.         return "=======>testA";
  12.     }
  14.     @GetMapping("/testB")
  15.     public String testB(){
  16.         flowLimitService.findOrder();
  17.         return "=======>testB";
  18.     }
  19. }
复制代码
设置规则：
  1. 1、配置规则如上
  2. 2、快速访问http://localhost:8401/testA
  3. 结果：
  4. ###############################有待确认#############
  5. 快速访问http://localhost:8401/testB
  6. 结果：
  7. ###############################有待确认#############
复制代码
3.2.2、流控结果

3.2.2.1、快速失败
  1. 源码：
  2. com.alibaba.csp.sentinel.slots.block.flow.controller.DefaultController
  4. 上面写流控模式的时候已经展示了效果，不符合配置的时候，快速做出对应的反映，如
复制代码
3.2.2.2、Warn Up预热
  1. 源码:
  2. com.alibaba.csp.sentinel.slots.block.flow.controller.WarmUpController
  4. 公式：
  5. 阈值除以coldFactor（默认为3），经过预热时长后才会达到阈值
  7. 限流-冷启动：
  8. 当流量突然增大的时候，我们常常会希望系统从空闲状态到繁忙状态的切换的时间长一些。即如果系统在此之前长期处于空闲
  9. 的状态，我们希望处理请求的数量是缓步的增多，经过预期的时间以后，到达系统处理请求个数的最大值。Warm Up（冷启
  10. 动，预热）模式就是为了实现这个目的的。
  12. 应用场景：
  13. 秒杀系统在开启的瞬间，会有很多流量上来，会把系统打死，预热方式就是为了保护系统，可以慢慢的把流量放进来。
  14. 慢慢的把阈值增长到设定的阈值、
复制代码
  1. 配置解读：
  2. 系统初始化的阈值为10/3约等于3，即阈值刚开始为3.然后过了5秒后阈值才逐渐升到10
复制代码
3.2.2.3、列队期待
  1. 源码：
  2. com.alibaba.csp.sentinel.slots.block.flow.controller.RateLimiterController
  4. 匀速排队，阈值必须设置为QPS。
  6. 匀速排队会严格控制请求通过的时间间隔。也即是让请求以均匀的速度通过，对应的是漏桶算法。（类似消息队列）
复制代码
  1. 配置解读：
  2. /testB每秒1次请求，超过的话就排队等待。等待的超时时间是20000ms
复制代码
3.3、降级规则
  1. 降级规则包括：RT、异常比例、异常数
复制代码
3.3.1、RT均匀相应时间
  1. RT平均响应时间:
  2. 当1s内持续进入5个请求，对应时刻的平均响应时间均超过阈值，那么在接下的时间窗口之内，对这个方法的调用都会自动地
  3. 熔断（抛出DegradeException）.
  5. Sentinel的默认RT上限是4900ms,超出此阈值的都会算作4900ms。若需要变更此上线可以通过：
  6. -Dcsp.sentinel.statistic.max.rt=xxx来配置
复制代码

新增代码：
  1. @GetMapping("/testD")
  2. public String testD()
  3. {
  4.     try {
  5.         TimeUnit.SECONDS.sleep(1);
  6.     } catch (InterruptedException e) {
  7.         e.printStackTrace();
  8.     }
  9.     log.info("testD 测试RT");
  10.     return "=======>testD";
  11. }
复制代码
设置

测试：
  1. 如上JMeter创建1s中10个线程的访问去请求testD.
  3. 然后再浏览器上访问http://localhost:8401/testD
  4. 结果：
  5. Blocked by Sentinel (flow limiting)
  7. （配置中，我们希望200毫秒处理完这次任务，如果200毫秒还没处理完，在未来1s的时间窗口内，断路器打开，微服务不可用）
  9. （当我们停止JMeter测试后，没这么大访问量了，断路器关闭，微服务恢复。）
复制代码
3.3.2、非常比例
  1. 异常比例：
  2. 当资源的每秒请求量>=5，并且每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下来的时间窗口之
  3. 内，对这个方法的调用都会自动返回。
复制代码

新增代码：
  1. @GetMapping("/testE")
  2. public String testE()
  3. {
  4.     log.info("testE 测试RT");
  5.     int age = 10/0;
  6.     return "------testE";
  7. }
复制代码
设置规则：

测试：
  1. JMeter压测testE,每秒10个线程
  3. 浏览器访问：http://localhost:8401/testE
  5. 结果：不是报错，而是Blocked by Sentinel (flow limiting)
  7. 结论：
  8. 开启JMeter后，直接高并发发送请求，多次调用达到了我们的配置条件。断路器开启，微服务不可用，不再报错error而是
  9. 进入服务降级
复制代码
3.3.3、非常数
  1. 异常数：
  2. 当资源近1分钟的异常数目超过阈值之后进入熔断，这个统计时间窗口是分钟级别的，若timewindow小于60s,则结束熔断状
  3. 态后仍可能再次进入熔断状态
复制代码

新增代码：
  1. @GetMapping("/testF")
  2. public String testF()
  3. {
  4.     log.info("testF 测试异常数");
  5.     int age = 10/0;
  6.     return "------testF 测试异常数";
  7. }
复制代码
设置规则如下：
  1. 浏览器访问：http://localhost:8401/testF
  2. 前5次报错，走Error
  3. 之后报：Blocked by Sentinel (flow limiting)
  4. 61s后,服务熔断解除，走Error
复制代码
3.4、热门KEY限流

3.4.1、寻常设置
  1. 何为热点？热点即经常访问的数据。很多时候我们希望统计某个热点数据中访问频次最高的 Top K 数据，并对其访问进行限
  2. 制。
复制代码
之前的case，限流出现标题后，都是Sentinel的默认提示:Blocked by Sentinel (flow limiting)
我们将使用@SentinelResource，类似Hystrix的@HystrixCommand。当方法出现标题后就找对应的兜底方法返回。
新增方法如下：
  1. @GetMapping("/testHotKey")
  2. @SentinelResource(value = "testHotKey",blockHandler = "deal_testHotKey")
  3. public String testHotKey(@RequestParam(value = "p1",required = false) String p1,
  4.                          @RequestParam(value = "p2",required = false) String p2) {
  5.     //int age = 10/0;
  6.     return "------testHotKey";
  7. }
  9. //兜底方法
  10. public String deal_testHotKey (String p1, String p2, BlockException exception){
  11.     return "------deal_testHotKey,o(╥﹏╥)o";
  12. }
复制代码
设置规则如下：

测试：
  1. 快速访问：http://localhost:8401/testHotKey   结果：------testHotKey
  3. 快速访问：http://localhost:8401/testHotKey?p1=abc    结果：------deal_testHotKey,o(╥﹏╥)o
  5. 快速访问：http://localhost:8401/testHotKey?p2=123  结果：------testHotKey
  7. 快速访问：http://localhost:8401/testHotKey?p1=abc&p2=123 结果：------deal_testHotKey,o(╥﹏╥)o
  9. 如果不快速访问，达不到阈值时，也只会返回------testHotKey
复制代码
3.4.2、参数例外：

我们偶然候渴望当P1参数为某个特别值时，它的限流值平静常不一样，假如当P1==5时，渴望它的阈值为200。

测试：
  1. 1、浏览器快速访问：http://localhost:8401/testHotKey?p1=5 返回：------testHotKey
  3. 2、浏览器快速访问：http://localhost:8401/testHotKey?p1=3 返回：------deal_testHotKey,o(╥﹏╥)o
  5. 注意：参数必须是基础数据类型
复制代码
3.5、体系规则
  1. 系统保护规则是从应用级别的入口流量进行控制，从单台机器的 load、CPU 使用率、平均 RT、入口 QPS 和并发线程数等
  2. 几个维度监控监控应用指标，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。
  4. 系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量生效。入口流量指的是进入应用的流量
  5. （EntryType.IN），比如 Web 服务或 Dubbo 服务端接收的请求，都属于入口流量。
  7. 系统规则支持以下的模式:
  8. 1、load自适应：仅对 Linux/Unix-like 机器生效
  9. 系统的 load1 作为启发指标，进行自适应系统保护。当系统 load1 超过设定的启发值，且系统当前的并发线程数超过估
  10. 算的系统容量时才会触发系统保护（BBR 阶段）。系统容量由系统的 maxQps * minRt 估算得出。设定参考值一般是
  11. CPU cores * 2.5。
  13. 2、CPU usage：
  14. 当系统 CPU 使用率超过阈值即触发系统保护（取值范围 0.0-1.0），比较灵敏。
  16. 3、平均 RT：
  17. 当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
  19. 4、并发线程数：
  20. 当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
  22. 5、入口 QPS：
  23. 当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
复制代码
3.6、@SentinelResource
  1. @SentinelResource:
  2.         类似Hystrix的@HystrixCommand,做兜底服务自定义
  4. 其中blockXXXX是处理：配置违规的
  5.         @blockHandlerClass 处理类
  6.         @blockHandler 处理类下的处理方法
  8. fallback:处理异常，做服务降级的
  9. exceptionToIgnore：忽略异常
  11. 【程序异常和违规同时发生优先执行blockHandler】
复制代码
3.6.1、按资源名称限流

新增业务类RateLimitController：
  1. @Slf4j
  2. @RestController
  3. public class RateLimitController {
  5.     @GetMapping("/byResource")
  6.     @SentinelResource(value = "byResource",blockHandler = "handleException")
  7.     public CommonResult byResource()
  8.     {
  9.         return new CommonResult(200,"按资源名称限流测试OK",new Payment(2020L,"serial001"));
  10.     }
  11.     public CommonResult handleException(BlockException exception)
  12.     {
  13.         return new CommonResult(444,exception.getClass().getCanonicalName()+"\t 服务不可用");
  14.     }
  16. }
复制代码
新增设置：

测试：
  1. 上述配置解析：
  2. 表示1秒钟内查询次数大于1，就限流跑到我们自定义的方法
  4. 1、1s访问一次：http://localhost:8401/byResource
  5. 结果：{"code":200,"message":"按资源名称限流测试OK","data":{"id":2020,"serial":"serial001"}}
  7. 2、1s内快速多次访问：http://localhost:8401/byResource
  8. 结果：{"code":444,"message":"com.alibaba.csp.sentinel.slots.block.flow.FlowException\t 服务不可用","data":null}
  10. 根据资源名称限流，会优先返回我们自定义的处理信息，没有自定义的返回Sentinel默认限流处理信息
复制代码
3.6.2、按URL地点限流

新增方法：
  1. @GetMapping("/rateLimit/byUrl")
  2. @SentinelResource(value = "byUrl",blockHandler = "byUrlHandler")
  3. public CommonResult byUrl()
  4. {
  5.     return new CommonResult(200,"按url限流测试OK",new Payment(2020L,"serial002"));
  6. }
  8. public CommonResult byUrlHandler(BlockException exception){
  9.     return new CommonResult(444,exception.getClass().getCanonicalName()+"\t 服务不可用");
  10. }
复制代码
新增设置：

测试：
  1. 1、1s访问一次：http://localhost:8401/rateLimit/byUrl
  2. 结果：
  3. {"code":200,"message":"按url限流测试OK","data":{"id":2020,"serial":"serial002"}}
  5. 2、1s内快速访问：http://localhost:8401/rateLimit/byUrl
  6. 结果：
  7. Blocked by Sentinel (flow limiting)
  9. 根据url地址限流返回的是Sentinel自带的默认限流处理信息
复制代码
3.6.3、优化

以上一个方法新增一个对应的处理处罚限流方法，代码冗余且和业务稠浊，我们可以将处理处罚方法提出来做单独处理处罚
新增一个handler：
  1. public class CustomerBlockHandler {
  2.        
  3.     //注意---这里必须是static且不能为private
  4.     public static CommonResult handlerException(BlockException exception)
  5.     {
  6.         return new CommonResult(4444,"按客戶自定义,global handlerException----1");
  7.     }
  8.     public static CommonResult handlerException2(BlockException exception)
  9.     {
  10.         return new CommonResult(4444,"按客戶自定义,global handlerException----2");
  11.     }
  13. }
复制代码
业务类新增方法：
  1. @GetMapping("/rateLimit/customerBlockHandler")
  2. @SentinelResource(value = "customerBlockHandler",
  3.                   blockHandlerClass = CustomerBlockHandler.class,
  4.                   blockHandler = "handlerException")
  5. public CommonResult customerBlockHandler()
  6. {
  7.     return new CommonResult(200,"按客戶自定义",new Payment(2020L,"serial003"));
  8. }
复制代码
新增对应的设置，然后测试：
  1. 1s内多次快速的访问：http://localhost:8401/rateLimit/customerBlockHandler
  3. 结果：
  4. {"code":4444,"message":"按客戶自定义,global handlerException----1","data":null}
复制代码
3.7、Sentinel与Ribbon和Feign的整合

3.7.1、Sentinel与Ribbon

3.7.1.1、创建cloudalibaba-provider-payment-9004和9005
  1. <parent>
  2.     <artifactId>cloud_2020</artifactId>
  3.     <groupId>com.lee.springcloud</groupId>
  4.     <version>1.0-SNAPSHOT</version>
  5. </parent>
  6. <modelVersion>4.0.0</modelVersion>
  7. <artifactId>cloudalibaba-provider-payment-9004</artifactId>
复制代码
pom
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud_2020</artifactId>
  7.         <groupId>com.lee.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.     <artifactId>cloudalibaba-provider-payment-9004</artifactId>
  13.     <dependencies>
  14.         <!--SpringCloud ailibaba nacos -->
  15.         <dependency>
  16.             <groupId>com.alibaba.cloud</groupId>
  17.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  18.         </dependency>
  19.         <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  20.             <groupId>com.lee.springcloud</groupId>
  21.             <artifactId>cloud-api-commons</artifactId>
  22.             <version>${project.version}</version>
  23.         </dependency>
  24.         <!-- SpringBoot整合Web组件 -->
  25.         <dependency>
  26.             <groupId>org.springframework.boot</groupId>
  27.             <artifactId>spring-boot-starter-web</artifactId>
  28.         </dependency>
  29.         <dependency>
  30.             <groupId>org.springframework.boot</groupId>
  31.             <artifactId>spring-boot-starter-actuator</artifactId>
  32.         </dependency>
  33.         <!--日常通用jar包配置-->
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-devtools</artifactId>
  37.             <scope>runtime</scope>
  38.             <optional>true</optional>
  39.         </dependency>
  40.         <dependency>
  41.             <groupId>org.projectlombok</groupId>
  42.             <artifactId>lombok</artifactId>
  43.             <optional>true</optional>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.springframework.boot</groupId>
  47.             <artifactId>spring-boot-starter-test</artifactId>
  48.             <scope>test</scope>
  49.         </dependency>
  50.     </dependencies>
  51. </project>
复制代码
application.yml
  1. server:
  2.   port: 9004
  4. spring:
  5.   application:
  6.     name: nacos-payment-provider
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: localhost:8848 #配置Nacos地址
  12. management:
  13.   endpoints:
  14.     web:
  15.       exposure:
  16.         include: '*'
复制代码
主启动类
  1. @SpringBootApplication
  2. @EnableDiscoveryClient//服务发现
  3. public class PaymentMain9004 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(PaymentMain9004.class,args);
  7.     }
  8. }
复制代码
业务类
  1. @Slf4j
  2. @RestController
  3. public class PaymentController {
  5.     @Value("${server.port}")
  6.     private String serverPort;
  8.     public static HashMap<Long, Payment> hashMap = new HashMap<>();
  9.     static{
  10.         hashMap.put(1L,new Payment(1L,"aaa"));
  11.         hashMap.put(2L,new Payment(2L,"bbb"));
  12.         hashMap.put(3L,new Payment(3L,"ccc"));
  13.     }
  15.     @GetMapping(value = "/paymentSQL/{id}")
  16.     public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id){
  17.         Payment payment = hashMap.get(id);
  18.         CommonResult<Payment> result = new CommonResult(200,"from mysql,serverPort:  "+serverPort,payment);
  19.         return result;
  20.     }
  22. }
复制代码
3.7.1.2、创建cloudalibaba-consumer-order-84
  1. <parent>
  2.     <artifactId>cloud_2020</artifactId>
  3.     <groupId>com.lee.springcloud</groupId>
  4.     <version>1.0-SNAPSHOT</version>
  5. </parent>
  6. <modelVersion>4.0.0</modelVersion>
  7. <artifactId>cloudalibaba-consumer-order-84</artifactId>
复制代码
POM
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>cloud_2020</artifactId>
  7.         <groupId>com.lee.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  11.     <artifactId>cloudalibaba-consumer-order-84</artifactId>
  13.     <dependencies>
  14.         <dependency>
  15.             <groupId>org.springframework.cloud</groupId>
  16.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  17.         </dependency>
  18.         <dependency>
  19.             <groupId>com.alibaba.cloud</groupId>
  20.             <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  25.         </dependency>
  26.         <dependency>
  27.             <groupId>com.lee.springcloud</groupId>
  28.             <artifactId>cloud-api-commons</artifactId>
  29.             <version>${project.version}</version>
  30.         </dependency>
  31.         <dependency>
  32.             <groupId>org.springframework.boot</groupId>
  33.             <artifactId>spring-boot-starter-web</artifactId>
  34.         </dependency>
  35.         <dependency>
  36.             <groupId>org.springframework.boot</groupId>
  37.             <artifactId>spring-boot-starter-actuator</artifactId>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-devtools</artifactId>
  42.             <scope>runtime</scope>
  43.             <optional>true</optional>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.projectlombok</groupId>
  47.             <artifactId>lombok</artifactId>
  48.             <optional>true</optional>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-starter-test</artifactId>
  53.             <scope>test</scope>
  54.         </dependency>
  55.     </dependencies>
  57. </project>
复制代码
application.yml
  1. server:
  2.   port: 84
  4. spring:
  5.   application:
  6.     name: nacos-order-consumer
  7.   cloud:
  8.     nacos:
  9.       discovery:
  10.         server-addr: localhost:8848
  11.     sentinel:
  12.       transport:
  13.         dashboard: localhost:8080
  14.         port: 8719
  16. service-url:
  17.   nacos-user-service: http://nacos-payment-provider
复制代码
主启动类
  1. @EnableDiscoveryClient
  2. @SpringBootApplication
  3. @EnableFeignClients
  5. public class ConsumerOrderNacos84 {
  7.     public static void main(String[] args) {
  8.         SpringApplication.run(ConsumerOrderNacos84.class,args);
  9.     }
  10. }
复制代码
设置类
  1. @Configuration
  2. public class ApplicationContextConfig {
  4.     @Bean
  5.     @LoadBalanced
  6.     public RestTemplate  getRestTemplate()
  7.     {
  8.         return new RestTemplate();
  9.     }
  11. }
复制代码
业务类
  1. @Slf4j
  2. @RestController
  3. public class CircleBreakerController {
  5.     public static final String SERVICE_URL = "http://nacos-payment-provider";
  7.     @Resource
  8.     private RestTemplate restTemplate;
  10.     @RequestMapping("/consumer/fallback/{id}")
  11.     @SentinelResource(value = "fallback") //没有配置
  12.     //@SentinelResource(value = "fallback",fallback = "handlerFallback") //fallback只负责业务异常
  13.     //@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
  14.     //@SentinelResource(value = "fallback", fallback = "handlerFallback", blockHandler="blockHandler",exceptionsToIgnore = {IllegalArgumentException.class})
  15.     public CommonResult<Payment> fallback(@PathVariable Long id) {
  16.         CommonResult<Payment> result = restTemplate.getForObject(SERVICE_URL + "/paymentSQL/"+id, CommonResult.class,id);
  18.         if (id == 4) {
  19.             throw new IllegalArgumentException ("IllegalArgumentException,非法参数异常....");
  20.         }else if (result.getData() == null) {
  21.             throw new NullPointerException ("NullPointerException,该ID没有对应记录,空指针异常");
  22.         }
  24.         return result;
  25.     }
  27.     //fallback
  28.     public CommonResult handlerFallback(@PathVariable  Long id,Throwable e) {
  29.         Payment payment = new Payment(id,"null");
  30.         return new CommonResult<>(444,"兜底异常handlerFallback,exception内容  "+e.getMessage(),payment);
  31.     }
  33.     //blockHandler
  34.     public CommonResult blockHandler(@PathVariable  Long id, BlockException blockException) {
  35.         Payment payment = new Payment(id,"null");
  36.         return new CommonResult<>(445,"blockHandler-sentinel限流,无此流水: blockException  "+blockException.getMessage(),payment);
  37.     }
  39. }
复制代码
3.7.1.3、测试：
  1. 1、启动nacos-server、sentinel-server、cloudalibaba-provider-payment-9004、9005、
  2. cloudalibaba-consumer-order-84
  4. #############测试一############
  5. 2、浏览器访问：http://localhost:84/consumer/fallback/1
  7. 结果：
  8. {"code":200,"message":"from mysql,serverPort:  9004","data":{"id":1,"serial":"aaa"}}
  9. {"code":200,"message":"from mysql,serverPort:  9005","data":{"id":1,"serial":"aaa"}}
  10. 两个结果来回切换
  12. 3、浏览器访问：http://localhost:84/consumer/fallback/4
  14. 结果：
  15. Whitelabel Error Page
  17. #############测试二##############
  18. 4、consumer-84业务类放开注解@SentinelResource(value = "fallback",fallback = "handlerFallback")//fallback只负责业务异常
  20. 5、浏览器访问：http://localhost:84/consumer/fallback/4
  22. 结果：
  23. {"code":444,"message":"兜底异常handlerFallback,exception内容  IllegalArgumentException,非法参数异常....","data":{"id":4,"serial":"null"}}
  25. ##############测试三############
  26. 6、consumer-84业务类放开注解@SentinelResource(value = "fallback",blockHandler = "blockHandler") //blockHandler只负责sentinel控制台配置违规
  28. 7、且sentinel控制台新增fallback的降级策略
  30. 新增降级：
  31.         资源名：fallback 策略：异常数        异常数：2 时间窗口：2
  33. 8、浏览器访问：http://localhost:84/consumer/fallback/2
  35. 结果：正常
  37. 浏览器访问：http://localhost:84/consumer/fallback/4
  39. 结果：Whitelabel Error Page
  41. 快速多次访问：http://localhost:84/consumer/fallback/4
  43. 结果：{"code":445,"message":"blockHandler-sentinel限流,无此流水: blockException  null","data":{"id":4,"serial":"null"}}
  45. ##################测试四############
  46. 9、consumer-84业务类放开注解@SentinelResource(value = "fallback", fallback = "handlerFallback", blockHandler = "blockHandler",exceptionsToIgnore = {IllegalArgumentException.class})
  48. 10、浏览器访问：http://localhost:84/consumer/fallback/4
  50. 结果：Whitelabel Error Page
  52. 浏览器访问：http://localhost:84/consumer/fallback/5
  54. 结果：{"code":444,"message":"兜底异常handlerFallback,exception内容  NullPointerException,该ID没有对应记录,空指针异常","data":{"id":5,"serial":"null"}}
  56. 结论：
  58. @blockHandlerClass 处理类
  59. @blockHandler 处理类下的处理方法
  60. fallback:处理异常，做服务降级的
  61. exceptionToIgnore：忽略异常
复制代码
3.7.2、Sentinel与OpenFeign

修改module：cloudalibaba-consumer-order-84
POM新增（上面创建的时间就已增长过了）
  1. <dependency>
  2.     <groupId>org.springframework.cloud</groupId>
  3.     <artifactId>spring-cloud-starter-openfeign</artifactId>
  4. </dependency>
复制代码
yml新增：
  1. #对Feign的支持
  2. feign:
  3.   sentinel:
  4.     enabled: true
复制代码
新增feign对应的接口：paymentService
  1. @FeignClient(value = "nacos-payment-provider",fallback = PaymentFallbackService.class)
  2. public interface PaymentService {
  4.     @GetMapping(value = "/paymentSQL/{id}")
  5.     public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id);
  7. }
复制代码
新增feign接口的对应的服务降级类：PaymentFallbackService
  1. @Component
  2. public class PaymentFallbackService implements PaymentService
  3. {
  4.     @Override
  5.     public CommonResult<Payment> paymentSQL(Long id)
  6.     {
  7.         return new CommonResult<>(44444,"服务降级返回,---PaymentFallbackService",new Payment(id,"errorSerial"));
  8.     }
  9. }
复制代码
新增controller：OrderController
  1. @Slf4j
  2. @RestController
  3. public class OrderController {
  5.     // OpenFeign
  6.     @Resource
  7.     private PaymentService paymentService;
  9.     @GetMapping(value = "/consumer/feign/paymentSQL/{id}")
  10.     public CommonResult<Payment> paymentSQL(@PathVariable("id") Long id) {
  11.         return paymentService.paymentSQL(id);
  12.     }
  14. }
复制代码
主启动类新增注解：
  1. @EnableFeignClients
复制代码
测试：
  1. 1、启动nacos-server、sentinel-server、cloudalibaba-provider-payment-9004、9005、
  2. cloudalibaba-consumer-order-84
  4. 2、浏览器访问：http://localhost:84/consumer/feign/paymentSQL/5
  6. 结果:
  7. {"code":200,"message":"from mysql,serverPort:  9005","data":null}
  9. 4、此时关闭cloudalibaba-provider-payment-9004、9005两个微服务，重新访问
  11. 结果：
  12. {"code":44444,"message":"服务降级返回,---PaymentFallbackService","data":{"id":5,"serial":"errorSerial"}}
复制代码
3.8、Sentinel规则长期化

//TODO 以后再单独列出文章来写
回复

使用道具 举报

返回列表

郭卫东
+ 我要发帖

登录后关闭弹窗

登录参与点评抽奖  加入IT实名职场社区
去登录
快速回复 返回顶部 返回列表