侧边栏壁纸
博主头像
欧泡果奶的小站

  • 累计撰写 84 篇文章
  • 累计创建 34 个标签
  • 累计收到 0 条评论

目 录CONTENT

文章目录
Spring Cloud Alibaba

SCA - 四、Sentinel--服务容错

欧泡果奶
欧泡果奶
2022-03-26 / 0 评论 / 0 点赞 / 234 阅读 / 0 字

1. 高并发带来的问题

在微服务架构中，我们将业务拆分成一个个的服务，服务与服务之间可以相互调用，但是由于网络原因或者自身的原因，服务并不能保证服务的100%可用，如果单个服务出现问题，调用这个服务就会出现网络延迟，此时若有大量的网络涌入，会形成任务堆积，最终导致服务瘫痪。

接下来，我们来模拟一个高并发的场景

1.1 编写OrderController2

import com.alibaba.fastjson.JSON;
import com.ochaly.domain.Order;
import com.ochaly.domain.Product;
import com.ochaly.service.OrderService;
import com.ochaly.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.discovery.DiscoveryClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@Slf4j
public class OrderController2 {
    @Autowired
    private ProductService productService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private DiscoveryClient discoveryClient;

    @RequestMapping("/order/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid) {
        log.info("接到{}号商品的下单请求，接下来调用商品微服务查询此商品信息", pid);
        List<ServiceInstance> instances = discoveryClient.getInstances("service-product");

        Product product = productService.findByPid(pid);

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.info("查询到{}号商品信息，内容是{}", pid, JSON.toJSONString(product));

        Order order = new Order();
        order.setUid(1);
        order.setUsername("测试用户");
        order.setPid(pid);
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);

//        orderService.createOrder(order);

        log.info("创建订单成功，订单信息为{}", JSON.toJSONString(order));

        return order;
    }

    @RequestMapping("/order/message")
    public String message() {
        return "测试高并发";
    }
}

1.2 修改配置文件中tomcat的并发数

server:
  tomcat:
    max-threads: 10 # tomcat的最大并发值修改为10,默认是200

1.3 使用压测工具,对请求进行压力测试

1.3.1 下载JMeter

https://jmeter.apache.org

1.3.2 修改配置，并启动软件

进入bin目录，修改jmeter.properties文件中的语言支持为language=zh_CN，然后点击jmeter启动软件。

JMeter

1.3.3 添加线程组

添加线程组

1.3.4 配置线程组

配置线程组

1.3.5 添加HTTP取样

HTTP取样

1.3.6 配置HTTP取样

配置HTTP取样

1.3.7 添加察看结果树

添加察看结果树

1.3.8 启动该线程组，并访问message方法观察效果

1.4 结论

此时会发现, 由于order方法囤积了大量请求, 导致message方法的访问出现了问题，这就是服务雪崩的雏形。

2. 服务雪崩

2.1 服务雪崩效应

​ 在分布式系统中,由于网络原因或自身的原因,服务一般无法保证100%可用。如果一个服务出现了问题，调用这个服务就会出现线程阻塞的情况，此时若有大量的请求涌入，就会出现多条线程阻塞等待，进而导致服务瘫痪。

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

​ 雪崩发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。我们无法完全杜绝雪崩源头的发生，只有做好足够的容错，保证在一个服务发生问题，不会影响到其它服务的正常运行。也就是"雪落而不雪崩"。

2.2 常见容错方案

​ 要防止雪崩的扩散，我们就要做好服务的容错，容错说白了就是保护自己不被猪队友拖垮的一些措施, 下面介绍常见的服务容错思路和组件。

2.2.1 常见的容错思路

​ 常见的容错思路有隔离、超时、限流、熔断、降级这几种，下面分别介绍一下。

  • 隔离

    它是指将系统按照一定的原则划分为若干个服务模块，各个模块之间相对独立，无强依赖。当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不波及其它模块，不影响整体的系统服务。常见的隔离方式有:线程池隔离和信号量隔离.

  • 超时

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

  • 限流

    限流就是限制系统的输入和输出流量已达到保护系统的目的。为了保证系统的稳固运行,一旦达到 的需要限制的阈值,就需要限制流量并采取少量措施以完成限制流量的目的。

  • 熔断

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

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

    • 熔断关闭状态(Closed)

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

    • 熔断开启状态(Open)

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

    • 半熔断状态(Half-Open)

      尝试恢复服务调用，允许有限的流量调用该服务，并监控调用成功率。如果成功率达到预期，则说明服务已恢复，进入熔断关闭状态;如果成功率仍旧很低，则重新进入熔断开启状态。

  • 降级

    降级其实就是为服务提供一个托底方案，一旦服务无法正常调用，就使用托底方案

2.2.2 常见的容错组件

  • Hystrix

    Hystrix是由Netflix开源的一个延迟和容错库，用于隔离访问远程系统、服务或者第三方库，防止 级联失败，从而提升系统的可用性与容错性。

  • Resilience4J

    Resilicence4J一款非常轻量、简单，并且文档非常清晰、丰富的熔断工具，这也是Hystrix官方推 荐的替代产品。不仅如此，Resilicence4j还原生支持Spring Boot 1.x/2.x，而且监控也支持和 prometheus等多款主流产品进行整合。

  • Sentinel

    Sentinel 是阿里巴巴开源的一款断路器实现，本身在阿里内部已经被大规模采用，非常稳定。

下面是三个组件在各方面的对比:

SentinelHystrixresilience4j
隔离策略信号量隔离(并发线程数限流)线程池隔离/信 号量隔离信号量隔离
熔断降级策略基于响应时间、异常比率、异常数基于异常比率基于异常比率、响应 时间
实时统计实现滑动窗口(LeapArray)滑动窗口(基于RxJava)Ring Bit Buffer
动态规则配置支持多种数据源支持多种数据源有限支持
扩展性多个扩展点插件的形式接口的形式
基于注解的支持支持支持支持
限流基于 QPS，支持基于调用关系的限流有限的支持Rate Limiter
流量整形支持预热模式、匀速器模式、预热排队模式不支持简单的Rate Limiter 模式
系统自适应保护支持不支持不支持
控制台提供开箱即用的控制台，可配置规则、查看秒级监控、机器发现等简单的监控查看不提供控制台，可对接其它监控系统

3. Sentinel入门

3.1 什么是Sentinel

Sentinel (分布式系统的流量防卫兵) 是阿里开源的一套用于服务容错的综合性解决方案。它以流量 为切入点, 从流量控制、熔断降级、系统负载保护等多个维度来保护服务的稳定性。

Sentinel具有以下特征:

  • 丰富的应用场景:

    Sentinel 承接了阿里巴巴近10年的双十一大促流量的核心场景, 例如秒杀(即突发流量控制在系统容量可以承受的范围)、消息削峰填谷、集群流量控制、实时熔断下游不可用应用等。

  • 完备的实时监控:

    Sentinel提供了实时的监控功能。通过控制台可以看到接入应用的单台机器秒级数据, 甚至500台以下规模的集群的汇总运行情况。

  • 广泛的开源生态:

    Sentinel提供开箱即用的与其它开源框架/库的整合模块, 例如与Spring Cloud、Dubbo、gRPC的整合。只需要引入相应的依赖并进行简单的配置即可快速地接入Sentinel。

  • 完善的 SPI扩展点:

    Sentinel提供简单易用、完善的 SPI 扩展接口。您可以通过实现扩展接口来快速地定制逻辑。例如定制规则管理、适配动态数据源等。

Sentinel分为两个部分:

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

3.2 订单微服务集成Sentinel

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

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

3.2.2 编写一个Controller测试使用

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
public class OrderController3 {

    @RequestMapping("/order/message1")
    public String message1() throws InterruptedException {
        return "message1";
    }

    @RequestMapping("/order/message2")
    public String message2() {
        return "message2";
    }
}

3.3 安装Sentinel控制台

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

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

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

3.3.2 启动控制台

# 直接使用jar命令启动项目(控制台本身是一个SpringBoot项目)
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 - Dproject.name=sentinel-dashboard -jar sentinel-dashboard-1.8.0.jar

3.3.3 修改 shop-order ,在里面加入有关控制台的配置

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

3.3.4 通过浏览器访问localhost:8080 进入控制台 ( 默认用户名密码是 sentinel/sentinel )

Sentinle Dashboard

如果左侧没有service-order，这时候随便访问订单微服务中的一个接口（例如: http://localhost:8091/order/message1 ），然后刷新sentinel页面就出来了。

3.5 实现一个接口的限流

3.5.1 通过控制台为message1添加一个流控规则

service-order

流控规则

3.5.2 通过控制台快速频繁访问, 观察效果

接口被限流

4. Sentinel的概念和功能

4.1.1 基本概念

  • 资源

    资源就是Sentinel要保护的东西

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

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

  • 规则

    规则就是用来定义如何进行保护资源的

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

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

4.1.2 重要功能

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

  • 流量控制

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

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

  • 熔断降级

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

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

    • 通过并发线程数进行限制Sentinel

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

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

      除了对并发线程数进行控制以外，Sentinel 还可以通过响应时间来快速降级不稳定的资源。当依赖的资源出现响应时间过长后，所有对该资源的访问都会被直接拒绝，直到过了指定的时间窗口之后才重新恢复。

Sentinel和Hystrix的区别

两者的原则是一致的, 都是当一个资源出现问题时, 让其快速失败, 不要波及到其它服务

但是在限制的手段上, 确采取了完全不一样的方法:

  • Hystrix 采用的是线程池隔离的方式, 优点是做到了资源之间的隔离, 缺点是增加了线程切换的成本。
  • Sentinel 采用的是通过并发线程的数量和响应时间来对资源做限制。

  • 系统负载保护

    Sentinel 同时提供系统维度的自适应保护能力。当系统负载较高的时候，如果还持续让请求进入可能会导致系统崩溃，无法响应。在集群环境下，会把本应这台机器承载的流量转发到其它的机器上去。如果这个时候其它的机器也处在一个边缘状态的时候，Sentinel 提供了对应的保护机制，让系统的入口流量和系统的负载达到一个平衡，保证系统在能力范围之内处理最多的请求。

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

5. Sentinel规则

5.1 流控规则

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

5.1.1 简单配置

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

    新增流控规则

  2. 设置阈值类型为QPS，单机阈值为3。即每秒请求量大于3的时候开始限流。接下来，在流控规则页面就可以看到这个配置。

    流控规则列表

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

接口被限流

5.1.2 配置流控模式

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

流控模式

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

  • 直接(默认): 接口达到限流条件时，开启限流
  • 关联: 当关联的资源达到限流条件时，开启限流 [适合做应用让步]
  • 链路: 当从某个接口过来的资源达到限流条件时，开启限流
5.1.2.1 直接流控模式

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

5.1.2.2 关联流控模式

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

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

    关联流控

  2. 通过jmeter软件向/order/message2连续发送请求，注意QPS一定要大于3

    设置线程组

    设置HTTP取样器

  3. 访问/order/message1,会发现已经被限流

    接口被限流

5.1.2.3 链路流控模式

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

  1. 编写一个service，在里面添加一个方法message

    @Service
public class OrderServiceImpl3 {
    @SentinelResource("message")
    public void message() {
        System.out.println("message");
    }
}

  2. 在Controller中声明两个方法，分别调用service中的方法

    import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.ochaly.service.impl.OrderServiceImpl3;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@Slf4j
public class OrderController3 {
    @Autowired
    private OrderServiceImpl3 orderServiceImpl3;


    @RequestMapping("/order/message1")
    public String message1() throws InterruptedException {
      	orderServiceImpl3.message();
        return "message1";
    }

    @RequestMapping("/order/message2")
    public String message2() {
      	orderServiceImpl3.message();
        return "message2";
    }
}

  3. 禁止收敛URL的入口 context

    1. 将SpringCloud Alibaba的版本调整为2.1.1.RELEASE

      <spring-cloud-alibaba.version>2.1.1.RELEASE</spring-cloud-alibaba.version>

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

      spring:
    cloud:
        sentinel:
            filter:
                enabled: false

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

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

  4. 控制台配置限流规则

    链路流控

  5. 分别通过 /order/message1 和 /order/message2 访问, 发现2没问题, 1的被限流了

5.1.3 配置流控效果

  • 快速失败(默认): 直接失败，抛出异常，不做任何额外的处理，是最简单的效果。
  • Warm Up: 它从开始阈值到最大QPS阈值会有一个缓冲阶段，一开始的阈值是最大QPS阈值的1/3，然后慢慢增长，直到最大阈值，适用于将突然增大的流量转换为缓步增长的场景。
  • 排队等待: 让请求以均匀的速度通过，单机阈值为每秒通过数量，其余的排队等待; 它还会让设置一个超时时间，当请求超过超时间时间还未处理，则会被丢弃。

5.2 降级规则

降级规则就是设置当满足什么条件的时候，对服务进行降级。

Sentinel提供了三个衡量条件:

  • 慢调用比例 :当资源的平均响应时间超过阈值(以 ms 为单位)之后，资源进入准降级状态。如果接下来 1s 内持续进入 5 个请求，它们的 RT都持续超过这个阈值，那么在接下的时间窗口 (以 s 为单位)之内，就会对这个方法进行服务降级。

    慢调用比例

    当请求数 > 5，且慢调用(RT > 1ms)的比例大于阈值0.5时，接下来的5s内服务降级。

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

    1. 模拟一个异常

      int i = 0;
@RequestMapping("/order/message2")
public String message2() {
  i++;
  if (i % 3 == 0) {
    throw new RuntimeException();
  }
  orderServiceImpl3.message();
  return "message2";
}

    2. 设置异常比例为0.25

      异常比例

  • 异常数: 当请求数大于最小请求数，且资源的异常数目超过阈值之后会进行服务降级。

    异常数

5.3 热点规则

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

5.3.1 简单使用

  1. 编写代码

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

  2. 配置热点规则

    热点规则

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

    name

    age

5.3.2 增强使用

参数例外项允许对一个参数的具体值进行流控。

编辑刚才定义的规则,增加参数例外项

热点规则-参数例外向

5.4 授权规则

很多时候，我们需要根据调用来源来判断该次请求是否允许放行，这时候可以使用 Sentinel 的来源访问控制的功能。来源访问控制根据资源的请求来源(origin)限制资源是否通过:

  • 若配置白名单，则只有请求来源位于白名单内时才可通过;
  • 若配置黑名单，则请求来源位于黑名单时不通过，其余的请求通过。

授权规则

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

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

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

  1. 自定义来源处理规则

    import com.alibaba.csp.sentinel.adapter.servlet.callback.RequestOriginParser;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

import javax.servlet.http.HttpServletRequest;

@Slf4j
@Component
public class RequestOriginParserDefinition implements RequestOriginParser {

    @Override
    public String parseOrigin(HttpServletRequest request) {
        String serviceName = request.getParameter("serviceName");
        if (StringUtils.isEmpty(serviceName)) {
            log.error("{}, serviceName is Empty!", request.getRequestURI());
        }
        return serviceName;
    }
}

  2. 授权规则配置

    授权规则

    这个规则的意思是只有serviceName=pc可以访问

  3. 访问 http://localhost:8091/order/message1?serviceName=pc观察结果

如果RequestOriginParser解析不生效，则执行以下步骤

新建SentinelConfiguration类，在里面配置RequestOriginParser

import com.alibaba.csp.sentinel.adapter.servlet.callback.WebCallbackManager;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class SentinelConfiguration {
 @PostConstruct
 public void init() {
     WebCallbackManager.setRequestOriginParser(new RequestOriginParserDefinition());
 }
}

5.5 系统规则

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

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

  • Load(仅对 Linux/Unix-like 机器生效): 当系统 load1 超过阈值，且系统当前的并发线程数超过系统容量时才会触发系统保护。系统容量由系统的 maxQps * minRt 计算得出。设定参考值一般是 CPU cores * 2.5。
  • RT: 当单台机器上所有入口流量的平均 RT 达到阈值即触发系统保护，单位是毫秒。
  • 线程数: 当单台机器上所有入口流量的并发线程数达到阈值即触发系统保护。
  • 入口 QPS: 当单台机器上所有入口流量的 QPS 达到阈值即触发系统保护。
  • CPU使用率: 当单台机器上所有入口流量的 CPU使用率达到阈值即触发系统保护。

5.6 扩展: 自定义异常返回

import com.alibaba.csp.sentinel.adapter.servlet.callback.UrlBlockHandler;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityException;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowException;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowException;
import com.alibaba.csp.sentinel.slots.system.SystemBlockException;
import com.alibaba.fastjson.JSON;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.stereotype.Component;

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

/**
 * @Description: 自定义异常返回
 */
@Component
public class ExceptionHandlerPage implements UrlBlockHandler {
    /**
     * BlockException 异常接口,包含Sentinel的五个异常
     *      FlowException 限流异常
     *      DegradeException 降级异常
     *      ParamFlowException 参数限流异常
     *      AuthorityException 授权异常
     *      SystemBlockException 系统负载异常
     */
    @Override
    public void blocked(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, BlockException e) throws IOException {
        httpServletResponse.setContentType("application/json;charset=utf-8");
        ResponseData data = null;
        if (e instanceof FlowException) {
            data = new ResponseData(-1, "接口被限流了...");
        } else if (e instanceof DegradeException) {
            data = new ResponseData(-2, "接口被降级了...");
        } else if (e instanceof ParamFlowException) {
            data = new ResponseData(-3, "接口被参数限流了...");
        } else if (e instanceof AuthorityException) {
            data = new ResponseData(-4, "授权异常...");
        } else if (e instanceof SystemBlockException) {
            data = new ResponseData(-5, "系统负载异常...");
        } else {
            data = new ResponseData(-6, "未知异常...");
        }
        httpServletResponse.getWriter().write(JSON.toJSONString(data));
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
class ResponseData {
    private int code;
    private String message;
}
如果自定义异常不生效，则执行以下步骤

如果配置RequestOriginParser解析时未创建，则新建SentinelConfiguration类，在里面配置自定义异常类

import com.alibaba.csp.sentinel.adapter.servlet.callback.WebCallbackManager;
import org.springframework.context.annotation.Configuration;

import javax.annotation.PostConstruct;

@Configuration
public class SentinelConfiguration {
 @PostConstruct
 public void init() {
     WebCallbackManager.setRequestOriginParser(new RequestOriginParserDefinition());
     WebCallbackManager.setUrlBlockHandler(new ExceptionHandlerPage());
 }
}

6. @SentinelResource的使用

在定义了资源点之后，我们可以通过Dashboard来设置限流和降级策略来对资源点进行保护。同时还能通过@SentinelResource来指定出现异常时的处理策略。

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

属性作用
value资源名称
entryTypeentry类型，标记流量的方向，取值IN/OUT，默认是OUT
blockHandler处理BlockException的函数名称,函数要求: 1. 必须是 public。2.返回类型 参数与原方法一致。3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置blockHandlerClass ，并指定blockHandlerClass里面的方法。
blockHandlerClass存放blockHandler的类,对应的处理函数必须static修饰。
fallback用于在抛出异常的时候提供fallback处理逻辑。fallback函数可以针对所 有类型的异常(除了 exceptionsToIgnore 里面排除掉的异常类型)进 行处理。函数要求: 1. 返回类型与原方法一致。2. 参数类型需要和原方法相匹配。3. 默认需和原方法在同一个类中。若希望使用其他类的函数，可配置fallbackClass ，并指定fallbackClass里面的方法。
fallbackClass存放fallback的类。对应的处理函数必须static修饰。
defaultFallback用于通用的 fallback 逻辑。默认fallback函数可以针对所有类型的异常进行处理。若同时配置了 fallback 和 defaultFallback，以fallback为准。函数要求: 1. 返回类型与原方法一致。2. 方法参数列表为空，或者有一个 Throwable 类型的参数。3. 默认需要和原方法在同一个类中。若希望使用其他类的函数，可配置fallbackClass ，并指定 fallbackClass 里面的方法。
exceptionsToIgnore指定排除掉哪些异常。排除的异常不会计入异常统计，也不会进入fallback逻辑，而是原样抛出。
exceptionsToTrace需要trace的异常

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

  • 方式一：直接将限流和降级方法定义在方法中

    import com.alibaba.csp.sentinel.annotation.SentinelResource;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class OrderServiceImpl3 {
    int i = 0;

    // 定义资源 value指定资源名称
    @SentinelResource(
            value = "message",
            blockHandler = "blockHandler", // 指定发生BlockException时进入的方法
            fallback = "fallback" // 指定发生Throwable时进入的方法
    )
    public String message(String name) {
        i++;
        if (i % 3 == 0) {
            throw new RuntimeException();
        }
        return "message";
    }

    /**
     * blockHandler
     * 1 当前方法的返回值参数必须跟原方法一样
     * 2 但是允许在参数列表最后加入一个参数BlockException，用来接收方法中的异常
     */
    public String blockHandler(String name, BlockException e) {
        log.error("触发了BlockException，内容为{}", e);
        return "BlockException";
    }

    /**
     * fallback
     * 1 当前方法的返回值参数必须跟原方法一样
     * 2 但是允许在参数列表最后加入一个参数Throwable，用来接收方法中的异常
     */
    public String fallback(String name, Throwable e) {
        log.error("触发了Throwable，内容为{}", e);
        return "Throwable";
    }
}

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

    import com.alibaba.csp.sentinel.slots.block.BlockException;
import lombok.extern.slf4j.Slf4j;

@Slf4j
public class OrderServiceImpl3BlockHandlerClass {
    /**
     * 注意这里必须使用static修饰方法
     */
    public static String blockHandler(BlockException ex) {
        log.error("{}", ex);
        return "接口被限流或者降级了...";
    }
}

    import lombok.extern.slf4j.Slf4j;

@Slf4j
public class OrderServiceImpl3FallbackClass {
    /**
     * 注意这里必须使用static修饰方法
     */
    public static String fallback(Throwable throwable) {
        log.error("{}", throwable);
        return "接口发生异常了...";
    }
}

    import com.alibaba.csp.sentinel.annotation.SentinelResource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

@Service
@Slf4j
public class OrderServiceImpl3 {
    int i = 0;

    // 定义资源 value指定资源名称
    @SentinelResource(
            value = "message",
            blockHandlerClass = OrderServiceImpl3BlockHandlerClass.class,
            blockHandler = "blockHandler", // 指定发生BlockException时进入的方法
            fallbackClass = OrderServiceImpl3FallbackClass.class,
            fallback = "fallback" // 指定发生Throwable时进入的方法
    )
    public String message(String name) {
        i++;
        if (i % 3 == 0) {
            throw new RuntimeException();
        }
        return "message";
    }
}

7. Sentinel规则持久化

通过前面的讲解，我们已经知道，可以通过Dashboard来为每个Sentinel客户端设置各种各样的规则，但是这里有一个问题，就是这些规则默认是存放在内存中，极不稳定，所以需要将其持久化。

本地文件数据源会定时轮询文件的变更，读取规则。这样我们既可以在应用本地直接修改文件来更新规则，也可以通过 Sentinel 控制台推送规则。以本地文件数据源为例，推送过程如下图所示:

规则持久化推送

首先 Sentinel 控制台通过 API 将规则推送至客户端并更新到内存中，接着注册的写数据源会将新的规则保存到本地的文件中。

7.1 编写处理类

import com.alibaba.csp.sentinel.command.handler.ModifyParamFlowRulesCommandHandler;
import com.alibaba.csp.sentinel.datasource.*;
import com.alibaba.csp.sentinel.init.InitFunc;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRule;
import com.alibaba.csp.sentinel.slots.block.authority.AuthorityRuleManager;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRule;
import com.alibaba.csp.sentinel.slots.block.degrade.DegradeRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import com.alibaba.csp.sentinel.slots.system.SystemRule;
import com.alibaba.csp.sentinel.slots.system.SystemRuleManager;
import com.alibaba.csp.sentinel.transport.util.WritableDataSourceRegistry;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;

import java.io.File;
import java.io.IOException;
import java.util.List;

/**
 * @Author: ouchonghui
 * @Created: 2022/3/22 10:52
 * @Description:
 */
public class FilePersistence implements InitFunc {

    @Override
    public void init() throws Exception {
        System.out.println(applicationName);
        String ruleDir = System.getProperty("user.home") + "/projects/IDEA/spring-cloud-alibaba/sentinel-rules/order" ;
        String flowRulePath = ruleDir + "/flow-rule.json";
        String degradeRulePath = ruleDir + "/degrade-rule.json";
        String systemRulePath = ruleDir + "/system-rule.json";

        String authorityRulePath = ruleDir + "/authority-rule.json";
        String paramFlowRulePath = ruleDir + "/param-flow-rule.json";
        this.mkdirIfNotExits(ruleDir);
        this.createFileIfNotExits(flowRulePath);
        this.createFileIfNotExits(degradeRulePath);
        this.createFileIfNotExits(systemRulePath);
        this.createFileIfNotExits(authorityRulePath);
        this.createFileIfNotExits(paramFlowRulePath);
        // 流控规则
        ReadableDataSource<String, List<FlowRule>> flowRuleRDS = new FileRefreshableDataSource<>(
                flowRulePath,
                flowRuleListParser
        );
        FlowRuleManager.register2Property(flowRuleRDS.getProperty());
        WritableDataSource<List<FlowRule>> flowRuleWDS = new FileWritableDataSource<>(
                flowRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerFlowDataSource(flowRuleWDS);

        // 降级规则
        ReadableDataSource<String, List<DegradeRule>> degradeRuleRDS = new FileRefreshableDataSource<>(
                degradeRulePath,
                degradeRuleListParser
        );
        DegradeRuleManager.register2Property(degradeRuleRDS.getProperty());
        WritableDataSource<List<DegradeRule>> degradeRuleWDS = new FileWritableDataSource<>(
                degradeRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerDegradeDataSource(degradeRuleWDS);

        // 系统规则
        ReadableDataSource<String, List<SystemRule>> systemRuleRDS = new FileRefreshableDataSource<>(
                systemRulePath,
                systemRuleListParser
        );
        SystemRuleManager.register2Property(systemRuleRDS.getProperty());
        WritableDataSource<List<SystemRule>> systemRuleWDS = new
                FileWritableDataSource<>(
                systemRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerSystemDataSource(systemRuleWDS);

        // 授权规则
        ReadableDataSource<String, List<AuthorityRule>> authorityRuleRDS = new FileRefreshableDataSource<>(
                authorityRulePath,
                authorityRuleListParser
        );
        AuthorityRuleManager.register2Property(authorityRuleRDS.getProperty());
        WritableDataSource<List<AuthorityRule>> authorityRuleWDS = new FileWritableDataSource<>(
                authorityRulePath,
                this::encodeJson
        );
        WritableDataSourceRegistry.registerAuthorityDataSource(authorityRuleWDS);

        // 热点参数规则
        ReadableDataSource<String, List<ParamFlowRule>> paramFlowRuleRDS = new FileRefreshableDataSource<>(
                paramFlowRulePath,
                paramFlowRuleListParser
        );
        ParamFlowRuleManager.register2Property(paramFlowRuleRDS.getProperty());
        WritableDataSource<List<ParamFlowRule>> paramFlowRuleWDS = new FileWritableDataSource<>(
                paramFlowRulePath,
                this::encodeJson
        );
        ModifyParamFlowRulesCommandHandler.setWritableDataSource(paramFlowRuleWDS);
    }

    private Converter<String, List<FlowRule>> flowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<FlowRule>>() {
            }
    );
    private Converter<String, List<DegradeRule>> degradeRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<DegradeRule>>() {
            }
    );
    private Converter<String, List<SystemRule>> systemRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<SystemRule>>() {
            }
    );
    private Converter<String, List<AuthorityRule>> authorityRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<AuthorityRule>>() {
            }
    );
    private Converter<String, List<ParamFlowRule>> paramFlowRuleListParser = source -> JSON.parseObject(
            source,
            new TypeReference<List<ParamFlowRule>>() {
            }
    );

    private void mkdirIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.mkdirs();
        }
    }

    private void createFileIfNotExits(String filePath) throws IOException {
        File file = new File(filePath);
        if (!file.exists()) {
            file.createNewFile();
        }
    }

    private <T> String encodeJson(T t) {
        return JSON.toJSONString(t);
    }
}

7.2 添加配置

在resources下创建配置目录 META-INF/services ,然后添加文件com.alibaba.csp.sentinel.init.InitFunc

在文件中添加配置类的全路径

com.ochaly.config.FilePersistence

8. Feign整合Sentinel

8.1 引入sentinel的依赖

<!--sentinel客户端--> 
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

8.2 在配置文件中开启Feign对Sentinel的支持

feign:
  sentinel:
    enabled: true

8.3 创建容错类

import com.ochaly.domain.Product;
import com.ochaly.service.ProductService;
import org.springframework.stereotype.Component;

/**
 * @Description: 这是一个容错类，需要实现Feign所在的接口,并去实现接口中的所有方法，
 * 一旦Feign远程调用出现问题了，就会进入当前类中同名方法，执行容错逻辑
 */
@Component
public class ProductServiceFallback implements ProductService {
    @Override
    public Product findByPid(Integer pid) {
        Product product = new Product();
        product.setPid(-100);
        product.setPname("远程调用商品微服务出现异常，进入了容错逻辑");
        return product;
    }
}

8.4 为接口指定容错类

import com.ochaly.domain.Product;
import com.ochaly.service.fallback.ProductServiceFallback;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

/**
 * @Description: 商品服务api
 * FeignClient: value用于指定调用nacos下哪个微服务
 */
@FeignClient(
        value = "service-product",
        fallback = ProductServiceFallback.class
)
public interface ProductService {
    /**
     * @FeignClient的value + @RequestMapping的value 其实就是完整的请求地址 "http://service-product/product/" + pid
     * 指定请求的uri部分
     */
    @RequestMapping("/product/{pid}")
    Product findByPid(@PathVariable Integer pid);
}

8.5 修改controller

import com.alibaba.fastjson.JSON;
import com.ochaly.domain.Order;
import com.ochaly.domain.Product;
import com.ochaly.service.OrderService;
import com.ochaly.service.ProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("order")
public class OrderController {
    @Autowired
    private ProductService productService;
    @Autowired
    private OrderService orderService;

    @RequestMapping("/prod/{pid}")
    public Order order(@PathVariable("pid") Integer pid) {
        log.info("接到{}号商品的下单请求，接下来调用商品微服务查询此商品信息", pid);

        // feign远程调用
        Product product = productService.findByPid(pid);
        if (product.getPid() == -100) {
            Order order = new Order();
            order.setPid(product.getPid());
            order.setPname("下单失败");
            return order;
        }

        log.info("查询到{}号商品信息，内容是{}", pid, JSON.toJSONString(product));

        Order order = new Order();
        order.setUid(1);
        order.setUsername("测试用户");
        order.setPid(pid);
        order.setPname(product.getPname());
        order.setPprice(product.getPprice());
        order.setNumber(1);

        orderService.createOrder(order);

        log.info("创建订单成功，订单信息为{}", JSON.toJSONString(order));
      
        try {
          	Thread.sleep(100);
        } catch (InterruptedException e) {
          	e.printStackTrace();
        }

        return order;
    }
}

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

8.7 扩展: 如果想在容错类中拿到具体的错误,可以使用下面的方式

import com.ochaly.domain.Product;
import com.ochaly.service.fallback.ProductServiceFallbackFactory;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@FeignClient(
        value = "service-product",
        fallbackFactory = ProductServiceFallbackFactory.class
)
public interface ProductService {
    /**
     * @FeignClient的value + @RequestMapping的value 其实就是完整的请求地址 "http://service-product/product/" + pid
     * 指定请求的uri部分
     */
    @RequestMapping("/product/{pid}")
    Product findByPid(@PathVariable Integer pid);
}

import com.ochaly.domain.Product;
import com.ochaly.service.ProductService;
import feign.hystrix.FallbackFactory;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

@Component
@Slf4j
public class ProductServiceFallbackFactory implements FallbackFactory<ProductService> {
    @Override
    public ProductService create(Throwable throwable) {
        return new ProductService() {
            @Override
            public Product findByPid(Integer pid) {
                log.error("{}", throwable);
                Product product = new Product();
                product.setPid(-100);
                product.setPname("远程调用商品微服务出现异常，进入了容错逻辑");
                return product;
            }
        };
    }
}
fallback和fallbackFactory只能使用其中一种方式
0
Spring Cloud Alibaba 微服务
版权归属： 欧泡果奶
本文链接： https://blog.bughole.cn/archives/s86yjx09
许可协议： 本文使用《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》协议授权

评论区