SpringCloud——Sentinel初步了解

最新推荐文章于 2024-05-18 23:43:46 发布

一枝酸橘子

最新推荐文章于 2024-05-18 23:43:46 发布

阅读量131

点赞数

文章标签： spring cloud sentinel java

本文链接：https://blog.csdn.net/m0_48777987/article/details/133207791

版权

Sentinel

Sentinel的本质是实现服务容错。试想当许多用户访问同一个页面时，这个后台是否能承受住这么多次的访问？这时就需要用到Sentinel这个服务工具了！并且在微服务架构中，服务与服务之间多存在互相调用的关系，如果一个服务出现问题，另一个服务会随之出现网络延迟，此时若有大量请求进行访问，则会造成任务堆积，造成服务瘫痪。这也是高并发带来的问题。

关于服务雪崩？

在分布式系统中,由于网络原因或自身的原因,服务一般无法保证 100% 可用。如果一个服务出现了

问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等

待，进而导致服务瘫痪。

由于服务与服务之间的依赖性，故障会传播，会对整个微服务系统造成灾难性的严重后果，这就是

服务故障的 “雪崩效应” 。

雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某

台机器的资源耗尽。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问

题，不会影响到其它服务的正常运行。也就是＂雪落而不雪崩＂。

💡 简而言之，当服务层层嵌套，一个服务出现问题时，其它服务也会随之“宕机”，这就是服务雪崩效应。

常见容错方案

为防止服务雪崩带来程序崩溃，这里就需要采取容错措施了！

常见的容错措施有隔离、限流、熔断、降级、超时。

隔离

将有关系的服务分为一个模块，保证模块间是互相独立，毫不关联的。

当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的系统服务。常见的隔离方式有：线程池隔离和信号量隔离。

限流

顾名思义，限制某个服务单位时间内的访问流量，当服务访问量达到限定额度时，采取一定措施限制流量。

熔断

在互联网系统中，当下游服务因访问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫做熔断。

服务熔断一般有三种状态：

熔断关闭状态（Closed）

服务没有故障时，熔断器所处的状态，对调用方的调用不做任何限制

熔断开启状态（Open）

后续对该服务接口的调用不再经过网络，直接执行本地的fallback方法

半熔断状态（Half-Open）

尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。如果成功率达到预

期，则说明服务已恢复，进入熔断关闭状态；如果成功率仍旧很低，则重新进入熔断关闭状态。

降级

当服务无法正常调用时，将会有一个备用方案执行。

超时

对访问设定一个超时时间（可以是等待访问的最大限度时间），一旦超过这个设定时间，则访问请求失败。

在上游服务调用下游服务的时候，设置一个最大响应时间，如果超过这个时间，下游未作出反应，就断开请求，释放掉线程。

什么是Sentinel

Sentinel是阿里开源的一套服务容错解决方案，以流量为切入点，从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。Sentinel具有以下特征：

丰富的应用场景，包括秒杀、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。
实时监控，提供单台机器秒级数据监控和小规模集群的汇总运行情况监控。
广泛的开源生态，提供与Spring Cloud、Dubbo、gRPC的整合。
完善的SPI扩展点，提供简单易用、完善的SPI扩展接口，例如定制规则管理、适配动态数据源等。

Sentinel分为两个部分：核心库（Java客户端）和控制台（Dashboard）。

微服务集成Sentinel

为微服务集成Sentinel非常简单, 只需要加入Sentinel的依赖即可

1 在pom.xml中加入下面依赖

在商品模块添加依赖

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

2 编写一个Controller测试使用


import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Product1Controller {
    @RequestMapping("/product/message1")
    public String message1() {
        return "message1";
    }
}

  cloud:
    sentinel:
      transport:
        port: 18080 #跟控制台交流的端口,随意指定一个未使用的端口即可
        dashboard: 127.0.0.1:9999 # 指定控制台服务的地址

安装Sentinel控制台

Sentinel 提供一个轻量级的控制台, 它提供机器发现、单机资源实时监控以及规则管理等功能。

1 下载jar包,解压到文件夹

https://github.com/alibaba/Sentinel/releases

2 启动控制台

# 简单启动
java -Dserver.port=9999 -jar sentinel-dashboard-1.7.0.jar

通过游览器访问localhost:9999进入控制台，用户名和密码都是sentinel。这时当你访问/product/message1后，sentinel控制台会显示此资源了！

Sentinel的概念和功能

基本概念

资源

资源就是Sentinel要保护的东西。

资源是 Sentinel 的关键概念。它可以是 Java 应用程序中的任何内容，可以是一个服务，也可以是一个方法，甚至可以是一段代码。

我们入门案例中的message1方法就可以认为是一个资源

规则

规则就是用来定义如何进行保护资源的，作用在资源之上, 定义以什么样的方式保护资源，主要包括流量控制规则、熔断降级规则以及系统

保护规则。

我们入门案例中就是为message1资源设置了一种流控规则, 限制了进入message1的流量

重要功能

Sentinel的主要功能就是容错，主要体现为下面这三个：

流量控制

流量控制在网络传输中是一个常用的概念，它用于调整网络包的数据。任意时间到来的请求往往是随机不可控的，而系统的处理能力是有限的。我们需要根据系统的处理能力对流量进行控制。

Sentinel 作为一个调配器，可以根据需要把随机的请求调整成合适的形状。

💡 简而言之，sentinel控制台可以为每一个资源设置单位时间（1s）内的最大访问阈值，一旦访问量超过阈值，则会触发定义的异常返回。

熔断降级

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

Sentinel 对这个问题采取了两种手段:

通过并发线程数进行限制

Sentinel 通过限制资源并发线程的数量，来减少不稳定资源对其它资源的影响。当某个资源出现不稳定的情况下，例如响应时间变长，对资源的直接影响就是会造成线程数的逐步堆积。当线程数在特定资源上堆积到一定的数量之后，对该资源的新请求就会被拒绝。堆积的线程完成任务后才开始继续接收请求。

通过响应时间对资源进行降级

除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。

当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。

系统负载保护

Sentinel 同时提供系统维度的自适应保护能力。当系统负载较高的时候，如果还持续让

请求进入可能会导致系统崩溃，无法响应。在集群环境下，会把本应这台机器承载的流量转发到其

它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，Sentinel 提供了对应的保

护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请

求。

总之一句话: 我们需要做的事情，就是在Sentinel的资源上配置各种各样的规则，来实现各种容错的功能。

Sentinel规则

流控规则

流量控制，其原理是监控应用流量的QPS(每秒查询率) 或并发线程数等指标，当达到指定的阈值时对流量进行控制，以避免被瞬时的流量高峰冲垮，从而保障应用的高可用性。

第 1 步: 点击簇点链路，我们就可以看到访问过的接口地址，然后点击对应的流控按钮，进入流控规则配置页面。新增流控规则界面如下:

资源名：唯一名称，默认是请求路径，可自定义

针对来源：指定对哪个微服务进行限流，默认指default，意思是不区分来源，全部限制

阈值类型/单机阈值：

QPS（每秒请求数量）: 当调用该接口的QPS达到阈值的时候，进行限流

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

是否集群：暂不需要集群

接下来我们以QPS为例来研究限流规则的配置。

简单配置

我们先做一个简单配置，设置阈值类型为QPS，单机阈值为 3 。即每秒请求量大于 3 的时候开始限流。

接下来，在流控规则页面就可以看到这个配置。

然后快速访问/order/message1接口，观察效果。此时发现，当QPS > 3的时候，服务就不能正常响应，而是返回**Blocked by Sentinel (flow limiting)**结果。

配置流控模式

点击上面设置流控规则的编辑按钮，然后在编辑页面点击高级选项，会看到有流控模式一栏

sentinel共有三种流控模式，分别是：

直接（默认）：接口达到限流条件时，开启限流

关联：当关联的资源达到限流条件时，开启限流 [适合做应用让步]

链路：当从某个接口过来的资源达到限流条件时，开启限流

下面呢分别演示三种模式：

直接流控模式

直接流控模式是最简单的模式，当指定的接口达到限流条件时开启限流。上面案例使用的就是直接流控模式。

💡 如果对请求中的共有资源进行直接流控限制，这拥有这个资源的请求都会被流控规则限制。

关联流控模式

关联流控模式指的是，当指定接口关联的接口达到限流条件时，开启对指定接口开启限流。

第 1 步：配置限流规则, 将流控模式设置为关联，关联资源设置为的 /order/message2。

第 3 步：向/order/message2连续发送请求

第 4 步：访问/order/message1,会发现已经被限流

链路流控模式

链路流控模式指的是，当从某个接口过来的资源达到限流条件时，开启限流。它的功能有点类似于针对来源配置项，区别在于：针对来源是针对上级微服务，而链路流控是针对上级接口，也就是说它的粒度更细。

第0 步: 添加依赖和配置

(1) 确保SpringCloud Alibaba的版本调整为2.1.0.RELEASE,

被限流的模块引入依赖(必须携带版本号1.7.0)

        <dependency>
            <groupId>com.alibaba.csp</groupId>
            <artifactId>sentinel-web-servlet</artifactId>
            <version>1.7.0</version>
        </dependency>

(2) 配置文件中关闭sentinel的CommonFilter实例化

spring:
  cloud:
    sentinel:
      filter:
        enabled: false

(3) 添加一个配置类，自己构建CommonFilter实例

在config包下面新建配置类


import com.alibaba.csp.sentinel.adapter.servlet.CommonFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterContextConfig {
    @Bean
    public FilterRegistrationBean sentinelFilterRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        registration.setFilter(new CommonFilter());
        registration.addUrlPatterns("/*");
// 入口资源关闭聚合
        registration.addInitParameter(CommonFilter.WEB_CONTEXT_UNIFY, "false");
        registration.setName("sentinelFilter");
        registration.setOrder(1);
        return registration;
    }
}

第 1 步：编写一个service，在里面添加一个方法message

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    @SentinelResource("message")
    public void message(){
        System.out.println("ProductService.message");
    }
}

第 2 步：在Controller中声明两个方法，分别调用service中的方法message

import com.itszt22.springcloud22.shopproduct.service.ProductService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class Product1Controller {

    @Resource
    private ProductService productService;

    @GetMapping("/product/message3")
    public String message3(){
        productService.message();
        return "message3";
    }

    @GetMapping("/product/message4")
    public String messag4(){
        productService.message();
        return "message4";
    }
}

第 4 步: 控制台配置限流规则

第 5 步: 分别通过/product/message3和/product/message4访问, 发现 4没问题, 3被限流了

此时从/product/message3访问message资源则会被流控规则限制。

Sentinel默认只标记Controller中的方法为资源，如果要标记其它方法，需要利用@SentinelResource注解

配置流控效果

快速失败（默认） : 直接失败，抛出异常，不做任何额外的处理，是最简单的效果。

Warm Up ：它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。

排队等待 ：让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待；它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃。

降级规则

降级规则就是设置当满足什么条件的时候，对服务进行降级，让服务在规定的时间内停止被访问。

流控规则和降级规则的区别？流控规则是统计1s内的资源流量，当1s内的资源流量超过限制后，则1s内超过的流量将会被限制。降级规则是统计1s内的资源状态（平均响应时间、异常比例、异常数），当超过规定资源状态后则接下来一段时间的访问将会被限制。

Sentinel提供了三个衡量条件：

平均响应时间：当资源的平均响应时间超过阈值（以 ms 为单位）之后，资源进入准降级状态。

如果接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，那么在接下的时间窗口（以 s 为单位）之内，就会对这个方法进行服务降级。

注意 Sentinel 默认统计的 RT 上限是 4900 ms，超出此阈值的都会算作 4900 ms，若需要

变更此上限可以通过启动配置项 -Dcsp.sentinel.statistic.max.rt=xxx 来配置。

异常比例：当资源的每秒异常总数占通过量的比值超过阈值之后，资源进入降级状态，即在接下的时间窗口（以 s 为单位）之内，对这个方法的调用都会自动地返回。异常比率的阈值范围是 [0.0,1.0]。

第 1 步: 首先模拟一个异常

第 2 步: 设置异常比例为0.25

int i = 0;
@RequestMapping("/product/message5")
public String message5() {
i++;
//异常比例为 0 .333
if (i % 3 == 0){
throw new RuntimeException();
}
return "message5";
}

异常数 ：当资源1 s的异常数目超过阈值之后会进行服务降级。

热点规则

热点参数流控规则是一种更细粒度的流控规则, 它允许将规则具体到参数上。

热点规则简单使用

第 1 步: 编写代码

第 2 步: 配置热点规则

		@RequestMapping("/product/message3")
    @SentinelResource("message3")//注意这里必须使用这个注解标识,否则热点规则不生效
    public String message3(String name, Integer age) {
        return name + age;
    }

第 3 步: 分别用两个参数访问,会发现只对第一个参数限流了

热点规则增强使用

参数例外项允许对一个参数的具体值进行流控，编辑刚才定义的规则,增加参数例外项

热点规则面对的参数仍然是索引0（p1），如果说p1的值为5，则满足参数例外项，此时阈值达到200，也就是说此时1秒内访问达到200次才会触发降级。所以下面在浏览器中访问，就可以得到testHotKey方法的返回值了。

如果说p1的值不是5，那么它的阈值仍然是上面的1，只要1秒内超过1次的访问，则直接触发降级。

授权规则

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源

访问控制的功能。来源访问控制根据资源的请求来源（origin）限制资源是否通过：

若配置白名单，则只有请求来源位于白名单内时才可通过；

若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过。

上面的资源名和授权类型不难理解，但是流控应用怎么填写呢？

其实这个位置要填写的是来源标识，Sentinel提供了RequestOriginParser接口来处理来源。

只要Sentinel保护的接口资源被访问，Sentinel就会调用RequestOriginParser的实现类去解析

访问来源。

第 1 步: 自定义来源处理规则

import com.alibaba.csp.sentinel.adapter.servlet.callback.RequestOriginParser;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;

@Component
public class RequestOriginParserDefinition implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {
        String serviceName = request.getParameter("serviceName");
        return serviceName;
    }
}

第 2 步: 授权规则配置

这个配置的意思是只有serviceName=pc不能访问(黑名单)

第 3 步: 访问 http://localhost:8091/product/message1?serviceName=pc观察结果

如果想对特殊的ip地址授权要怎么做呢？

第一步：自定义来源处理规则

@Component
public class RequestOriginParserDefinition implements RequestOriginParser {
    @Override
    public String parseOrigin(HttpServletRequest request) {

        String remoteHost = request.getRemoteHost();
//        String serviceName = request.getParameter("serviceName");
        return remoteHost;//此处返回的是ip地址
    }

第二步：授权规则配置

这里的流控应用应填ip地址。

💡 注意：如果ip地址填的是本机地址，在浏览器输入网址访问时应将localhost改为本机地址再访问！

系统规则了解

系统保护规则是从应用级别的入口流量进行控制，从单台机器的总体 Load、RT、入口 QPS 、CPU,使用率和线程数五个维度监控应用数据，让系统尽可能跑在最大吞吐量的同时保证系统整体的稳定性。

系统保护规则是应用整体维度的，而不是资源维度的，并且仅对入口流量 (进入应用的流量) 生效。

Load（仅对 Linux/Unix-like 机器生效）：当系统 load1 超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护。系统容量由系统的 maxQps * minRt 计算得出。设定参考值一般是 CPU cores * 2.5。

RT：当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。

线程数：当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。

入口 QPS：当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。

CPU使用率：当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护。

扩展: 自定义资源默认异常返回

注意: 默认异常处理器, 只能处理默认资源

import com.alibaba.csp.sentinel.adapter.servlet.callback.UrlBlockHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class ExceptionHandlerPage implements UrlBlockHandler {

    //BlockException 异常接口,包含Sentinel的五个异常
// FlowException 限流异常
// DegradeException 降级异常
// ParamFlowException 参数限流异常
// AuthorityException 授权异常
// SystemBlockException 系统负载异常

    private static final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public void blocked(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws IOException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        String data = "自定义阻塞异常返回结果";
        if (e instanceof FlowException) {
            data = "这是个流控异常";
        } else if (e instanceof DegradeException) {
            data = "这是个降级异常";
        }
        httpServletResponse.getWriter().write(objectMapper.writeValueAsString(data));
    }
}

特定资源异常处理

sentinel官方网址

在定义了资源点之后，我们可以通过Dashboard来设置限流和降级策略来对资源点进行保护。同时还能

通过@SentinelResource来指定出现异常时的处理策略。

@SentinelResource 用于定义资源，并提供可选的异常处理和 fallback 配置项。其主要参数如下:

定义限流和降级后的处理方法

方式一：直接将限流和降级方法定义在本类的方法中 (了解)

import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class Product2Controller {

    //注意 要根据@SentinelResource中的value属性进行配置规则, 且value属性不要和url值一样,否则会一半触发,一半不触发
    // 注意 如果controller方法有参数, 异常处理方法参数必须和controller方法参数完全一致
    @RequestMapping("/product2/message1")
    @SentinelResource(value = "message21",
            blockHandler = "blockMethod",
            fallback = "fallbackMethod")
    public String message21(){
        int i = 1/0;
        return "message21";
    }

    //BlockException时进入的方法
    //注意jdk的sun包里面有个BlockedException, 不要误选jdk的包了
    public String blockMethod(BlockException blockException){
        System.out.println("blockException = " + blockException);
        return "出现阻塞异常了";
    }

    //Throwable时进入的方法
    public String fallbackMethod(Throwable throwable){
        System.out.println("throwable = " + throwable);
        return "接口发生异常了";
    }
}

💡 容错兜底方法需要将BlockException参数放到controller原有参数后面，否则控制台输出：com.alibaba.csp.sentinel.slots.block.flow.FlowException: null（FallBack方法也是）

方式二: 将限流和降级方法外置到单独的类中

    //注意 要根据@SentinelResource中的value属性进行配置规则, 且value属性不要和url值一样,否则会一半触发,一半不触发
    //将限流和降级方法外置到单独的类中
    //注意blockHandlerClass指类, blockHandler指向对应类中的对应方法,fallback同理
    @RequestMapping("/order/message4")
    @SentinelResource(value = "message4",
            blockHandlerClass = OrderController3BlockClass.class,
            blockHandler = "blockHandler",
            fallbackClass = OrderController3Fallback.class,
            fallback = "fallback")
    public String message4(){
        int i = 1/0;
        return "message4";
   }

import com.alibaba.csp.sentinel.slots.block.BlockException;

public class OrderController3BlockClass {

    //注意这里必须使用static修饰方法
public static string blockHandler(BlockException ex) {
        System.out.println("ex = " + ex);
        return "接口被限流或者降级了...";
    }
}

public class OrderController3Fallback {
    //注意这里必须使用static修饰方法
    public static String fallback(Throwable throwable) {
        System.out.println("throwable = " + throwable);
        return "接口发生异常了...";
    }
}

如果想根据不同异常指定不同返回结果，可以使用如下代码：

public class Message5FallBackAndBlockHandler {
    public static String m5FallBack(Throwable throwable){
        return "我是单独写在另外一个类中的m5备份方案";
    }

    public static String m5BlockHandler(BlockException e){
        if (e instanceof FlowException){
            return "我是单独写在另外一个类中的m5限流返回结果";
        }
        return null;
    }
}

Sentinel规则持久化

nacos持久化

依赖

<dependency>
    <groupId>com.alibaba.csp</groupId>
    <artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

配置

spring:
  cloud:
    sentinel:
      datasource:
        ds1:
          nacos:
            username: nacos
            password: nacos
            server-addr: 127.0.0.1:8848
            dataId: cloudalibaba-sentinel-service
            groupId: DEFAULT_GROUP
            data-type: json
            rule-type: flow

nacos界面中添加规则

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

resource: 资源名称，注意这里设定的资源名称一定要准确！！

limitApp: 来源应用

grade: 阈值类型,0表示线程,1表示QPS

count: 单机阈值

strategy: 流控模式,0表示直接,1表示关联,2表示链路

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

clusterMode: 是否集群

Feign整合Sentinel [比较重要]

订单模块中添加依赖

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

添加sentinel配置

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

第 1 步: 在配置文件中开启Feign对Sentinel的支持

第 2 步: 创建容错类

第 3 步: 为被容器的接口指定容错类

第 4 步: 修改controller

第 5 步: 停止所有shop-product服务,重启shop-order服务,访问请求,观察容错效果

容错类要求必须实现被容错的接口,并为每个方法实现容错方案

@Component
public class ShopProductFallBack implements IShopProductFeign {
    @Override
    public Product shopOder(Integer pid) {
        Product product = new Product();
        product.setKuCun(-1);
        product.setName("未知商品");
        return product;
    }
}

//feign 将来谁调用这个接口 就是表明想要调用product服务
@FeignClient(value = "shop-product", fallback = ShopProductFallBack.class)
public interface IShopProductFeign {

    @GetMapping("/product/{id}")
    Product getProductById(@PathVariable("id") Integer pid);

}

@RestController
public class ShopOrderController {
    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private DiscoveryClient discoveryClient;

    @Autowired
    private IShopProductFeign shopProductFeign;

    private static Integer number = 0;

    private Object lock=1;

    @GetMapping("/order/{pid}/{num}")
    public Order shopOrder(@PathVariable Integer pid,@PathVariable Integer num){
        Product forObject = shopProductFeign.shopOder(pid);
        if (num>forObject.getKuCun() || num <= 0 ){
            return null;
        }else {
            Order order = new Order();
            order.setPid(pid);
            order.setNum(num);
            order.setOid(1);
            order.setPrice((double) (num * forObject.getPrice()));
            return order;
        }
    }
}

使用fallbackFactory注解

@FeignClient(value = "shop-product",fallbackFactory = ShopProductFallBackFactory.class)
public interface IShopProductFeign {
    @GetMapping("/product/{pid}")
    Product shopOder(@PathVariable("pid") Integer pid);
}

使用匿名内部类实现接口（为什么这里不能有lambda表达式实现接口？因为ShopProduct接口内的方法可以有多个）

@Component
public class ShopProductFallBackFactory implements FallbackFactory<IShopProductFeign> {

    @Override
    public IShopProductFeign create(Throwable throwable) {
        IShopProductFeign iShopProductFeign = new IShopProductFeign() {
            @Override
            public Product shopOder(Integer pid) {
                Product product = new Product();
                product.setName("未知商品");
                product.setKuCun(10);
                product.setPrice(0);
                return product;
            }
        };
        return iShopProductFeign;
    }
}