一、概述

1、分布式系统面临的问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失败。
几个微服务之间的相互调用，一定会导致链路越来越长。一个出事了，就会导致整条链路上的服务都出事。

1.1 服务雪崩

多个微服务之间调用的时候，假设微服务A调用微服务B和微服务C，微服务B和微服务C又调用其他的微服务，这就是所谓的“扇出”如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务A的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的“雪崩效应”。
对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒钟内饱和，比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障。
这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消整个应用程序或系统。
所以，
通常当你发现一个模块下某个实例失败后，这时候这个模块依然还会接收流量，然而这个有问题的模块还调用了其他模块，这样就会发生级联故障，或者叫雪崩。

2、Hystrix 是什么

Hystrix 是一个用于处理分布式系统的延迟和容错的开源库，在分布式系统里，许多依赖不可避免的会调用失败，比如超时，异常等，Hystrix能够保证在一个依赖出问题的情况下，不会导致整体服务失败，避免级联故障，以提高分布式系统的弹性。

断路器本身是一种开关装置，当某个服务单元发生故障之后，通过断路器的故障监控（类似熔断保险丝），向调用方返回一个符合预期的，可处理的备选响应（FallBack），而不是长时间的等待或者抛出调用方无法处理的异常，这样就保证了服务调用方的线程不会被长时间、不必要地占用，从而避免了故障在分布式系统中的蔓延，乃至雪崩。

3、Hystrix能做什么

  • 服务降级
  • 服务熔断
  • 接近实时的监控

  • 。。。。

    4、Hystrix官网

    https://github.com/Netflix/Hystrix/wiki/How-To-Use

    二、Hystrix 重要概念

    1、服务降级：fallback

    加入对方的系统不可用了，需要一个兜底的解决方案或备选响应；向调用方返回一个符合预期的、可处理的备选响应。
    服务器繁忙，请稍后再试，不让客户端等待并立刻返回一个好友提示。fallback
    哪些情况会触发降级：

  • 程序运行异常

  • 超时
  • 服务熔断触发服务降级
  • 线程池/信号量打满也会导致服务降级

    2、服务熔断：break

    类比保险丝达到最大服务访问后，直接拒绝访问，拉闸限电，然后调用服务降级的方法并返回友好提示 break

    就是保险丝 || 服务的降级—->进而熔断—->恢复调用链路

3、服务限流：flowlimit

秒杀高并发等操作，严禁一窝蜂的过来拥挤，大家排队，一秒钟N个，有序进行 flowlimit

三、Hystrix案例

1、构建正确提供者模块

这里视频里面首先将eureka7001从集群版改成了单机版，我没有改。

搭建基础平台：从正确—->错误—->降级熔断—->恢复 以此平台 演示 Hystrix 服务降级 服务熔断 服务限流

1.1 创建cloud-provider-hystrix-payment8001模块

1.2 改pom

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>jdk8cloud2021</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-provider-hystrix-payment8001</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <!--hystrix-->
  20.         <dependency>
  21.             <groupId>org.springframework.cloud</groupId>
  22.             <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  23.         </dependency>
  24.         <!--eureka client-->
  25.         <dependency>
  26.             <groupId>org.springframework.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  28.         </dependency>
  29.         <!--web-->
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-web</artifactId>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.springframework.boot</groupId>
  36.             <artifactId>spring-boot-starter-actuator</artifactId>
  37.         </dependency>
  38.         <dependency><!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  39.             <groupId>com.atguigu.springcloud</groupId>
  40.             <artifactId>cloud-api-commons</artifactId>
  41.             <version>${project.version}</version>
  42.         </dependency>
  43.         <dependency>
  44.             <groupId>org.springframework.boot</groupId>
  45.             <artifactId>spring-boot-devtools</artifactId>
  46.             <scope>runtime</scope>
  47.             <optional>true</optional>
  48.         </dependency>
  49.         <dependency>
  50.             <groupId>org.projectlombok</groupId>
  51.             <artifactId>lombok</artifactId>
  52.             <optional>true</optional>
  53.         </dependency>
  54.         <dependency>
  55.             <groupId>org.springframework.boot</groupId>
  56.             <artifactId>spring-boot-starter-test</artifactId>
  57.             <scope>test</scope>
  58.         </dependency>
  59.     </dependencies>
  60. </project>

1.2 yml

  1. server:
  2.   port: 8001
  4. spring:
  5.   application:
  6.     name: cloud-provider-hystrix-payment
  8. eureka:
  9.   client:
  10.     register-with-eureka: true
  11.     fetch-registry: true
  12.     service-url:
  13.       #集群版
  14.       defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka
  15.       #单机版
  16. #      defaultZone: http://eureka7001.com:7001/eureka

1.3 主启动类

  1. @SpringBootApplication
  2. @EnableEurekaClient
  3. public class PaymentHystrixMain8001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(PaymentHystrixMain8001.class, args);
  6.     }
  7. }

1.4 业务类

1.4.1 Service

  1. @Service
  2. public class PaymentService {
  3.     /**
  4.      * 正常访问，一定ok的方法
  5.      */
  6.     public String paymentInfo_Ok(Integer id) {
  7.         return "线程池：  " + Thread.currentThread().getName() + "   paymentInfo_OK,  id:  " + id
  8.                 + "\t"+"O(∩_∩)O哈哈~";
  9.     }
  11.     public String paymentInfo_Timeout(Integer id) {
  12.         int timeNumber = 3;
  13.         try {
  14.             TimeUnit.SECONDS.sleep(timeNumber);
  15.             } catch (InterruptedException e) {
  16.                 e.printStackTrace();
  17.             }
  19.         return "线程池：  " + Thread.currentThread().getName() + "   payment_Timeout,  id:  " + id
  20.                 + "\t"+"O(∩_∩)O哈哈~耗时(s):" + timeNumber;
  21.     }
  22. }

1.4.2 Controller

  1. @RestController
  2. @Slf4j
  3. public class PaymentController {
  4.     @Resource
  5.     private PaymentService paymentService;
  6.     @Value("${server.port}")
  7.     private String serverPort;
  9.     @GetMapping("/payment/hystrix/ok/{id}")
  10.     private String paymentInfo_Ok(@PathVariable("id") Integer id) {
  11.         String result = paymentService.paymentInfo_Ok(id);
  12.         log.info("******ok****result：" + result);
  13.         return result;
  14.     }
  16.     @GetMapping("/payment/hystrix/timeout/{id}")
  17.     private String paymentInfo_Timeout(@PathVariable("id") Integer id) {
  18.         String result = paymentService.paymentInfo_Timeout(id);
  19.         log.info("******timeout****result：" + result);
  20.         return result;
  21.     }
  22. }

1.5 正常测试

启动eireka7001/7002；启动cloud-provider-hystrix-payment8001
访问模拟健康的方法： ok的方法
image.png
image.png
访问模拟复杂业务逻辑的方法：timeout的方法，耗时3s
image.png
image.png

1.6 以上述平台为根基，演示正确—>错误—>降级熔断—>恢复

高并发压测

上述在非高并发情况下，还勉强可以满足。使用jmeter，设置20000个并发压死8001,20000个请求都去访问http://localhost:8001/payment/hystrix/timeout/31
image.pngimage.png
结果发现原来可以迅速响应的http://localhost:8001/payment/hystrix/ok/31 变得卡顿。两个都在转圈。
原因：
因为ok跟timeout都在一个微服务里，现在大量的资源被timeout占用，微服务必须集中资源去处理这些 高并发的请求。那么ok方法，得到的资源就少，进而被影响。SpringBoot默认集成的是tomcat容器，里面有一个tomcat的线程池，高并发下没有多余的 线程来分解压力和处理ok方法。 每个线程都要等待3秒钟，才能拿到timeout的结果响应。那么2000个线程一起过来， Tomcat池子里的线程，马上就会被抢占完。
Jmeter压测结论：
上面还只是服务提供者8001自己测试，假如此时外部的消费者80也来访问，那消费者只能干等， 最终导致消费端80不满意，服务端8001直接被拖死。

2、新建消费者模块：cloud-consumer-feign-hystrix-order80

2.1 pom

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>jdk8cloud2021</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-consumer-feign-hystrix-order80</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <!--openfeign-->
  20.         <dependency>
  21.             <groupId>org.springframework.cloud</groupId>
  22.             <artifactId>spring-cloud-starter-openfeign</artifactId>
  23.         </dependency>
  24.         <!--hystrix-->
  25.         <dependency>
  26.             <groupId>org.springframework.cloud</groupId>
  27.             <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
  28.         </dependency>
  29.         <!--eureka client-->
  30.         <dependency>
  31.             <groupId>org.springframework.cloud</groupId>
  32.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  33.         </dependency>
  34.         <!-- 引入自己定义的api通用包，可以使用Payment支付Entity -->
  35.         <dependency>
  36.             <groupId>com.atguigu.springcloud</groupId>
  37.             <artifactId>cloud-api-commons</artifactId>
  38.             <version>${project.version}</version>
  39.         </dependency>
  40.         <!--web-->
  41.         <dependency>
  42.             <groupId>org.springframework.boot</groupId>
  43.             <artifactId>spring-boot-starter-web</artifactId>
  44.         </dependency>
  45.         <dependency>
  46.             <groupId>org.springframework.boot</groupId>
  47.             <artifactId>spring-boot-starter-actuator</artifactId>
  48.         </dependency>
  49.         <!--一般基础通用配置-->
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-devtools</artifactId>
  53.             <scope>runtime</scope>
  54.             <optional>true</optional>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>org.projectlombok</groupId>
  58.             <artifactId>lombok</artifactId>
  59.             <optional>true</optional>
  60.         </dependency>
  61.         <dependency>
  62.             <groupId>org.springframework.boot</groupId>
  63.             <artifactId>spring-boot-starter-test</artifactId>
  64.             <scope>test</scope>
  65.         </dependency>
  66.     </dependencies>
  67. </project>

2.2 yml

  1. server:
  2.   port: 80
  4. eureka:
  5.   client:
  6.     register-with-eureka: false
  7.     service-url:
  8.       defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

2.3 主启动类

  1. @SpringBootApplication
  2. @EnableFeignClients //不作为Eureak客户端了，而是作为Feign客户端
  3. public class OrderFeignHystrixMain80 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(OrderFeignHystrixMain80.class, args);
  6.     }
  7. }

2.4 业务类

2.4.1 PaymentHystrixService

  1. @Component
  2. @FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
  3. public interface PaymentHystrixService {
  4.     @GetMapping("/payment/hystrix/ok/{id}")
  5.     public String paymentInfo_Ok(@PathVariable("id") Integer id);
  7.     @GetMapping("/payment/hystrix/timeout/{id}")
  8.     public String paymentInfo_Timeout(@PathVariable("id") Integer id);
  9. }

2.4.2 OrderHystirxController

  1. @RestController
  2. @Slf4j
  3. public class OrderHystirxController {
  4.     @Resource
  5.     PaymentHystrixService paymentHystrixService;
  7.     @GetMapping("/consumer/payment/hystrix/ok/{id}")
  8.     public String paymentInfo_Ok(@PathVariable("id") Integer id) {
  9.         return paymentHystrixService.paymentInfo_Ok(id);
  10.     }
  12.     @GetMapping("/consumer/payment/hystrix/timeout/{id}")
  13.     public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
  14.         return paymentHystrixService.paymentInfo_Timeout(id);
  15.     }
  16. }

2.5 正常测试

http://localhost/consumer/payment/hystrix/timeout/31
由于使用的是Feign作为客户端，默认1s没有得到响应就会报超时错误。这是正常的，这里我们不进行改动。
image.png
http://localhost/consumer/payment/hystrix/ok/31
image.png

2.6 高并发测试

2W个线程压8001 消费端80微服务再去访问正常的OK微服务8001地址http://localhost/consumer/payment/hystrix/ok/31: 要么转圈圈等待，要么消费端报超时错误。
原因： 8001同一层次的其他接口服务被困死，因为tomcat线程池里面的工作线程已经被挤占完毕 所以80此时调用8001，客户端访问响应缓慢，转圈圈。 正因为有上述故障或不佳表现，才有了我们的降级/容错/限流等技术诞生。

3、Hystrix如何解决问题？

如何解决？解决的要求？

  • 超时导致服务器变慢(转圈)：超时不再等待
  • 出错(宕机或程序运行出错)：出错要有兜底
  • 解决
    • 对方服务(8001)超时了，调用者(80)不能一直卡死等待，必须有服务降级
    • 对方服务(8001)down机了，调用者(80)不能一直卡死等待，必须有服务降级
    • 对方服务(8001)OK，调用者(80)自己出故障或有自我要求（自己的等待时间小于服务提供者），自己处理降级

四、服务降级

不管是在消费者，还是提供者，都可以进行服务降级，使用过@HystrixCommand注解指定降级后的方法 一般服务降级 是放在 客户端

1、服务降级：8001生产者服务端 （服务端）

cloud-provider-hystrix-payment8001
服务降级：payment8001支付侧（生产者服务）
8001先从自身找问题，设置自身调用超时时间的峰值，峰值内可以正常运行。超过了就需要有兜底的方法，做服务降级fallback。向调用方法返回一个符合预期的，可以处理的备选响应（FallBack）

1.1 业务类(Service)方法上添加@HystrixCommand

  1. //模拟拥堵的情况
  2. @HystrixCommand(fallbackMethod = "paymentInfo_TimeoutHandler", commandProperties = {
  3.     //规定这个线程的超时时间是3s，3s后就由fallbackMethod指定的方法帮我“兜底”（服务降级）
  4.     @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds", value = "3000")
  5. })
  6. public String paymentInfo_Timeout(Integer id) {
  7.     int timeNumber = 5;
  8.     //int age = 10 / 0;
  9.     try {
  10.         TimeUnit.SECONDS.sleep(timeNumber);
  11.     } catch (InterruptedException e) {
  12.         e.printStackTrace();
  13.     }
  15.     return "线程池：  " + Thread.currentThread().getName() + "   payment_Timeout,  id:  " + id
  16.         + "\t"+"O(∩_∩)O哈哈~耗时(s):" + timeNumber;
  17. }
  19. public String paymentInfo_TimeoutHandler(Integer id) {
  20.     return "线程池：  "+ Thread.currentThread().getName()+"   paymentInfo_TimeoutHandler,  id:  "+id
  21.         +"\t"+"o(╥﹏╥)o";
  22. }

一旦调用服务方法失败并抛出了错误信息后，会自动调用@HystrixCommand标注好的fallbackMethod调用类中的指定方法，当前服务不可用了，做服务降级，兜底的方案都是paymentInfo_TimeOutHandler。
image.png

1.2 主启动类激活

主启动类添加新注解@EnableCircuitBreaker

1.3 测试

image.png
我们故意制造的两个异常： 1. int age = 10/0 计算异常 2. 我们定义超时时间3s，服务运行5s的超时异常 这些都会造成当前服务不可用了，就会进行服务降级，执行兜底的方案。

2、服务降级：80消费者服务端（客户端）

cloud-consumer-feign-hystrix-order80
我们自己配置过的热部署方式对java代码的改动明显，但对@HystrixCommand内属性的修改建议重启微服务

2.1 修改yaml

  1. feign:
  2.   hystrix:
  3.     enabled: true

2.2 主启动类：@EnableHystrix

开启Hystrix支持
image.png

2.3 业务类——Controller

  1. @RestController
  2. @Slf4j
  3. public class OrderHystirxController {
  4.     @Resource
  5.     PaymentHystrixService paymentHystrixService;
  7.     @GetMapping("/consumer/payment/hystrix/ok/{id}")
  8.     public String paymentInfo_Ok(@PathVariable("id") Integer id) {
  9.         return paymentHystrixService.paymentInfo_Ok(id);
  10.     }
  12.     @GetMapping("/consumer/payment/hystrix/timeout/{id}")
  13.     @HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod",commandProperties = {
  14.             @HystrixProperty(name="execution.isolation.thread.timeoutInMilliseconds",
  15.                     value="1500")
  16.     })
  17.     public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
  18.         return paymentHystrixService.paymentInfo_Timeout(id);
  19.     }
  21.     public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id)
  22.     {
  23.         return "我是消费者80,对方支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己,o(╥﹏╥)o";
  24.     }
  26. }

image.png

2.4 测试

把8001服务端的业务处理时间设置为2s，设定3s以内是正常的，保证8001服务端能够正常运行。

3、进一步优化

3.1 目前存在的问题——代码臃肿、耦合度高

  • 我们现在服务降级的方法和业务处理的方法混杂在了一块，耦合度很高。
  • 如果每个接口，每个方法都需要一个“兜底”方法，那么就会造成代码臃肿

所以我们需要一个全局的服务降级：global fallback；需要特殊照顾的方法，我们再进行精确的配置服务降级。

3.2 解决代码臃肿

1：1 每个方法配置一个服务降级方法，技术上可以，实际上傻X
1：N 除了个别重要核心业务有专属，其它普通的可以通过@DefaultProperties(defaultFallback = “”) 统一跳转到统一处理结果页面
通用的和独享的各自分开，避免了代码膨胀，合理减少了代码量。

下面以消费者服务端80为例：cloud-consumer-feign-hystrix-order80

  • 在业务类Controller上加@DefaultProperties(defaultFallback = “method_name”)注解，并指明defaultFallback
  • 在需要服务降级的方法上标注@HystrixCommand 注解
    • 如果@HystrixCommand里没有指明fallbackMethod，就默认使用@DefaultProperties(defaultFallback = “method_name”)中指明的降级服务

image.png
测试
image.png

3.3 降低代码耦合度

在80微服务中，它没有注册进eureka注册中心成为eureka客户端。
image.png
而是通过openFeign，成为一个Feign客户端，通过Feign来进行微服务的调用和负载均衡。
直接定义Service层的接口通过@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")这个注解找CLOUD-PROVIDER-HYSTRIX-PAYMENT这个微服务中的方法进行调用。
image.png

即： 只要是用Feign进行微服务的调用，那么一定有标注@FeignClient(value = “CLOUD-PROVIDER-HYSTRIX-PAYMENT”)的接口，这个接口就能实现调用其他微服务的操作，因此我们将这个接口中的全部方法进行统一的fallback服务降级。

解耦案例——服务降级：客户端调用服务端，遇到服务端宕机或关闭等极端情况

本次案例服务降级是在客户端80实现完成，与服务端8001没有关系。

只需要为Feign客户端定义的接口添加一个服务降级实现类即可实现解耦
未来我们遇到的异常有：运行时异常、超时、宕机

修改cloud-consumer-feign-hystrix-order80

根据cloud-consumer-feign-hystrix-order80已经有的PaymentHystrixService接口，重新新建一个类(PaymentFallbackService)实现该接口，统一为接口里面的方法进行异常处理。

  1. @Component  //不要忘记这个注解
  2. public class PaymentFallbackService implements PaymentHystrixService{
  4.     @Override
  5.     public String paymentInfo_Ok(Integer id) {
  6.         return "------PaymentFallbackService-paymentInfo_Ok, fallback";
  7.     }
  9.     @Override
  10.     public String paymentInfo_Timeout(Integer id) {
  11.         return "------PaymentFallbackService-paymentInfo_Timeout, fallback";
  12.     }
  13. }

修改PaymentHystrixService接口，指定其服务异常处理类：

@Component
@FeignClient(value = “CLOUD-PROVIDER-HYSTRIX-PAYMENT”, fallback = PaymentFallbackService.class)
public interface PaymentHystrixService {
@GetMapping(“/payment/hystrix/ok/{id}”)
public String paymentInfo_Ok(@PathVariable(“id”) Integer id);

  1. @GetMapping("/payment/hystrix/timeout/{id}")<br />    public String paymentInfo_Timeout(@PathVariable("id") Integer id);<br />}

确认yml配置文件中开启了hystrix

  1. # 用于服务降级 在注解@FeignClient中添加fallbackFactory属性值
  2. feign:
  3.   hystrix:
  4.     enabled: true  #在Feign中开启Hystrix

目的是为了实现以下效果：

  • 正常运行的话就找指定的微服务中的方法执行；
  • 异常的话就找PaymentFallbackService，由它来统一进行服务降级的处理

这样的话客户端的OrderHystirxController中就不需要再进行降级处理，降级处理只针对要调用的微服务，因此降低了服务降级和客户端的耦合度。

测试

启动7001、7002（我这里用了集群）、8001、80
8001端口正常运行：
image.png
8001端口宕机：此时服务端provider已经down了，但是我们做了服务降级处理，让客户端在服务端不可用时也会获得提示信息而不会挂起耗死服务器
image.png

五、服务熔断

熔断也会出发服务降级。

1、熔断机制概述

熔断机制是应对雪崩效应的一种微服务链路保护机制。当扇出链路的某个微服务出错不可用或者响应时间太长时，会进行服务的降级，进而熔断该节点微服务的调用，快速返回错误的响应信息。
当检测到该节点微服务调用响应正常后，自动恢复调用链路。

熔断状态： 开启 关闭 半开启

image.png
在SpringCloud框架中，熔断机制通过Hystrix实现。Hystrix会监控微服务间调用的状况。
当失败的调用到一定阈值，缺省时5秒内20次调用失败，就会启动熔断机制，熔断机制的注解是@HystrixCommand
大神论文：https://martinfowler.com/bliki/CircuitBreaker.html

半开状态： 比如说一个微服能承受100的并发量，某一时刻有500人同时访问。该服务就会崩掉，熔断，直接当掉。 外部此时不能访问了，过了一会，发现没有那么高的并发量了。感觉并发量在我的承受之内了(100)。 比如1s/72次，那么就试着这放开这些并发请求。 放着放着发现能够适应当前的并发量了，我再把闸道合上。 放着放着的状态就是半开状态，然后再把断路器关闭变成关闭的状态。

2、Hystrix服务熔断案例

2.1 对8001服务端的Service层进行改造 增加熔断机制

  • circuitBreaker.enabled：是否开启断路器
  • circuitBreaker.requestVolumeThreshold：该属性设置滚动窗口（快照时间窗口，默认10s）中将使断路器跳闸的最小请求数量（默认是20），如果10s内请求数小于设定值，就算请求全部失败也不会触发断路器。
  • circuitBreaker.sleepWindowInMilliseconds：短路多久以后开始尝试是否恢复，默认5s
  • circuitBreaker.errorThresholdPercentage：失败率达到多少后跳闸
  • metrics.rollingStats.timeInMilliseconds：快照时间窗、滚动窗口

总的意思就是在10s的时间窗口期内，m次请求中有p%的请求失败了，那么断路器启动，随后短路n秒后开始尝试恢复

  1. //=============================服务熔断===============================
  2. @HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback",commandProperties = {
  3.     @HystrixProperty(name = "circuitBreaker.enabled",value = "true"), //是否开启断路器
  4.     @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"),  //最小请求次数
  5.     //短路多久以后开始尝试是否恢复，默认5s
  6.     @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"), 
  7.     @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "60")  //失败率达到多少后跳闸
  8. })   //总的意思就是在n毫秒内的时间窗口期内，m次请求中有p%的请求失败了，那么断路器启动
  9. public String paymentCircuitBreaker(@PathVariable("id") Integer id)
  10. {
  11.     if(id < 0)
  12.     {
  13.         throw new RuntimeException("******id 不能负数");
  14.     }
  15.     String serialNumber = IdUtil.simpleUUID();  //等价于UUID.randomUUID().toString()
  17.     return Thread.currentThread().getName()+"\t"+"调用成功，流水号: " + serialNumber;
  18. }
  19. public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id)
  20. {
  21.     return "id 不能负数，请稍后再试，/(ㄒoㄒ)/~~   id: " +id;
  22. }

2.2 修改模块cloud-provider-hystrix-payment8001的controller层

  1. //===================服务熔断====================
  2. @GetMapping("/payment/circuit/{id}")
  3. public String paymentCircuitBreaker(@PathVariable("id") Integer id)
  4. {
  5.     String result = paymentService.paymentCircuitBreaker(id);
  6.     log.info("****result: "+result);
  7.     return result;
  8. }

2.3 测试

2.3.1 正确跟错误情况自测

启动7001、7002（我这里启动了Eureka集群）和8001
http://localhost:8001/payment/circuit/-5 http://localhost:8001/payment/circuit/5
image.pngimage.png

2.3.2 测试熔断机制

测试一下单位时间请求达到10次/10s以上，在10s内执行了超过10*0.6 = 6次的异常请求，随后进行短路。（10个/10s 注意分母是10s。 默认20个/10s） 短路10s后尝试恢复
@HystrixProperty(name = “circuitBreaker.requestVolumeThreshold”,value = “10”)
触发了Hystrix的断路器，即使传入正确的参数，也出现服务降级
image.png
隔了一会才恢复
image.png

3、Hystrix服务熔断总结

3.1 熔断类型

  • 熔断打开：请求不再进行调用当前服务，再有请求调用时将不会调用主逻辑，而是直接调用降级fallback。实现了自动的发现错误并将降级逻辑切换为主逻辑，减少响应延迟效果。内部设置时钟一般为MTTR（Mean time to repair，平均故障处理时间)，当打开时长达到所设时钟则进入半熔断状态。
  • 熔断关闭：熔断关闭不会对服务进行熔断，服务正常调用
  • 熔断半开：部分请求根据规则调用当前服务，如果请求成功且符合规则则认为当前服务恢复正常，关闭熔断

image.png

3.2 断路器在什么情况下开始起作用

image.png
涉及到断路器的四个重要参数：快照时间窗、请求总数阀值、窗口睡眠时间、错误百分比阀值。

  • 1：快照时间窗（滚动窗口）：断路器确定是否打开需要统计一些请求和错误数据，而统计的时间范围就是快照时间窗，默认为最近的10秒。
    • 对应红框中的metrics.rollingStats.timeInMilliseconds
  • 2：请求总数阀值：在快照时间窗内，必须满足请求总数阀值才有资格熔断。默认为20，意味着在10秒内，如果该hystrix命令的调用次数不足20次，即使所有的请求都超时或其他原因失败，断路器都不会打开。
    • 对应红框中的circuitBreaker.requestVolumeThreshold
  • 3：窗口睡眠时间：剩下一个表示窗口睡眠时间，即断路器触发多少秒（默认5s）后尝试恢复，进入半开状态。
    • 对应红框中的circuitBreaker.sleepWindowInMilliseconds
  • 4：错误百分比阀值：当请求总数在快照时间窗内超过了阀值，比如发生了30次调用，如果在这30次调用中，有15次发生了超时异常，也就是超过50%的错误百分比，在默认设定50%阀值情况下，这时候就会将断路器打开。
    • 对应红框中的circuitBreaker.errorThresholdPercentage

      3.3 断路器开启或关闭条件

      1、当满足一定的阈值的时候（默认10秒内超过20个请求次数）；
      2、当失败率达到一定的时候（默认10秒内超过50%的请求失败）；
      3、到达以上阈值，断路器将会开启；
      4、当开启的时候，所有请求都不会进行转发；
      5、一段时间之后（默认是5秒），这个时候断路器是半开状态，会让其中一个请求进行转发；如果成功，断路器会关闭，若失败，继续开启。重复4和5。

      3.4 断路器打开之后

      1： 再有请求调用的时候，还会调用主逻辑吗？

      将不会调用主逻辑，而是直接调用降级的fallback方法，通过断路器，实现了自动的发现错误并将降级逻辑升级为主逻辑，减少响应延迟的效果。

2：原来的主逻辑要如何恢复？

  • 对于这一问题mhystrix也为我们实现了自动恢复功能。
  • 当断路器打开，对主逻辑进行熔断之后，hystrix会启动一个休眠时间窗，在这个时间窗内，降级逻辑是临时的成为主逻辑。
  • 当休眠时间窗到期，断路器将进入半开状态，释放给一次请求到原来的主逻辑上，如果此次请求正常返回，那么断路器将继续闭合。

  • 主逻辑恢复，如果这次请求依然有问题，断路器继续进入打开状态，休眠时间窗重新计时。

    3.5 所有的配置

    1. //========================All
    2. @HystrixCommand(fallbackMethod = "str_fallbackMethod",
    3.       groupKey = "strGroupCommand",
    4.       commandKey = "strCommand",
    5.       threadPoolKey = "strThreadPool",
    7.       commandProperties = {
    8.               // 设置隔离策略，THREAD 表示线程池 SEMAPHORE：信号池隔离
    9.               @HystrixProperty(name = "execution.isolation.strategy", value = "THREAD"),
    10.               // 当隔离策略选择信号池隔离的时候，用来设置信号池的大小（最大并发数）
    11.               @HystrixProperty(name = "execution.isolation.semaphore.maxConcurrentRequests", value = "10"),
    12.               // 配置命令执行的超时时间
    13.               @HystrixProperty(name = "execution.isolation.thread.timeoutinMilliseconds", value = "10"),
    14.               // 是否启用超时时间
    15.               @HystrixProperty(name = "execution.timeout.enabled", value = "true"),
    16.               // 执行超时的时候是否中断
    17.               @HystrixProperty(name = "execution.isolation.thread.interruptOnTimeout", value = "true"),
    18.               // 执行被取消的时候是否中断
    19.               @HystrixProperty(name = "execution.isolation.thread.interruptOnCancel", value = "true"),
    20.               // 允许回调方法执行的最大并发数
    21.               @HystrixProperty(name = "fallback.isolation.semaphore.maxConcurrentRequests", value = "10"),
    22.               // 服务降级是否启用，是否执行回调函数
    23.               @HystrixProperty(name = "fallback.enabled", value = "true"),
    24.               // 是否启用断路器
    25.               @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),
    26.               // 该属性用来设置在滚动时间窗中，断路器熔断的最小请求数。例如，默认该值为 20 的时候，
    27.               // 如果滚动时间窗（默认10秒）内仅收到了19个请求， 即使这19个请求都失败了，断路器也不会打开。
    28.               @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
    29.               // 该属性用来设置在滚动时间窗中，表示在滚动时间窗中，在请求数量超过
    30.               // circuitBreaker.requestVolumeThreshold 的情况下，如果错误请求数的百分比超过50,
    31.               // 就把断路器设置为 "打开" 状态，否则就设置为 "关闭" 状态。
    32.               @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50"),
    33.               // 该属性用来设置当断路器打开之后的休眠时间窗。 休眠时间窗结束之后，
    34.               // 会将断路器置为 "半开" 状态，尝试熔断的请求命令，如果依然失败就将断路器继续设置为 "打开" 状态，
    35.               // 如果成功就设置为 "关闭" 状态。
    36.               @HystrixProperty(name = "circuitBreaker.sleepWindowinMilliseconds", value = "5000"),
    37.               // 断路器强制打开
    38.               @HystrixProperty(name = "circuitBreaker.forceOpen", value = "false"),
    39.               // 断路器强制关闭
    40.               @HystrixProperty(name = "circuitBreaker.forceClosed", value = "false"),
    41.               // 滚动时间窗设置，该时间用于断路器判断健康度时需要收集信息的持续时间
    42.               @HystrixProperty(name = "metrics.rollingStats.timeinMilliseconds", value = "10000"),
    43.               // 该属性用来设置滚动时间窗统计指标信息时划分"桶"的数量，断路器在收集指标信息的时候会根据
    44.               // 设置的时间窗长度拆分成多个 "桶" 来累计各度量值，每个"桶"记录了一段时间内的采集指标。
    45.               // 比如 10 秒内拆分成 10 个"桶"收集这样，所以 timeinMilliseconds 必须能被 numBuckets 整除。否则会抛异常
    46.               @HystrixProperty(name = "metrics.rollingStats.numBuckets", value = "10"),
    47.               // 该属性用来设置对命令执行的延迟是否使用百分位数来跟踪和计算。如果设置为 false, 那么所有的概要统计都将返回 -1。
    48.               @HystrixProperty(name = "metrics.rollingPercentile.enabled", value = "false"),
    49.               // 该属性用来设置百分位统计的滚动窗口的持续时间，单位为毫秒。
    50.               @HystrixProperty(name = "metrics.rollingPercentile.timeInMilliseconds", value = "60000"),
    51.               // 该属性用来设置百分位统计滚动窗口中使用 “ 桶 ”的数量。
    52.               @HystrixProperty(name = "metrics.rollingPercentile.numBuckets", value = "60000"),
    53.               // 该属性用来设置在执行过程中每个 “桶” 中保留的最大执行次数。如果在滚动时间窗内发生超过该设定值的执行次数，
    54.               // 就从最初的位置开始重写。例如，将该值设置为100, 滚动窗口为10秒，若在10秒内一个 “桶 ”中发生了500次执行，
    55.               // 那么该 “桶” 中只保留 最后的100次执行的统计。另外，增加该值的大小将会增加内存量的消耗，并增加排序百分位数所需的计算时间。
    56.               @HystrixProperty(name = "metrics.rollingPercentile.bucketSize", value = "100"),
    57.               // 该属性用来设置采集影响断路器状态的健康快照（请求的成功、 错误百分比）的间隔等待时间。
    58.               @HystrixProperty(name = "metrics.healthSnapshot.intervalinMilliseconds", value = "500"),
    59.               // 是否开启请求缓存
    60.               @HystrixProperty(name = "requestCache.enabled", value = "true"),
    61.               // HystrixCommand的执行和事件是否打印日志到 HystrixRequestLog 中
    62.               @HystrixProperty(name = "requestLog.enabled", value = "true"),
    63.       },
    64.       threadPoolProperties = {
    65.               // 该参数用来设置执行命令线程池的核心线程数，该值也就是命令执行的最大并发量
    66.               @HystrixProperty(name = "coreSize", value = "10"),
    67.               // 该参数用来设置线程池的最大队列大小。当设置为 -1 时，线程池将使用 SynchronousQueue 实现的队列，
    68.               // 否则将使用 LinkedBlockingQueue 实现的队列。
    69.               @HystrixProperty(name = "maxQueueSize", value = "-1"),
    70.               // 该参数用来为队列设置拒绝阈值。 通过该参数， 即使队列没有达到最大值也能拒绝请求。
    71.               // 该参数主要是对 LinkedBlockingQueue 队列的补充,因为 LinkedBlockingQueue
    72.               // 队列不能动态修改它的对象大小，而通过该属性就可以调整拒绝请求的队列大小了。
    73.               @HystrixProperty(name = "queueSizeRejectionThreshold", value = "5"),
    74.       }
    75. )
    76. public String strConsumer() {
    77.   return "hello 2020";
    78. }
    79. public String str_fallbackMethod()
    80. {
    81.   return "*****fall back str_fallbackMethod";
    82. }

    //六、服务限流

    在spring cloud alibaba Sentinel时再说！

    七、Hystrix工作流程

    https://github.com/Netflix/Hystrix/wiki/How-it-Works

    工作流程图

    image.png

    步骤说明

    | 1 | 创建 HystrixCommand（用在依赖的服务返回单个操作结果的时候） 或 HystrixObserableCommand（用在依赖的服务返回多个操作结果的时候） 对象。 | | —- | —- | | 2 | 命令执行。其中 HystrixComand 实现了下面前两种执行方式；而 HystrixObservableCommand 实现了后两种执行方式：execute()：同步执行，从依赖的服务返回一个单一的结果对象， 或是在发生错误的时候抛出异常。queue()：异步执行， 直接返回 一个Future对象， 其中包含了服务执行结束时要返回的单一结果对象。observe()：返回 Observable 对象，它代表了操作的多个结果，它是一个 Hot Obserable（不论 “事件源” 是否有 “订阅者”，都会在创建后对事件进行发布，所以对于 Hot Observable 的每一个 “订阅者” 都有可能是从 “事件源” 的中途开始的，并可能只是看到了整个操作的局部过程）。toObservable()： 同样会返回 Observable 对象，也代表了操作的多个结果，但它返回的是一个Cold Observable（没有 “订阅者” 的时候并不会发布事件，而是进行等待，直到有 “订阅者” 之后才发布事件，所以对于 Cold Observable 的订阅者，它可以保证从一开始看到整个操作的全部过程）。 | | 3 | 若当前命令的请求缓存功能是被启用的， 并且该命令缓存命中， 那么缓存的结果会立即以 Observable 对象的形式 返回。 | | 4 | 检查断路器是否为打开状态。如果断路器是打开的，那么Hystrix不会执行命令，而是转接到 fallback 处理逻辑（第 8 步）；如果断路器是关闭的，检查是否有可用资源来执行命令（第 5 步）。 | | 5 | 线程池/请求队列/信号量是否占满。如果命令依赖服务的专有线程池和请求队列，或者信号量（不使用线程池的时候）已经被占满， 那么 Hystrix 也不会执行命令， 而是转接到 fallback 处理逻辑（第8步）。 | | 6 | Hystrix 会根据我们编写的方法来决定采取什么样的方式去请求依赖服务。HystrixCommand.run() ：返回一个单一的结果，或者抛出异常。HystrixObservableCommand.construct()： 返回一个Observable 对象来发射多个结果，或通过 onError 发送错误通知。 | | 7 | Hystrix会将 “成功”、”失败”、”拒绝”、”超时” 等信息报告给断路器， 而断路器会维护一组计数器来统计这些数据。断路器会使用这些统计数据来决定是否要将断路器打开，来对某个依赖服务的请求进行 “熔断/短路”。 | | 8 | 当命令执行失败的时候， Hystrix 会进入 fallback 尝试回退处理， 我们通常也称该操作为 “服务降级”。而能够引起服务降级处理的情况有下面几种：第4步： 当前命令处于”熔断/短路”状态，断路器是打开的时候。第5步： 当前命令的线程池、 请求队列或 者信号量被占满的时候。第6步：HystrixObservableCommand.construct() 或 HystrixCommand.run() 抛出异常的时候。 | | 9 | 当Hystrix命令执行成功之后， 它会将处理结果直接返回或是以Observable 的形式返回。 |

tips：如果我们没有为命令实现降级逻辑或者在降级处理逻辑中抛出了异常， Hystrix 依然会返回一个 Observable 对象， 但是它不会发射任何结果数据， 而是通过 onError 方法通知命令立即中断请求，并通过onError()方法将引起命令失败的异常发送给调用者。

八、服务监控 HystrixDashBoard

除了隔离依赖服务的调用以外，Hystrix还提供了准实时的调用监控（Hystrix Dashboard）Hystrix会持续的记录所有通过Hystrix发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等，Netflix通过hystrix-metrics-event-stream项目实现了对以上指标的监控，Spring Cloud提供了Hystrix Dashboard的整合，对监控内容转化成可视化页面。

8.1 新建cloud-consumer-hystrix-dashboard9001

8.1.2 pom

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>jdk8cloud2021</artifactId>
  7.         <groupId>com.atguigu.springcloud</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>cloud-consumer-hystrix-dashboard9001</artifactId>
  14.     <properties>
  15.         <maven.compiler.source>8</maven.compiler.source>
  16.         <maven.compiler.target>8</maven.compiler.target>
  17.     </properties>
  18.     <dependencies>
  19.         <dependency>
  20.             <groupId>org.springframework.cloud</groupId>
  21.             <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
  22.         </dependency>
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-actuator</artifactId>
  26.         </dependency>
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-devtools</artifactId>
  31.             <scope>runtime</scope>
  32.             <optional>true</optional>
  33.         </dependency>
  34.         <dependency>
  35.             <groupId>org.projectlombok</groupId>
  36.             <artifactId>lombok</artifactId>
  37.             <optional>true</optional>
  38.         </dependency>
  39.         <dependency>
  40.             <groupId>org.springframework.boot</groupId>
  41.             <artifactId>spring-boot-starter-test</artifactId>
  42.             <scope>test</scope>
  43.         </dependency>
  44.     </dependencies>
  45. </project>

8.1.3 yaml

image.png给个端口号就行

8.1.4 主启动类

HystrixDashboardMain9001+新注解@EnableHystrixDashboard

  1. @SpringBootApplication
  2. @EnableHystrixDashboard // 开启Hystrix仪表盘
  3. public class HystrixDashboardMain9001 {
  4.     public static void main(String[] args) {
  5.         SpringApplication.run(HystrixDashboardMain9001.class, args);
  6.     }
  7. }

所有provider微服务（生产者）提供类8001/8002/8003都需要监控依赖配置

确保所有生产者微服务中均包含spring-boot-starter-actuator依赖

org.springframework.boot spring-boot-starter-actuator

8.1.5 启动测试

http://localhost:9001/hystrix
image.png

8.2 断路器演示(服务监控hystrixDashboard)

微服务想要被监控必须要有spring-boot-starter-actuator依赖

8.2.1 注意事项

注意:新版本Hystrix需要在需要监控的微服务端的主启动类中指定监控路径，不然会报错：
Hystrix断路器 - 图29

在被监控的服务端主启动类中添加以下代码，这里以【PaymentHystrixMain8001】为示例

  1. @SpringBootApplication
  2. @EnableEurekaClient  //本服务启动后会自动注册进eureka服务中
  3. @EnableCircuitBreaker  //对hystrixR熔断机制的支持
  4. public class PaymentHystrixMain8001 {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(PaymentHystrixMain8001.class, args);
  7.     }
  9.     /** ======================================需要添加的代码==================
  10.      *此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
  11.      *ServletRegistrationBean因为springboot的默认路径不是"/hystrix.stream"，
  12.      *只要在自己的项目里配置上下面的servlet就可以了
  13.      */
  14.     @Bean
  15.     public ServletRegistrationBean getServlet() {
  16.         HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
  17.         ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
  18.         registrationBean.setLoadOnStartup(1);
  19.         registrationBean.addUrlMappings("/hystrix.stream");
  20.         registrationBean.setName("HystrixMetricsStreamServlet");
  21.         return registrationBean;
  22.     }
  23. }

8.2.2 测试

  • 启动Eureka7001、Eureka7002（我这里用的是两个Eureka的集群，视频里是单个）、8001、9001
  • 9001监控8001

image.png

image.pngimage.png

  • 打开监控页面

image.png
image.png

image.png

image.png

8.2.3 监控页的各个地方表示什么意思？

7色1圈
image.png
实心圆：共有两种含义。它通过颜色的变化代表了实例的健康程度，它的健康度从绿色<黄色<橙色<红色递减。
该实心圆除了颜色的变化之外，它的大小也会根据实例的请求流量发生变化，流量越大该实心圆就越大。所以通过该实心圆的展示，就可以在大量的实例中快速的发现故障实例和高压力实例。
曲线：用来记录2分钟内流量的相对变化，可以通过它来观察到流量的上升和下降趋势。

图片说明：
image.png
image.png