SpringCloud Alibaba学习笔记 ——（六、Sentinel 服务保护框架）

SpriingCloudAlibaba —— Sentinel 服务保护框架

• • 
    
• ​​六、Sentinel 服务保护框架​​

• • 
    
• ​​6.1 Sentinel 的功能​​

​​6.1.1 服务接口的保护方案​​​​6.1.2 名词解释​​

• 
  

• • 
    
• ​​6.2.1 Sentinel 和 Hystrix 的区别​​
• ​​6.2.2 配置限流的方式​​
  • 
    

• • 
    
• ​​6.3.0 安装 Sentinel 控制台​​
• ​​6.3.1 使用 Java 代码实现服务限流​​
• ​​6.3.2 使用注解实现服务限流​​
• ​​6.3.3 Springboot 整合 Sentinel 仪表盘​​
• ​​6.3.4 实现信号量隔离​​
  • 
    

• • 
    
• ​​6.4.1 Sentinel 数据持久化的方式（基于 nacos 配置中心实现持久化）​​
• ​​6.4.2 Gateway 整合 sentinel 实现服务限流​​
• ​​6.4.3 实现服务动态降级​​
  • 
    

• ​​6.6 Sentinel 整合热词限流​​
  • 
    

• 
  

Author: Gorit

Date：2021年1月

Refer：阿里云大学

2021年发表博文：

11/30

六、Sentinel 服务保护框架

具体介绍查阅官方文档，这里就不介绍了

6.1 Sentinel 的功能

1. 1. 
      
2. 服务限流
3. 实现对服务接口的保护
   1. 
      

QPS（每秒的请求量）

6.1.1 服务接口的保护方案

1. 1. 
      
2. 黑名单和白名单
3. 对 IP 实现限流 / 熔断机制
4. 服务降级
5. 服务隔离机制。
   1. 
      

6.1.2 名词解释

服务限流：（类比去景点玩，景点人员限流）

目的为了保护我们的服务，在高并发情况下，如果客户端的请求服务器端达到一定的极限（设置阈值），请求的数量超出我们设置的阈值，开启我们的自我保护机制，直接执行我们的服务降级的方法，不会去执行我们的业务逻辑，走本地的 fallback 方法

服务降级：（类比秒杀一件商品，当前排队人数过多，请稍后重试）

在高并发的情况下，为了防止用户一直等待，采用限流活熔断机制，保护我们的服务，不会执行我们的业务逻辑，走本地 fallback 方法，返回一个友好的提示给客户端

服务雪崩的效应：

默认的情况下，Tomcat/ Jetty 服务器 只会有一个线程池处理所有的接口请求。

这样的话，高并发情况下，如果客户端所有的请求都堆积到同一个接口上，那么会产生该服务器的所有线程都在处理该接口，可能会导致其他接口无法访问，短暂没有线程处理

**服务雪崩**解决方案：

服务的隔离机制：线程池隔离 或者 信号量隔离机制

1. 1. 
      
2. 线程池隔离：每个接口都由自己的独立的线程池维护我们的请求、每个线程池互不影响。缺点：占用服务器内存非常大
3. 信号量隔离：设置最多允许我们某个接口有一定的阈值线程数量去处理接口，如果超出线程数量，拒绝访问
   1. 
      

6.2 Sentinel 和 Hystrix 的区别

6.2.1 Sentinel 和 Hystrix 的区别

6.2.2 配置限流的方式

1. 1. 
      
2. 手动代码配置（纯代码，注解的形式）
3. Sentinel 控制台形式配置
4. 默认情况下 Sentinel 不对数据持久化，需要自己持久化
   1. 
      

实现的步骤：

创建我们流控、限流规则。

然后在被映射的地址去引用。

6.3 Sentinel 实现服务限流

6.3.0 安装 Sentinel 控制台

在 6.3.3 小结中会用到

​​参考文档​​

1. 1. 
      
2. 下载 Jar 包 (sentinel-dashboard-1.8.0.jar)
3. 运行
   1. 
      

java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

3. 默认登录 sentinel sentinel

6.3.1 使用 Java 代码实现服务限流

1. 导入坐标依赖

<!-- 服务限流、服务降级       -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2. 编写 OrderContoller

@RestController
public class OrderService {

    // 定义的限流规则名称
    private static final String GETORDER_KEY = "orderToMenber";


    // 测试 Sentinel，对接口限流
    @RequestMapping("/orderToMenber")
    public String orderToMenber() {
        Entry entry = null;
        try {
            entry = SphU.entry(GETORDER_KEY);
            return "orderToMenber接口";
        } catch (Exception e) {
           // 限流的情况就会进入 Exception
            return "当前访问人数过多，请稍后重试！";
        } finally {
            if (entry != null) {
                entry.exit();
            }
        }
    }

    /**
     * 创建限流规则
     * @return
     */
    @RequestMapping("/initFlowQpsRule")
    public String initFlowQpsRule() {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(GETORDER_KEY); // 限流规则名称
        //qps 控制在 1 以内
        rule1.setCount(1);
        //qps 限流
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
        return ".... 限流配置初始化成功";
    }


}

3. 3. 
      
4. 编写启动类 AppOrder
5. 先访问 http://localhost:8080/initFlowQpsRule 实现初始化规则
6. 再访问 http://localhost:8080/orderToMenber
7. 然后看到刷新一遍，接口就会显示 Exception 的异常信息了
   3. 
      

• • 
    
• QPS：每秒接口的访问次数，设置为 1，每秒接口只能访问一次
  
• 必须先加载规则，规则才能生效。
  
• 如果 SpringBoot 重启，规则就会失效
  
  • 
    

SpringBoot 项目启动成功之后，加载我们的限流规则。

Sentinel 限流的规则默认情况下是没有持久化，如果需要持久化的话用 zk、nacos、携程阿波罗

解决方案

1. 编写 SentinelApplicationRunner 配置类，并实现 ApplicationRunner 接口（这个接口是 SpringBoot 提供的启动加载的一个类

package cn.gorit.service.order.config;

import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * @Classname SentinelApplicationRunner
 * @Description 我们将初始化的规则，放在这里加载，这是 Springboot 提供的一个启动加载接口
 * @Date 2021/1/30 14:31
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class SentinelApplicationRunner implements ApplicationRunner {
    // 定义的限流规则名称
    private static final String GETORDER_KEY = "orderToMenber";

    private Logger log = LoggerFactory.getLogger(SentinelApplicationRunner.class);

    @Override
    public void run(ApplicationArguments args) throws Exception {
        List<FlowRule> rules = new ArrayList<FlowRule>();
        FlowRule rule1 = new FlowRule();
        rule1.setResource(GETORDER_KEY); // 限流规则名称
        //qps 控制在 1 以内
        rule1.setCount(1);
        //qps 限流
        rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule1.setLimitApp("default");
        rules.add(rule1);
        FlowRuleManager.loadRules(rules);
        log.info(">>> 限流配置加载成功");
    }
}

2. 然后再次启动，就能直接访问 http://localhost:8080/orderToMenber 实现服务限流了

6.3.2 使用注解实现服务限流

/**
     * @SentinelResource 参数主要如下
     * fallback 服务降级执行本地方法
     * blockHandler 限流/熔断 出现异常执行的方法
     * value 指定我们的资源名称
     * @return
     */
    @SentinelResource(value = GETORDER_KEY, blockHandler = "getOrderQpsException")
    @RequestMapping("/orderToMemberSentinelResource")
    public String orderToMemberSentinelResource() {
        return "orderToMemberSentinelResource";
    }

    /**
     * 被限流后返回的提示
     * @param e
     * @return
     */
    public String getOrderQpsException(BlockException e) {
        e.printStackTrace();
        return "该接口被限流了";
    }

6.3.3 Springboot 整合 Sentinel 仪表盘

1. 先启动 Sentinel 控制台：

java -Dserver.port=8718 -Dcsp.sentinel.dashboard.server=localhost:8718 -=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

2. 2. 
      
3. 登录的账号密码：sentinel sentinel
4. SpringBoot 配置整合 Sentinel 控制台
   2. 
      

spring:
  application:
    name: gorit-order
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        dashboard: 127.0.0.1:8718
      eager: true

4. 重新启动 SpringBoot

5. 编写接口

/**
     * 基于控制台实现流量规则限流
     * @return
     */
    @RequestMapping("/getOrderConsole")
    public String getOrderConsole () {
        return "getOrderConsole";
    }

    /**
     * 如果没有使用 @SentinelResource 注解，默认资源名称为接口路径 /getOrderConsole
     */

6. 6. 
      
8. 
   

在控制台添加规则

被限流返回的结果

6. 
   

Blocked by Sentinel (flow limiting)

8. 如果要实现和上述一样的返回效果，只需要加上 @SentinelResouce 注解即可

PS：如果配置了注解，就会和默认的资源名称冲突，所以要删除默认的资源名称

6.3.4 实现信号量隔离

限流规则设置 线程数

// 基于信号量， 在控制台设置规则的时候，配置为 线程数
    @SentinelResource(value = GETORDER_KEY, blockHandler = "getOrderQpsException")
    @RequestMapping("/getOrderSemaphore")
    public String getOrderSemaphore () {
        log.info(">>>" + Thread.currentThread().getName());
        return "getOrderSemaphore";
    }

阙值改为线程数

访问效果

如果看不到效果，可以在代码中加入 Thread.sleep(500) ，使线程阻塞即可

6.4 Sentinel 数据持久化 & 实现服务降级 & 服务熔断

1. 1. 
      
2. Sentinel 持久化方案
3. 网关整合 Sentinel 实现限流
4. 如何对服务实现动态降级
5. 降级的策略 RT、错误比例、次数
   1. 
      

6.4.1 Sentinel 数据持久化的方式（基于 nacos 配置中心实现持久化）

Sentinel 支持数据规则持久化的，官方默认支持 5 种（sentinel-nacos 1.7.0 版本）

1. 1. 
      
2. nacos 分布式配置中心
3. 携程阿波罗
4. 存放本地文件
5. Zookeeper
6. redis
   1. 
      

一、在 nacos 中创建流控规则

gorit-order-sentinel

我们可以在 Nacos 编写 Sentinel 的资源配置，然后整合 sentinel-nacos 的配置

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

• • 
    
• resource: 资源名，即限流规则的作用对象
• limitApp： 流控针对的调用来源，若为 default 则不区分调用来源
• grade：限流阙值类型（QPS 或并发线程数）；0 代表根据并发数量来限流， 1 代表 QPS 来进行流量控制
• count：限流阙值
• strategy：调用关系限流策略
  • 
    

二、SpringBoot 客户端 整合 nacos-sentinel

依赖配置

<!-- 服务限流、服务降级       -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
            <version>2.1.0.RELEASE</version>
        </dependency>
        <!-- SpringBoot 整合 nacos-sentinel 持久化 -->
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-datasource-nacos</artifactId>
            <version>1.7.0</version>
        </dependency>

PS：我用的 SpringBoot 版本是 2.3.4 RELEASE，之前用的 nacos-sentinel 的版本是 1.5.6，启动老是报错，好来改成 1.7.0 就出来了

配置文件 （application.yml）

spring:
  application:
    name: gorit-order
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    sentinel:
      transport:
        dashboard: 127.0.0.1:8718 # 这个是控制台的地址，因为我启动时，指定了控制台启动的端口为 8718
      eager: true
      datasource:
        - nacos:
            server-addr: localhost:8848 # nacos 连接地址
            group-id: DEFAULT_GROUP # nacos 连接分组
            rule-type: flow # 路由存储规则  flow、degrade、param-flow、gw-flow
            data-id: ${spring.application.name}-sentinel # 读取配置文件的 data-id
            data-type: json # 读取配置文件累心为 JSON 和 XML

server:
  port: 8091

编写 getOrderSentinel 接口

// 集成 nacos 实现 sentinel 流控规则的持久化
    @RequestMapping("/getOrderSentinel")
    public String getOrderSentinel() {
        return "OrderSentinel";
    }

启动项目

三、更新前面 Nacos 的配置

更新前

更新 nacos 配置

更改后

看，我们已经实现了通过 nacos 配置中心修改限流规则了

PS: 如果发现重启没有生效的话，是因为我们之前编写的 SentinelApplicationRunner 类会初始化我们的流控配置，所以将其注释掉，就可以解决 nacos 持久化被覆盖的问题

6.4.2 Gateway 整合 sentinel 实现服务限流

​​官方文档​​

Gateway 是采用 netty 启动的，不支持 Servlet-API。所以添加了 Springboot-web 的依赖就会报错

网关流控原理

当通过 ​​GatewayRuleManager​​​ 加载网关流控规则（​​GatewayFlowRule​​​）时，无论是否针对请求属性进行限流，Sentinel 底层都会将网关流控规则转化为热点参数规则（​​ParamFlowRule​​​），存储在 ​​GatewayRuleManager​​​ 中，与正常的热点参数规则相隔离。转换时 Sentinel 会根据请求属性配置，为网关流控规则设置参数索引（​​idx​​），并同步到生成的热点参数规则中。

外部请求进入 API Gateway 时会经过 Sentinel 实现的 filter，其中会依次进行 路由/API 分组匹配、请求属性解析和参数组装。Sentinel 会根据配置的网关流控规则来解析请求属性，并依照参数索引顺序组装参数数组，最终传入 ​​SphU.entry(res, args)​​​ 中。Sentinel API Gateway Adapter Common 模块向 Slot Chain 中添加了一个 ​​GatewayFlowSlot​​​，专门用来做网关规则的检查。​​GatewayFlowSlot​​​ 会从 ​​GatewayRuleManager​​ 中提取生成的热点参数规则，根据传入的参数依次进行规则检查。若某条规则不针对请求属性，则会在参数最后一个位置置入预设的常量，达到普通流控的效果。

1. 1. 
      
2. 新建一个 module，并命名为 gorit-gateway
3. 添加依赖
   1. 
      

<dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
            <version>2.2.4.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
            <version>1.7.0</version>
        </dependency>

3. 编写项目配置依赖 application.yml

spring:
  application:
    name: gorit-order-gateway-8080
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      routes:
        - id: my-member  # 这个用不到，是之前写过的，可以直接 copy 过来
          uri: lb://gorit-member
          # 匹配规则
          predicates:
            - Path=/gorit-member/**
        - id: gorit
          uri: https://www.gorit.cn/ # 转发到我的个人网站
          # 匹配规则
          predicates:
            - Path=/**
      enabled: true
server:
  port: 8080

4. 注入对应的 ​​SentinelGatewayFilter​​​ 实例以及 ​​SentinelGatewayBlockExceptionHandler​​ 实例即可

package cn.gorit.config;

import .SentinelGatewayFilter;
import .exception.SentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;

import java.util.Collections;
import java.util.List;

/**
 * @Classname GatewayConfiguration
 * @Description TODO
 * @Date 2021/1/31 22:34
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class GatewayConfiguration {

    private final List<ViewResolver> viewResolvers;
    private final ServerCodecConfigurer serverCodecConfigurer;

    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        // Register the block exception handler for Spring Cloud Gateway.
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }
}

5. 配置限流的接口（对应上述第一段实现原理）

package cn.gorit.config;

import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;

import java.util.HashSet;
import java.util.Set;

/**
 * @Classname SentinelApplicationRunner
 * @Description TODO
 * @Date 2021/1/31 22:37
 * @Created by CodingGorit
 * @Version 1.0
 */
@Configuration
public class SentinelApplicationRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        initGatewayRules();
    }

    /**
     * 配置网关限流规则
     */
    private void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        // 设置规则
        rules.add(new GatewayFlowRule("gorit")
                // 设置阙值
                .setCount(1)
                // 设置时间窗口，单位是秒，默认是 1 s
                .setIntervalSec(1));
        GatewayRuleManager.loadRules(rules);
    }
}

然后即可实现限流效果

PS：

1. 1. 
      
2. 如果要实现动态限流，并且持久化，将配置写入 nacos 配置中心即可
3. 如果要实现自定义限流返回的信息，需要重写该方法：
   1. 
      

public class SentinelGatewayBlockExceptionHandler implements WebExceptionHandler

3. 然后注入我们重写的 handler 即可

*/
public class JsonSentinelGatewayBlockExceptionHandler implements WebExceptionHandler {
    public JsonSentinelGatewayBlockExceptionHandler(List<ViewResolver> viewResolvers) {
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable throwable) {
        ServerHttpResponse serverHttpResponse = exchange.getResponse();
        serverHttpResponse.getHeaders().add("Content-Type","application/json;charset=utf-8");
        byte[] datas = "{\"code\":403,\"msg\":\"API 接口被限流\"}".getBytes(StandardCharsets.UTF_8);
        DataBuffer buffer = serverHttpResponse.bufferFactory().wrap(datas);
        return serverHttpResponse.writeWith(Mono.just(buffer));
    }
}

6.4.3 实现服务动态降级

​​官方文档​​

服务出现异常时，会自动服务降级，禁止外来继续访问，不会执行真正的逻辑

Sentinel 支持服务的熔断降级

熔断类似于保险丝，如果超出了我们的阙值的情况下，在一定时间内不会执行我们的业务逻辑，直接执行我们的服务降级方法 （fallback） 返回一个友好的提示给客户端，不会真实的执行业务逻辑

// 基于信号量， 在控制台设置规则的时候，配置为 线程数
    @SentinelResource(value = GETORDER_KEY, fallback = "",blockHandler = "getOrderQpsException")
    @RequestMapping("/getOrderSemaphore")
    public String getOrderSemaphore () {
        log.info(">>>" + Thread.currentThread().getName());
        return "getOrderSemaphore";
    }

服务降级策略

1. 1. 
      
2. rt（平均响应时间）
   如果在 1s 内访问五次，平均响应时间超出了我们在平台设置的阙值的情况下，直接触发我们的熔断，执行我们的服务降级的方法。
   时间窗口：在规定的时间窗口内一直执行服务降级的方法，不执行业务逻辑
   
3. 错误比例
   客户端，发出了连续 5 个请求，每个请求全部错误，这说明错误率百分之百
   每 s 秒发出 5个请求，如果请求异常占比超过我们设置的阈值占比的情况下，就会执行服务降级的方法，在规定时间窗口不执行业务逻辑
   
4. 错误次数
   
   1. 
      

官方的熔断策略

• • 
    
• 慢调用比例 (​​SLOW_REQUEST_RATIO​​​)：选择以慢调用比例作为阈值，需要设置允许的慢调用 RT（即最大的响应时间），请求的响应时间大于该值则统计为慢调用。当单位统计时长（​​statIntervalMs​​）内请求数目大于设置的最小请求数目，并且慢调用的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求响应时间小于设置的慢调用 RT 则结束熔断，若大于设置的慢调用 RT 则会再次被熔断。
• 异常比例 (​​ERROR_RATIO​​​)：当单位统计时长（​​statIntervalMs​​​）内请求数目大于设置的最小请求数目，并且异常的比例大于阈值，则接下来的熔断时长内请求会自动被熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。异常比率的阈值范围是 ​​[0.0, 1.0]​​，代表 0% - 100%。
• 异常数 (​​ERROR_COUNT​​)：当单位统计时长内的异常数目超过阈值之后会自动进行熔断。经过熔断时长后熔断器会进入探测恢复状态（HALF-OPEN 状态），若接下来的一个请求成功完成（没有错误）则结束熔断，否则会再次被熔断。
  • 
    

一、编写慢调用比例策略

接口

/**
     * 基于我们的平均响应时间海鲜降级
     */
    @SentinelResource(value = "getOrderDowngradeRtType",fallback = "getOrderDowngradeRtTypeFallback")
    @RequestMapping("/getOrderDowngradeRtType")
    public String getOrderDowngradeRtType() {
        try {
            Thread.sleep(300);
        } catch (Exception e) {

        }
        return "order 业务逻辑正常执行";
    }

    public String getOrderDowngradeRtTypeFallback() {
        return "执行本地的服务降级的方法";
    }

sentinel 添加降级规则

测试相应即可

超出响应时间了，就会返回 fallback 的内容

二、异常比例熔断测试

接口（不带参数就会报错)

/**
     * 基于异常比例 服务降级
     *
     */
    @SentinelResource(value = "getOrderDowngradeErrorType",fallback = "getOrderDowngradeErrorTypeFallback")
    @RequestMapping("/getOrderDowngradeErrorType")
    public String getOrderDowngradeErrorType(@RequestParam int age) {
        int i = 1/age;
        return "业务逻辑请求成功 i "+ i;
    }

    public String getOrderDowngradeErrorTypeFallback(int age) {
        return "错误率太高，请稍后重试访问该接口";
    }

配置

三、基于异常数实现服务降级

复用上面的接口

6.6 Sentinel 整合热词限流

​​热点参数限流​​

下一节

负载均衡专题