SpringCloud Sentinel实战限流熔断降级应用

àì夳堔傛蜴生んèń 2024-03-17 11:26 54阅读 0赞

#### 目录 ####

*  1 Sentinel核心库
 *   *  1.1 Sentinel介绍
     *  1.2 Sentinel核心功能
     *   *  1.2.1 流量控制
         *  1.2.2 熔断降级
     *  2 Sentinel 限流熔断降级
     *   *  2.1 @SentinelResource定义资源
         *  2.2 Sentinel的规则
         *   *  2.2.1 流量控制规则 (FlowRule)
             *  2.2.2 熔断降级规则 (DegradeRule)
             *  2.2.3 系统保护规则 (SystemRule)
             *  2.2.4 访问控制规则 (AuthorityRule)
             *  2.2.5 热点规则 (ParamFlowRule)
         *  2.3 OpenFeign支持
         *   *  2.3.1 fallback
             *  2.3.2 fallbackFactory

--------------------

## 1 Sentinel核心库 ##

Sentinel主页 [https://github.com/alibaba/Sentinel/wiki/%E4%B8%BB%E9%A1%B5][https_github.com_alibaba_Sentinel_wiki_E4_B8_BB_E9_A1_B5]

### 1.1 Sentinel介绍 ###

![在这里插入图片描述][3674d811bb6646b88de548c6653606ad.png]

随着微服务的流行，服务和服务之间的稳定性变得越来越重要。Sentinel 是面向分布式服务架构的流量控制组件，主要以流量为切入点，从限流、流量整形、熔断降级、系统负载保护、热点防护等多个维度来帮助开发者保障微服务的稳定性。

**1)Sentinel核心组件**

1:核心库（Java 客户端）：不依赖任何框架/库，能够运行于 Java 7 及以上的版本的运行时环境，同时对 Dubbo / Spring Cloud 等框架也有较好的支持。

2:控制台（Dashboard）：控制台主要负责管理推送规则、监控、集群限流分配管理、机器发现等。

**2)同组件功能对比**

参看：[https://github.com/alibaba/Sentinel/wiki/%E5%9C%A8%E7%94%9F%E4%BA%A7%E7%8E%AF%E5%A2%83%E4%B8%AD%E4%BD%BF%E7%94%A8-Sentinel\#%E5%90%8C%E7%B1%BB%E7%BB%84%E4%BB%B6%E5%8A%9F%E8%83%BD%E5%AF%B9%E6%AF%94][https_github.com_alibaba_Sentinel_wiki_E5_9C_A8_E7_94_9F_E4_BA_A7_E7_8E_AF_E5_A2_83_E4_B8_AD_E4_BD_BF_E7_94_A8-Sentinel_E5_90_8C_E7_B1_BB_E7_BB_84_E4_BB_B6_E5_8A_9F_E8_83_BD_E5_AF_B9_E6_AF_94]

<table> 
 <thead> 
  <tr> 
   <th>对比内容</th> 
   <th>Sentinel</th> 
   <th>Hystrix</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>隔离策略</td> 
   <td>信号量隔离</td> 
   <td>线程池隔离/信号量隔离</td> 
  </tr> 
  <tr> 
   <td>熔断降级策略</td> 
   <td>基于响应时间或失败比率</td> 
   <td>基于失败比率</td> 
  </tr> 
  <tr> 
   <td>实时指标实现</td> 
   <td>滑动窗口</td> 
   <td>滑动窗口（基于 RxJava）</td> 
  </tr> 
  <tr> 
   <td>规则配置</td> 
   <td>支持多种数据源</td> 
   <td>支持多种数据源</td> 
  </tr> 
  <tr> 
   <td>扩展性</td> 
   <td>多个扩展点</td> 
   <td>插件的形式</td> 
  </tr> 
  <tr> 
   <td>基于注解的支持</td> 
   <td>支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>限流</td> 
   <td>基于 QPS，支持基于调用关系的限流</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>流量整形</td> 
   <td>支持慢启动、匀速器模式</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>系统负载保护</td> 
   <td>支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>控制台</td> 
   <td>开箱即用，可配置规则、查看秒级监控、机器发现等</td> 
   <td>不完善</td> 
  </tr> 
  <tr> 
   <td>常见框架的适配</td> 
   <td>Servlet、Spring Cloud、Dubbo、gRPC 等</td> 
   <td>Servlet、Spring Cloud Netflix</td> 
  </tr> 
 </tbody> 
</table>

**3)Sentinel基本概念**

*  资源

资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，例如，由应用程序提供的服务，或由应用程序调用的其它应用提供的服务，甚至可以是一段代码。

只要通过 Sentinel API 定义的代码，就是资源，能够被 Sentinel 保护起来。大部分情况下，可以使用方法签名，URL，甚至服务名称作为资源名来标示资源。

*  规则

围绕资源的实时状态设定的规则，可以包括流量控制规则、熔断降级规则以及系统保护规则。所有规则可以动态实时调整。

### 1.2 Sentinel核心功能 ###

#### 1.2.1 流量控制 ####

流量控制在网络传输中是一个常用的概念，它用于调整网络包的发送数据。然而，从系统稳定性角度考虑，在处理请求的速度上，也有非常多的讲究。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状，如下图所示：

![在这里插入图片描述][39bf3491c6154b4f8fd6cf7971729fdb.png]

流量控制有以下几个角度:

*  资源的调用关系，例如资源的调用链路，资源和资源之间的关系；
 *  运行指标，例如 QPS、线程池、系统负载等；
 *  控制的效果，例如直接限流、冷启动、排队等。

Sentinel 的设计理念是让您自由选择控制的角度，并进行灵活组合，从而达到想要的效果。

#### 1.2.2 熔断降级 ####

**1)什么是熔断降级**

除了流量控制以外，及时对调用链路中的不稳定因素进行熔断也是 Sentinel 的使命之一。由于调用关系的复杂性，如果调用链路中的某个资源出现了不稳定，可能会导致请求发生堆积，进而导致级联错误。

![在这里插入图片描述][64d3f13639a94f80a197c102d16332a6.png]

Sentinel 和 Hystrix 的原则是一致的: 当检测到调用链路中某个资源出现不稳定的表现，例如请求响应时间长或异常比例升高的时候，则对这个资源的调用进行限制，让请求快速失败，避免影响到其它的资源而导致级联故障。

**2)Sentinel熔断降级设计**

Hystrix 通过 线程池隔离 的方式，来对依赖（在 Sentinel 的概念中对应 资源）进行了隔离。这样做的好处是资源和资源之间做到了最彻底的隔离。缺点是除了增加了线程切换的成本（过多的线程池导致线程数目过多），还需要预先给各个资源做线程池大小的分配。

Sentinel熔断降级设计：

并发线程数限制:和资源池隔离的方法不同，Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。这样不但没有线程切换的损耗，也不需要您预先分配线程池的大小。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。
    
    响应时间降级:除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。

**3)系统自适应保护**

Sentinel 同时提供系统维度的自适应保护能力。防止雪崩，是系统防护中重要的一环。当系统负载较高的时候，如果还持续让请求进入，可能会导致系统崩溃，无法响应。在集群环境下，网络负载均衡会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，这个增加的流量就会导致这台机器也崩溃，最后导致整个集群不可用。

针对这个情况，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求。

### 2 Sentinel 限流熔断降级 ###

Sentinel 可以简单的分为 Sentinel 核心库和 Dashboard。核心库不依赖 Dashboard，但是结合 Dashboard 可以取得最好的效果。我们先来学习Sentinel 核心库的使用，后面再学习Dashboard使用。

![在这里插入图片描述][dae772b25a884be9bf9f51be5473de48.png]

在我们项目中，用户请求通过`hailtaxi-gateway`路由到`hailtaxi-driver`或者`hailtaxi-order`，还有可能在`hailtaxi-order`中使用feign调用`hailtaxi-driver`，所以我们有可能在单个服务中实现熔断限流，也有可能要集成feign调用实现熔断限流，还有可能在微服务网关中实现熔断限流。我们接下来一步一步实现每一种熔断限流操作。

**使用Spring Cloud Alibaba Sentinel**

使用手册：https://github.com/alibaba/spring-cloud-alibaba/wiki/Sentinel

首先需要引入`spring-cloud-starter-alibaba-sentinel`依赖，并使用`@SentinelResource`标识资源。

在`hailtaxi-driver`工程中引入`spring-cloud-starter-alibaba-sentinel`依赖，依赖如下：

#### 2.1 @SentinelResource定义资源 ####

`@SentinelResource` 用于定义资源，并提供可选的异常处理和 fallback 配置项。 `@SentinelResource` 注解包含以下属性：

具体参考：[https://github.com/alibaba/Sentinel/wiki/%E6%B3%A8%E8%A7%A3%E6%94%AF%E6%8C%81][https_github.com_alibaba_Sentinel_wiki_E6_B3_A8_E8_A7_A3_E6_94_AF_E6_8C_81]

<table> 
 <thead> 
  <tr> 
   <th>value</th> 
   <th>资源名称，必需项(不能为空)</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>blockHandler / blockHandlerClass</td> 
   <td>blockHandler 对应处理 BlockException 的函数名称，可选项。 ♞ blockHandler 函数访问范围需要是 public； ♞ 返回类型需要与原方法相匹配，参数类型需要和原方法相匹配并且最后加一个额外的参数，类型为 BlockException。 ♞ blockHandler 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 blockHandlerClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。</td> 
  </tr> 
  <tr> 
   <td>fallback / fallbackClass</td> 
   <td>fallback 函数名称，可选项，用于在抛出异常的时候提供 fallback 处理逻辑。fallback 函数可以针对所有类型的异常(除了 exceptionsToIgnore 里面排除掉的异常类型)进行处理。fallback 函数签名和位置要求： ♞ 返回值类型必须与原函数返回值类型一致； ♞ 方法参数列表需要和原函数一致，或者可以额外多一个 Throwable 类型的参数用于接收对应的异常。 ♞ fallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 fallbackClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。</td> 
  </tr> 
  <tr> 
   <td>defaultFallback(1.6.0 开始)</td> 
   <td>默认的 fallback 函数名称，可选项，通常用于通用的 fallback 逻辑(即可以用于很多服务或方法)。默认 fallback 函数可以针对所有类型的异常(除了 exceptionsToIgnore 里面排除掉的异常类型)进行处理。若同时配置了 fallback 和 defaultFallback，则只有 fallback 会生效。defaultFallback 函数签名要求： ♞ 返回值类型必须与原函数返回值类型一致； ♞ 方法参数列表需要为空，或者可以额外多一个 Throwable 类型的参数用于接收对应的异常。 ♞ defaultFallback 函数默认需要和原方法在同一个类中。若希望使用其他类的函数，则可以指定 fallbackClass 为对应的类的 Class 对象，注意对应的函数必需为 static 函数，否则无法解析。</td> 
  </tr> 
  <tr> 
   <td>exceptionsToIgnore(1.6.0 开始)</td> 
   <td>用于指定哪些异常被排除掉，不会计入异常统计中，也不会进入 fallback 逻辑中，而是会原样抛出。</td> 
  </tr> 
  <tr> 
   <td>entryType</td> 
   <td>entry 类型，可选项(默认为 EntryType.OUT)</td> 
  </tr> 
 </tbody> 
</table>

blockHandler/blockHandlerClass

在`hailtaxi-driver`中找到`DriverController`中的`info`方法，用户在打车的时候，会查询司机信息，如果司机不存在，此时会报错，代码改造如下：

/****
         * 司机信息
         */
    @GetMapping(value = "/info/{id}")
    //@RequestMapping(value = "/info/{id}")
    public Driver info(@PathVariable(value = "id")String id){
         // 去掉参数上的HttpServletRequest request
        log.info("当前服务占用的端口为:{}",port);
        Driver driver = driverService.findById(id);
        if (driver==null) {
        
            throw new RuntimeException("司机id="+id+"不存在");
        }
        return driver;
    }

如果此时访问：http://localhost:18081/driver/info/3 查询司机信息，如果没有ID为3的司机信息，会报如下错误，

![在这里插入图片描述][d89d99eda53646ea921f081fb0ab36d3.png]

这种体验非常差，我们可以集成Sentinel使用`@SentinelResource`的`blockHandler`返回默认错误信息，形成**降级**！！！

1、Sentinel 支持在程序中抛出它定义的`BlockException`异常，该异常会被Sentinel捕获，然后走降级方法，

为`info()`方法添加一个`@SentinelResource`注解，用来标注资源，表示当前方法需要执行限流、降级，在注解中添加value属性，用来标注资源，说白了就是给当前资源起个名字，blockHandler用来表示当前方法发生`BlockException`异常的时候，将处理流程交给指定的方法`blockExHandler()`处理,此时`blockExHandler()`方法必须和抛出异常的方法在同一个类中，这是一种降级操作，代码如下：

/****
         * 司机信息
         */
    @SentinelResource(value = "info",blockHandler = "blockExHandler")
    @RequestMapping(value = "/info/{id}")
    public Driver info(@PathVariable(value = "id")String id) throws BlockException {
        
        log.info("当前服务占用的端口为:{}",port);
        Driver driver = driverService.findById(id);
        if (driver==null) {
        
            //throw new RuntimeException("司机id="+id+"不存在");
            throw new SystemBlockException("info", "司机id="+id+"不存在",null); // 抛出BlockException
        }
        return driver;
    }
    
    /**
         * info资源出现BlockException后的降级处理
         */
    public Driver blockExHandler(String id,BlockException e) {
        
        Driver driver = new Driver();
        driver.setId(id);
        driver.setName("系统繁忙,稍后再试");
        return driver;
    }

![在这里插入图片描述][c7a03a127c9444c1a41a37ee0283613f.png]

> 注意：
> 
> 如果blockHandler方法和资源方法不在同一个类中，我们可以在`@SentinelResource`中添加`blockHandlerClass`属性，指定降级处理类的方法所在的类，且要求blockHandler方法是静态的，代码如下：
> 
>     @SentinelResource(value = "info",blockHandler = "blockExHandler",blockHandlerClass = "xxx.xxx.Xxxx")

2、启动测试，访问：http://localhost:18081/driver/info/3 测试出错效果如下：

![在这里插入图片描述][1c2229a539eb436a8b2131c20602cdb4.png]

fallback/fallbackClass

1、如果我们希望抛出任何异常都能处理，都能调用默认处理方法，而并非只是`BlockException`异常才调用，此时可以使用`@SentinelResource`的`fallback`属性，代码如下：

/****
         * 司机信息
         */
    @SentinelResource(value = "info"/*,blockHandler = "blockExHandler"*/,fallback = "exHandler")
    @RequestMapping(value = "/info/{id}")
    public Driver info(@PathVariable(value = "id")String id) throws BlockException {
        
        log.info("当前服务占用的端口为:{}",port);
        Driver driver = driverService.findById(id);
        if (driver==null) {
        
            throw new RuntimeException("司机id="+id+"不存在");
            // throw new SystemBlockException("info", "司机id="+id+"不存在",null); // 抛出BlockException
        }
        return driver;
    }
    /**
         * info资源出现任何类型异常后的降级处理
         * 方法参数可以添加一个Throwable 类型的参数，也可不添加
         */
    public Driver exHandler(String id,Throwable e) {
        
        Driver driver = new Driver();
        driver.setId(id);
        driver.setName("系统繁忙,稍后再试");
        return driver;
    }

> 注意：
> 
> 如果fallback方法和当前的资源方法不在同一个类中，可以使用`@SentinelResource`注解的`fallbackClass`实现，也要求fallback方法是静态的，代码如下：
> 
>     @SentinelResource(value = "info",fallback ="exHandler" ,fallbackClass = "xx.xxx.xxx.xx.Xxx")

2、访问 http://localhost:18081/driver/info/3 测试出错效果如下：

![在这里插入图片描述][7e815829fb034ad9acb68d09b505e6c0.png]

defaultFallback

上面无论是`blockHandler`还是`fallback`，每个方法发生异常，都要为方法独立创建一个处理异常的方法，效率非常低，我们可以使用`@SentinelResource`注解的`defaultFallback`属性，为一个类指定一个全局的处理错误的方法，代码如下：

@RestController
    @RequestMapping(value = "/driver")
    @Slf4j
    @RefreshScope
    @SentinelResource(defaultFallback = "defaultExHandler")
    public class DriverController {
        
        @Autowired
        private DriverService driverService;
    
        public Driver defaultExHandler(Throwable e) {
        
            Driver driver = new Driver();
            driver.setName("系统繁忙,稍后再试");
            return driver;
        }
    
        /****
         * 司机信息
         */
        //@SentinelResource(value = "info"/*,blockHandler = "blockExHandler"*/,fallback = "exHandler")
        @SentinelResource("info")
        @RequestMapping(value = "/info/{id}")
        public Driver info(@PathVariable(value = "id")String id) throws BlockException {
        
            log.info("当前服务占用的端口为:{}",port);
            Driver driver = driverService.findById(id);
            if (driver==null) {
        
                throw new RuntimeException("司机id="+id+"不存在");
                // throw new SystemBlockException("info", "司机id="+id+"不存在",null); // 抛出BlockException
            }
            return driver;
        }

访问 http://localhost:18081/driver/info/3 效果如下：

![在这里插入图片描述][4911fdf1217642eba69d72a07bc7a2ac.png]

#### 2.2 Sentinel的规则 ####

查看：[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E8%A7%84%E5%88%99%E7%9A%84%E7%A7%8D%E7%B1%BB][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E8_A7_84_E5_88_99_E7_9A_84_E7_A7_8D_E7_B1_BB]

Sentinel 的所有规则都可以在内存态中动态地查询及修改，修改之后立即生效。同时 Sentinel 也提供相关 API，供您来定制自己的规则策略。

Sentinel 支持以下几种规则：**流量控制规则**、**熔断降级规则**、**系统保护规则**、**来源访问控制规则** 和 **热点参数规则**。

##### 2.2.1 流量控制规则 (FlowRule) #####

查看：

[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6%E8%A7%84%E5%88%99-flowrule][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E6_B5_81_E9_87_8F_E6_8E_A7_E5_88_B6_E8_A7_84_E5_88_99-flowrule]

[https://github.com/alibaba/Sentinel/wiki/%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6][https_github.com_alibaba_Sentinel_wiki_E6_B5_81_E9_87_8F_E6_8E_A7_E5_88_B6]

流量规则的定义，重要属性如下：

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

同一个资源可以同时有多个限流规则，检查规则时会依次检查

> strategy限流策略说明：
> 
>     直接:资源达到限流条件时，直接限流。
>     
>     关联:A资源关联B资源，当关联的B资源达到阈值限流时，A资源也会被限流。
>     
>     链路:对于某资源C，有两个入口，从资源A->C,从资源B->C, 通过指定入口资源可以达到只记录从该入口进来的流量（指定资源从入口资源进来的流量，如果达到阈值，就可以对其限流）。
> 
> controlBehavior流控说明：
> 
>     直接拒绝:请求直接失败。
>     WarmUp:当系统长期处于低水位的情况下，当流量突然增加时，直接把系统拉升到高水位可能瞬间把系统压垮。通过"冷启动"，让通过的流量缓慢增加，在一定时间内逐渐增加到阈值上限，给冷系统一个预热的时间，避免冷系统被压垮。
>     排队等待:排队处理请求。

理解上面规则的定义之后，我们可以通过调用 `FlowRuleManager.loadRules()` 方法来用硬编码的方式定义流量控制规则。

QPS流量控制

1、我们先实现基于QPS流量控制，在`hailtaxi-driver`的`DriverApplication`启动类上添加如下方法加载限流规则，当`DriverApplication`初始化完成之后加载规则，代码如下：

/***
     * 初始化规则
     */
    @PostConstruct
    private void initFlowRule() {
        
        //规则集合
        List<FlowRule> rules = new ArrayList<FlowRule>();
        //定义一个规则
        FlowRule rule = new FlowRule("info");
        // 设置阈值
        rule.setCount(2);
        //设置限流阈值类型
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        //default，代表不区分调用来源
        rule.setLimitApp("default");
        //设置流控效果
        rule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT);
        //将定义的规则添加到集合中
        rules.add(rule);
        //加载规则
        FlowRuleManager.loadRules(rules);
    }

2、访问 http://localhost:18081/driver/info/1 此时不会抛出异常，但是频繁刷新，则会调用降级方法，效果如下：

![在这里插入图片描述][757aac4b9d3d4d24b3c115827efc09a6.png]

线程数流量控制

1、我们修改限流阈值类型，代码如下：

@PostConstruct
    public void initFlowRule() {
        
        //规则集合
        List<FlowRule> rules = new ArrayList<>();
        // 定义一个规则
        FlowRule rule = new FlowRule("info");
        // 设置基流量控制 的类型
        rule.setGrade(RuleConstant.FLOW_GRADE_THREAD);//默认是qps
        //设置流量阈值
        rule.setCount(2);
        // 将 规则添加到 集合中
        rules.add(rule);
        // 加载规则
        FlowRuleManager.loadRules(rules);
    }

2、此时再来访问`http://localhost:18081/driver/info/1`我们发现用浏览器无论怎么访问都不会出现降级现象，但是如果用Jmeter模拟多个线程，效果就不一样了,效果如下：

![在这里插入图片描述][bf83a2d529994205a8f15056b7188504.png]

##### 2.2.2 熔断降级规则 (DegradeRule) #####

参看：

[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7%E8%A7%84%E5%88%99-degraderule][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_86_94_E6_96_AD_E9_99_8D_E7_BA_A7_E8_A7_84_E5_88_99-degraderule]

[https://github.com/alibaba/Sentinel/wiki/%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7][https_github.com_alibaba_Sentinel_wiki_E7_86_94_E6_96_AD_E9_99_8D_E7_BA_A7]

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

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

同一个资源可以同时有多个降级规则。

理解上面规则的定义之后，我们可以通过调用 `DegradeRuleManager.loadRules()` 方法来用硬编码的方式定义熔断规则，

1、在`DriverApplication`规则定义如下：

@PostConstruct
    public void initDegradeRule() {
        
        List<DegradeRule> rules = new ArrayList<>();
        DegradeRule rule = new DegradeRule();
        // 设置资源名称
        rule.setResource("info");
        /**
             * 设置熔断策略
             * DEGRADE_GRADE_RT:平均响应时间
             * DEGRADE_GRADE_EXCEPTION_RATIO:异常比例数量
             * DEGRADE_GRADE_EXCEPTION_COUNT:异常数
             */
        rule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_COUNT);
        //设置阈值
        rule.setCount(2);
        //设置 熔断时长
        rule.setTimeWindow(30);
        // 统计时长（单位为 ms） 默认1000
        rule.setStatIntervalMs(60*1000);
        //将规则添加到集合中
        rules.add(rule);
        DegradeRuleManager.loadRules(rules);
    }

2、首先访问：http://localhost:18081/driver/info/1 ，确保没问题，

其次访问：http://localhost:18081/driver/info/3，多访问几次，造成熔断（5+2=7）

然后在访问：http://localhost:18081/driver/info/1，会发现已经有熔断降级效果了，

且查看服务控制台，发现不会有信息输出，表明已经熔断了，且从页面展示效果来看走了降级

![在这里插入图片描述][b2720cb045824e91a50154d80eaff335.png]

等待30s后，再次访问：http://localhost:18081/driver/info/1，查看熔断是否结束！

##### 2.2.3 系统保护规则 (SystemRule) #####

参考：

[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E7%B3%BB%E7%BB%9F%E4%BF%9D%E6%8A%A4%E8%A7%84%E5%88%99-systemrule][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_B3_BB_E7_BB_9F_E4_BF_9D_E6_8A_A4_E8_A7_84_E5_88_99-systemrule]

[https://github.com/alibaba/Sentinel/wiki/%E7%B3%BB%E7%BB%9F%E8%87%AA%E9%80%82%E5%BA%94%E9%99%90%E6%B5%81][https_github.com_alibaba_Sentinel_wiki_E7_B3_BB_E7_BB_9F_E8_87_AA_E9_80_82_E5_BA_94_E9_99_90_E6_B5_81]

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

系统规则包含下面几个重要的属性：

<table> 
 <thead> 
  <tr> 
   <th>Field</th> 
   <th>说明</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>highestSystemLoad</td> 
   <td><code>load1</code> 触发值，用于触发自适应控制阶段</td> 
   <td>-1 (不生效)</td> 
  </tr> 
  <tr> 
   <td>avgRt</td> 
   <td>所有入口流量的平均响应时间</td> 
   <td>-1 (不生效)</td> 
  </tr> 
  <tr> 
   <td>maxThread</td> 
   <td>入口流量的最大并发数</td> 
   <td>-1 (不生效)</td> 
  </tr> 
  <tr> 
   <td>qps</td> 
   <td>所有入口资源的 QPS</td> 
   <td>-1 (不生效)</td> 
  </tr> 
  <tr> 
   <td>highestCpuUsage</td> 
   <td>当前系统的 CPU 使用率（0.0-1.0）</td> 
   <td>-1 (不生效)</td> 
  </tr> 
 </tbody> 
</table>

理解上面规则的定义之后，我们可以通过调用 `SystemRuleManager.loadRules()` 方法来用硬编码的方式定义流量控制规则。

1、在`hailtaxi-driver`的`DriverApplication`中创建如下方法，代码如下：

/***
     * 系统自我保护
     */
    @PostConstruct
    private void initSystemRule() {
        
        //系统自我保护集合
        List<SystemRule> rules = new ArrayList<>();
        //创建系统自我保护规则
        SystemRule rule = new SystemRule();
        //CPU使用率 值为[0,1],-1 (不生效)
        rule.setHighestCpuUsage(0.2);
        //所有入口资源的 QPS,-1 (不生效)
        rule.setQps(10);
        //入口流量的最大并发数,-1 (不生效)
        rule.setMaxThread(5);
        //所有入口流量的平均响应时间,单位：毫秒,-1 (不生效)
        rule.setAvgRt(1000);
        //load1 触发值，用于触发自适应控制阶段,系统最高负载，建议取值 CPU cores * 2.5
        rule.setHighestSystemLoad(20);
        //将规则加入到集合
        rules.add(rule);
        SystemRuleManager.loadRules(rules);
    }

我们可以测试CPU使用率自我保护，使用`jmeter`测试如下：

![在这里插入图片描述][f31fce74df7c4064895cfde1232158c0.png]

##### 2.2.4 访问控制规则 (AuthorityRule) #####

参看：

[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E8%AE%BF%E9%97%AE%E6%8E%A7%E5%88%B6%E8%A7%84%E5%88%99-authorityrule][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E8_AE_BF_E9_97_AE_E6_8E_A7_E5_88_B6_E8_A7_84_E5_88_99-authorityrule]

[https://github.com/alibaba/Sentinel/wiki/%E9%BB%91%E7%99%BD%E5%90%8D%E5%8D%95%E6%8E%A7%E5%88%B6][https_github.com_alibaba_Sentinel_wiki_E9_BB_91_E7_99_BD_E5_90_8D_E5_8D_95_E6_8E_A7_E5_88_B6]

很多时候，我们需要根据调用方来限制资源是否通过，这时候可以使用 Sentinel 的访问控制（黑白名单）的功能。黑白名单根据资源的请求来源（`origin`）限制资源是否通过，若配置白名单则只有请求来源位于白名单内时才可通过；若配置黑名单则请求来源位于黑名单时不通过，其余的请求通过。

授权规则，即黑白名单规则（`AuthorityRule`）非常简单，主要有以下配置项：

*  `resource`：资源名，即规则的作用对象
 *  `limitApp`：对应的黑名单/白名单，不同 origin 用 `,` 分隔，如 `appA,appB`
 *  `strategy`：限制模式，`AUTHORITY_WHITE` 为白名单模式，`AUTHORITY_BLACK` 为黑名单模式，默认为白名单模式

了解了以上规则后，可以通过`AuthorityRuleManager.loadRules`来加载规则

1、在`hailtaxi-driver`的`DriverApplication`中创建如下方法，代码如下：

@PostConstruct
        public void initAuthorityRule() {
        
            AuthorityRule rule = new AuthorityRule();
            rule.setResource("info");
            rule.setStrategy(RuleConstant.AUTHORITY_WHITE);
            rule.setLimitApp("127.0.0.1,appB");
            AuthorityRuleManager.loadRules(Collections.singletonList(rule));
        }
    
        /**
         * Sentinel提供了 RequestOriginParser 接口来处理访问来源，Sentinel保护的资源如果被访问，
         * 就会调用 RequestOriginParser解析访问来源
         */
        @Component
        public class IpLimiter implements RequestOriginParser{
        
    
            @Override
            public String parseOrigin(HttpServletRequest httpServletRequest) {
        
                return httpServletRequest.getRemoteAddr();
            }
        }

2、访问：http://localhost:18081/driver/info/1，不通过，走了降级

访问：http://127.0.0.1:18081/driver/info/1

##### 2.2.5 热点规则 (ParamFlowRule) #####

参看：[https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8\#%E7%83%AD%E7%82%B9%E8%A7%84%E5%88%99-paramflowrule][https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_83_AD_E7_82_B9_E8_A7_84_E5_88_99-paramflowrule]

何为热点？热点即经常访问的数据。

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

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

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

![在这里插入图片描述][ff86a98a21db481f8a2be8637e8e5ebf.png]

Sentinel 利用 LRU 策略统计最近最常访问的热点参数，结合令牌桶算法来进行参数级别的流控。热点参数限流支持集群模式。

要使用热点参数限流功能，需要引入以下依赖，将该依赖加入到`hailtaxi-driver`中：

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-parameter-flow-control</artifactId>
        <version>1.8.1</version>
    </dependency>

然后为对应的资源配置热点参数限流规则，并在 `entry` 的时候传入相应的参数，即可使热点参数限流生效。

**热点参数规则（`ParamFlowRule`）类似于流量控制规则（`FlowRule`）：**

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>resource</td> 
   <td>资源名，必填</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>限流阈值，必填</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>grade</td> 
   <td>限流模式</td> 
   <td>QPS 模式</td> 
  </tr> 
  <tr> 
   <td>durationInSec</td> 
   <td>统计窗口时间长度（单位为秒），1.6.0 版本开始支持</td> 
   <td>1s</td> 
  </tr> 
  <tr> 
   <td>controlBehavior</td> 
   <td>流控效果（支持快速失败和匀速排队模式），1.6.0 版本开始支持</td> 
   <td>快速失败</td> 
  </tr> 
  <tr> 
   <td>maxQueueingTimeMs</td> 
   <td>最大排队等待时长（仅在匀速排队模式生效），1.6.0 版本开始支持</td> 
   <td>0ms</td> 
  </tr> 
  <tr> 
   <td>paramIdx</td> 
   <td>热点参数的索引，必填，对应 <code>SphU.entry(xxx, args)</code> 中的参数索引位置</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>paramFlowItemList</td> 
   <td>参数例外项，可以针对指定的参数值单独设置限流阈值，不受前面 <code>count</code> 阈值的限制。<strong>仅支持基本类型和字符串类型</strong></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>clusterMode</td> 
   <td>是否是集群参数流控规则</td> 
   <td><code>false</code></td> 
  </tr> 
  <tr> 
   <td>clusterConfig</td> 
   <td>集群流控相关配置</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

我们可以通过 `ParamFlowRuleManager` 的 `loadRules` 方法更新热点参数规则

1、在`DriverController`中创建一个司机筛选方法，比如根据城市来筛选，在`DriverController`中创建一个方法：

/***
         * 搜素指定城市的司机
         */
    @SentinelResource(value = "search")
    @GetMapping(value = "/search/{city}")
    public Driver search(@PathVariable(value = "city")String city){
        
        System.out.println("查询的司机所在城市："+city);
        //假设查询到了一个司机信息
        Driver driver = new Driver();
        driver.setName("唐僧老师");
        driver.setId("No.1");
        return driver;
    }

2、对热门参数进行控制，对热点数据执行特殊限流，比如资源参数列表中的第一个参数值为`恩施`的时候执行限流，在`DriverApplication`中创建限流配置，代码如下：

/***
     * 热点参数初始化
     */
    @PostConstruct
    private static void initParamFlowRules() {
        
        ParamFlowRule rule = new ParamFlowRule("search")
                //参数下标为0
                .setParamIdx(0)
                //限流模式为QPS
                .setGrade(RuleConstant.FLOW_GRADE_QPS)
                //统计窗口时间长度（单位为秒）
                .setDurationInSec(10)
                //流控效果（支持快速失败和匀速排队模式）
                //CONTROL_BEHAVIOR_DEFAULT：限流行为，直接拒绝
                //CONTROL_BEHAVIOR_WARM_UP:限流行为，匀速排队
                //CONTROL_BEHAVIOR_RATE_LIMITER：限流行为，匀速排队
                .setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_DEFAULT)
                //最大排队等待时长（仅在匀速排队模式生效  CONTROL_BEHAVIOR_RATE_LIMITER）
                //.setMaxQueueingTimeMs(600)
                //最大阈值为5
                .setCount(5);
    
        // 为特定参数单独设置规则
        //如下配置：当参数值为恩施的时候，阈值到达2的时候则执行限流
        ParamFlowItem item = new ParamFlowItem()
                //参数类型为String类型
                .setClassType(String.class.getName())
                //设置阈值为2
                .setCount(2)
                //需要统计的值
                .setObject(String.valueOf("恩施"));
        rule.setParamFlowItemList(Collections.singletonList(item)); //返回的是不可变的集合，但是这个长度的集合只有1，可以减少内存空间
        //加载热点数据
        ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
    }

2、我们访问 http://localhost:18081/driver/search/天津/ 的时候，连续执行5次，才会限流，

我们访问 http://localhost:18081/driver/search/恩施/ 的时候，连续执行2次，就会限流，

#### 2.3 OpenFeign支持 ####

参看：

[https://github.com/alibaba/spring-cloud-alibaba/wiki/Sentinel\#feign-%E6%94%AF%E6%8C%81][https_github.com_alibaba_spring-cloud-alibaba_wiki_Sentinel_feign-_E6_94_AF_E6_8C_81]

Sentinel 适配了 [Feign][] 组件。如果想使用，除了外还需要 2 个步骤：

1：引入 `spring-cloud-starter-alibaba-sentinel` 的依赖
    2：加入 spring-cloud-starter-openfeign 依赖
    3：配置文件打开 Sentinel 对 Feign 的支持：feign.sentinel.enabled=true

![在这里插入图片描述][73261ec1e48c448c9e56360afb083912.png]

在上面案例中，我们可以实现用户打车成功调用`hailtaxi-order`执行下单，并且通过feign调用`hailtaxi-driver`修改司机状态，此时我们可以使用Sentinel实现Feign调用降级、限流。

> 注意：
> 
> 在进行操作之前，可以先将`hailtaxi-driver`中的访问控制规则注释掉，注释掉`DriverApplication#initAuthorityRule`，`DriverApplication#initSystemRule`上的注解即可

1、在`hailtaxi-order`中引入`sentinel`和`OpenFeign`依赖，配置如下：

<dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
        <version>2.2.5.RELEASE</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>

2、在`hailtaxi-order`的配置文件中开启Feign支持`sentinel`，配置如下：

feign:
      #开启Sentinel对Feign的支持
      sentinel:
        enabled: true

> 注意：现在配置信息都存放在了`nacos`中，所以找到`hailtaxi-order.yaml`的Data ID配置，将以上配置添加进去！
> 
> ![在这里插入图片描述][a462d56da8544b7b9e140c81d717846e.png]

> 注意修改完后一定要发布才能生效！！！

3、因为`hailtaxi-order`要通过`openfeign`去调用`hailtaxi-driver`中的`DriverController#status`方法，改造一下该方法

/****
         * 更新司机信息
         */
    @PutMapping(value = "/status/{id}/{status}")
    public Driver status(@PathVariable(value = "id")String id,@PathVariable(value = "status")Integer status) throws Exception {
        
        log.info("当前服务占用的端口为:{}",port);
        //修改状态
        driverService.update(id,status);
        //修改状态后的司机信息
        Driver driver = driverService.findById(id);
        if (driver == null) {
        
            throw new RuntimeException("学生id="+id+",不存在");
        }
        return driver;
    }

> 模拟被调用服务出现异常的情况

3、先验证正确性，启动`hailtaxi-gateway`，`hailtaxi-order`，`hailtaxi-driver`服务，使用postman访问：

http://localhost:8001/order

4、为了测试程序异常能实现降级操作，我们在`hailtaxi-order`中将`OrderInfoController.add()`方法的司机ID改成一个不存在的司机ID，让程序报错，测试降级处理，代码如下：

/***
         * 下单
         */
    @PostMapping
    public OrderInfo add(){
        
        //修改司机信息  司机ID=1
        Driver driver = driverFeign.status("3",2);// 改成一个不存在的id
        //创建订单
        OrderInfo orderInfo = new OrderInfo("No"+((int)(Math.random()*10000)), (int)(Math.random()*100), new Date(), "深圳北站", "罗湖港", driver);
        orderInfoService.add(orderInfo);
        return orderInfo;
    }

![在这里插入图片描述][a2875e6895c349a49be98d54a98228d5.png]

5、再次启动测试：

![在这里插入图片描述][9b4eda886f334d5badd77d8939003d94.png]

注意：服务调用出错要进行降级操作有两个地方都可以进行，一是在被调用方进行降级，一是在调用方进行降级，

在被调用方进行降级前面已经讲过了，所以接下来讲解如何在调用方（openfeign）结合 sentinel 进行降级处理。

##### 2.3.1 fallback #####

在`hailtaxi-api`模块中找到`DriverFeign`接口：

1、为Feign接口创建一个实现类：`com.itheima.driver.feign.fallback.DriverFeignFallback`，在实现类中处理程序异常降级处理方法，代码如下：

package com.itheima.driver.feign.fallback;
    
    import com.itheima.driver.feign.DriverFeign;
    import com.itheima.driver.model.Driver;
    import org.springframework.stereotype.Component;
    
    @Component
    public class DriverFeignFallback implements DriverFeign {
        
    
        /**
         * status()降级处理方法
         */
        @Override
        public Driver status(String id, Integer status) {
        
            Driver driver = new Driver();
            driver.setId(id);
            driver.setStatus(status);
            driver.setName("系统比较繁忙，请您稍后再试！");
            return driver;
        }
    }

2、在`DriverFeign`接口上添加`fallback`属性指定降级处理的类，代码如下：

@FeignClient(value = "hailtaxi-driver",fallback = DriverFeignFallback.class)

> 注意：修改了`hailtaxi-api`模块，最好`clean`，`package`！！

3、启动运行，会发生如下问题：

java.lang.AbstractMethodError: com.alibaba.cloud.sentinel.feign.SentinelContractHolder.parseAndValidatateMetadata(Ljava/lang/Class;)Ljava/util/List;

出现上面问题的主要原因是当前SpringCloud版本存在问题。

Hoxton.SR1` 中，`fegin.context`接口方法的定义为`parseAndValidatateMetadata` `Hoxton.SR3` 中，`fegin.context`接口方法的定义为`parseAndValidateMetadata

我们现在需要把`Hoxton.SR1`换成`Hoxton.SR3`，因此需要在`hailtaxi-parent`修改SpringCloud版本：

![在这里插入图片描述][7f4c3103673f4f0ab89da62d90864053.png]

将`SpringCloud`版本升级至`Hoxton.SR3`同时将`SpringBoot`版本升级至`2.2.10`，如上图：

https://github.com/spring-cloud/spring-cloud-release/wiki/Spring-Cloud-Hoxton-Release-Notes

此时我们测试，效果如下：

![在这里插入图片描述][ea6baf72631a442498684fb66a1b5c8b.png]

##### 2.3.2 fallbackFactory #####

我们可以为`DriverFeign`接口创建一个降级处理的工厂对象，在工厂对象中处理程序异常降级处理方法，用工厂对象处理可以拿到异常信息，代码如下：

1、创建：`com.itheima.driver.feign.fallback.DriverFeignFallbackFactory`

package com.itheima.driver.feign.fallback;
    
    import com.itheima.driver.feign.DriverFeign;
    import com.itheima.driver.model.Driver;
    import feign.hystrix.FallbackFactory;
    import org.springframework.stereotype.Component;
    
    @Component
    public class DriverFeignFallbackFactory implements FallbackFactory<DriverFeign> {
        
        @Override
        public DriverFeign create(Throwable throwable) {
        
            return new DriverFeign() {
        
                /**
                 * status()降级处理方法
                 */
                @Override
                public Driver status(String id, Integer status) {
        
                    Driver driver = new Driver();
                    driver.setId(id);
                    driver.setStatus(status);
                    driver.setName("系统比较繁忙，请您稍后再试！");
                    return driver;
                }
            };
        }
    }

2、在`DriverFeign`接口上添加`fallbackFactory`属性指定讲解处理的类，代码如下：

@FeignClient(value = "hailtaxi-driver",fallbackFactory = DriverFeignFallbackFactory.class)

3、再次启动测试，效果如下：

![在这里插入图片描述][884d78a3c6dd4f7fbe66c291b0e8c9da.png]

[https_github.com_alibaba_Sentinel_wiki_E4_B8_BB_E9_A1_B5]: https://github.com/alibaba/Sentinel/wiki/%E4%B8%BB%E9%A1%B5
[3674d811bb6646b88de548c6653606ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9f9006243b0a495bb73762681b99306a.png
[https_github.com_alibaba_Sentinel_wiki_E5_9C_A8_E7_94_9F_E4_BA_A7_E7_8E_AF_E5_A2_83_E4_B8_AD_E4_BD_BF_E7_94_A8-Sentinel_E5_90_8C_E7_B1_BB_E7_BB_84_E4_BB_B6_E5_8A_9F_E8_83_BD_E5_AF_B9_E6_AF_94]: https://github.com/alibaba/Sentinel/wiki/%E5%9C%A8%E7%94%9F%E4%BA%A7%E7%8E%AF%E5%A2%83%E4%B8%AD%E4%BD%BF%E7%94%A8-Sentinel#%E5%90%8C%E7%B1%BB%E7%BB%84%E4%BB%B6%E5%8A%9F%E8%83%BD%E5%AF%B9%E6%AF%94
[39bf3491c6154b4f8fd6cf7971729fdb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/44dada3ae14c4c98af7a26b6355fb918.png
[64d3f13639a94f80a197c102d16332a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/60554436b55c4ef09e9ab2791d008c5b.png
[dae772b25a884be9bf9f51be5473de48.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/3c0e08107c2d493d9d0740bf7bec2a47.png
[https_github.com_alibaba_Sentinel_wiki_E6_B3_A8_E8_A7_A3_E6_94_AF_E6_8C_81]: https://github.com/alibaba/Sentinel/wiki/%E6%B3%A8%E8%A7%A3%E6%94%AF%E6%8C%81
[d89d99eda53646ea921f081fb0ab36d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7e8d945c0bc7433b86f6316f76a9f0c9.png
[c7a03a127c9444c1a41a37ee0283613f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/641a478f07054339aad68710067a8beb.png
[1c2229a539eb436a8b2131c20602cdb4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7369618c03ae4379bba7e2b444f7c958.png
[7e815829fb034ad9acb68d09b505e6c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/d167b633b72c470aadee58b1af6820fc.png
[4911fdf1217642eba69d72a07bc7a2ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/a39f104a98ec48ed9dcdd3d2eae765b7.png
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E8_A7_84_E5_88_99_E7_9A_84_E7_A7_8D_E7_B1_BB]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E8%A7%84%E5%88%99%E7%9A%84%E7%A7%8D%E7%B1%BB
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E6_B5_81_E9_87_8F_E6_8E_A7_E5_88_B6_E8_A7_84_E5_88_99-flowrule]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6%E8%A7%84%E5%88%99-flowrule
[https_github.com_alibaba_Sentinel_wiki_E6_B5_81_E9_87_8F_E6_8E_A7_E5_88_B6]: https://github.com/alibaba/Sentinel/wiki/%E6%B5%81%E9%87%8F%E6%8E%A7%E5%88%B6
[757aac4b9d3d4d24b3c115827efc09a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7e441a4c34a64097a9982681ffd3537d.png
[bf83a2d529994205a8f15056b7188504.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/78de8df087ca4748b3fce8dea0cc6f39.png
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_86_94_E6_96_AD_E9_99_8D_E7_BA_A7_E8_A7_84_E5_88_99-degraderule]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7%E8%A7%84%E5%88%99-degraderule
[https_github.com_alibaba_Sentinel_wiki_E7_86_94_E6_96_AD_E9_99_8D_E7_BA_A7]: https://github.com/alibaba/Sentinel/wiki/%E7%86%94%E6%96%AD%E9%99%8D%E7%BA%A7
[b2720cb045824e91a50154d80eaff335.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1d62cc5658914b798638dbdd34157feb.png
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_B3_BB_E7_BB_9F_E4_BF_9D_E6_8A_A4_E8_A7_84_E5_88_99-systemrule]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E7%B3%BB%E7%BB%9F%E4%BF%9D%E6%8A%A4%E8%A7%84%E5%88%99-systemrule
[https_github.com_alibaba_Sentinel_wiki_E7_B3_BB_E7_BB_9F_E8_87_AA_E9_80_82_E5_BA_94_E9_99_90_E6_B5_81]: https://github.com/alibaba/Sentinel/wiki/%E7%B3%BB%E7%BB%9F%E8%87%AA%E9%80%82%E5%BA%94%E9%99%90%E6%B5%81
[f31fce74df7c4064895cfde1232158c0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1f139975ebb846b8af8a22139183eb8e.png
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E8_AE_BF_E9_97_AE_E6_8E_A7_E5_88_B6_E8_A7_84_E5_88_99-authorityrule]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E8%AE%BF%E9%97%AE%E6%8E%A7%E5%88%B6%E8%A7%84%E5%88%99-authorityrule
[https_github.com_alibaba_Sentinel_wiki_E9_BB_91_E7_99_BD_E5_90_8D_E5_8D_95_E6_8E_A7_E5_88_B6]: https://github.com/alibaba/Sentinel/wiki/%E9%BB%91%E7%99%BD%E5%90%8D%E5%8D%95%E6%8E%A7%E5%88%B6
[https_github.com_alibaba_Sentinel_wiki_E5_A6_82_E4_BD_95_E4_BD_BF_E7_94_A8_E7_83_AD_E7_82_B9_E8_A7_84_E5_88_99-paramflowrule]: https://github.com/alibaba/Sentinel/wiki/%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8#%E7%83%AD%E7%82%B9%E8%A7%84%E5%88%99-paramflowrule
[ff86a98a21db481f8a2be8637e8e5ebf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/c17ce48cfd5f4687ac78b25f603f7d46.png
[https_github.com_alibaba_spring-cloud-alibaba_wiki_Sentinel_feign-_E6_94_AF_E6_8C_81]: https://github.com/alibaba/spring-cloud-alibaba/wiki/Sentinel#feign-%E6%94%AF%E6%8C%81
[Feign]: https://github.com/OpenFeign/feign
[73261ec1e48c448c9e56360afb083912.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/62f6303ff07a4377a7b01a830db2b1b7.png
[a462d56da8544b7b9e140c81d717846e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/3618283c64fa4cc0a36c382ca349f974.png
[a2875e6895c349a49be98d54a98228d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/535e7a7f22c9474a9fce967d826c4931.png
[9b4eda886f334d5badd77d8939003d94.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9aa21b3f4e1b4699ae4b9968a702ef82.png
[7f4c3103673f4f0ab89da62d90864053.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/8261a37c3a4c42a78b48f015cf841f8e.png
[ea6baf72631a442498684fb66a1b5c8b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/6f595798e66f4f358e4431e403bc2a18.png
[884d78a3c6dd4f7fbe66c291b0e8c9da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/a533fcb3ff1e4f418aa1f00297941679.png