Hystrix 断路器

---

---

1-分布式系统面临问题

复杂分布式体系结构中的应用程序有数十个依赖关系，每个依赖关系在某些时候将不可避免地失败。

1.1-服务雪崩

多个微服务之间调用的时候，假设微服务 A 调用微服务 B 和微服务 C，微服务 B 和微服务 C 又调用其它的微服务，这就是所谓的扇出。如果扇出的链路上某个微服务的调用响应时间过长或者不可用，对微服务 A 的调用就会占用越来越多的系统资源，进而引起系统崩溃，所谓的雪崩效应。

对于高流量的应用来说，单一的后端依赖可能会导致所有服务器上的所有资源都在几秒钟内饱和。比失败更糟糕的是，这些应用程序还可能导致服务之间的延迟增加，备份队列，线程和其他系统资源紧张，导致整个系统发生更多的级联故障。这些都表示需要对故障和延迟进行隔离和管理，以便单个依赖关系的失败，不能取消整个应用程序或系统。

通常当你发现一个模块下的某个实例失败后，这时候这个模块依然还会接收流量，然后这个有问题的模块还调用了其他的模块，这样就会发生级联故障，或者叫雪崩。

1.2-解决方案

一般情况对于服务依赖的保护主要有 3 种解决方案。

1.2.1-隔离模式

这种模式就像对系统请求按类型划分成一个个小岛的一样，当某个小岛被火少光了，不会影响到其他的小岛。例如可以对不同类型的请求使用线程池来资源隔离，每种类型的请求互不影响，如果一种类型的请求线程资源耗尽，则对后续的该类型请求直接返回，不再调用后续资源。这种模式使用场景非常多，例如将一个服务拆开，对于重要的服务使用单独服务器来部署，再或者公司最近推广的多中心。

1.2.2-熔断模式

这种模式主要是参考电路熔断，如果一条线路电压过高，保险丝会熔断，防止火灾。放到我们的系统中，如果某个目标服务调用慢或者有大量超时，此时熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。

1.2.3-限流模式

上述的熔断模式和隔离模式都属于出错后的容错处理机制，而限流模式则可以称为预防模式。限流模式主要是提前对各个类型的请求设置最高的 QPS 阈值，若高于设置的阈值则对该请求直接返回，不再调用后续资源。这种模式不能解决服务依赖的问题，只能解决系统整体资源分配问题，因为没有被限流的请求依然有可能造成雪崩效应。

---

2-Hystrix 概述

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

2.1-是什么

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

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

2.2-能干嘛

2.2.1-服务降级

其实就是线程池中单个线程障处理，防止单个线程请求时间太长，导致资源长期被占有而得不到释放，从而导致线程池被快速占用完，导致服务崩溃。

Hystrix 能解决如下问题：

• 请求超时降级，线程资源不足降级，降级之后可以返回自定义数据。

• 线程池隔离降级，分布式服务可以针对不同的服务使用不同的线程池，从而互不影响。

• 自动触发降级与恢复。

• 实现请求缓存和请求合并。

2.2.2-服务熔断

这种模式主要是参考电路熔断，如果一条线路电压过高，保险丝会熔断，防止火灾。放到我们的系统中，如果某个目标服务调用慢或者有大量超时，此时熔断该服务的调用，对于后续调用请求，不在继续调用目标服务，直接返回，快速释放资源。如果目标服务情况好转则恢复调用。

2.2.3-服务限流

主要是提前对各个类型的请求设置最高的 QPS 阈值，若高于设置的阈值则对该请求直接返回，不再调用后续资源。这种模式不能解决服务依赖的问题，只能解决系统整体资源分配问题，因为没有被限流的请求依然有可能造成雪崩效应。

2.2.4-准实时监控

2.3-停更

Hystrix 官宣停更进维：https://github.com/Netflix/Hystrix

• 被动修复 Bug。

• 不再接受合并请求。

• 不再发布新版本。

---

3-Hystrix 核心

3.2-服务降级

服务降级：服务器忙，请稍候再试，不让客户端等待并立刻返回一个友好提示。

哪些情况会触发降级？

• 程序运行异常。

• 超时。

• 服务熔断触发服务降级。

• 线程池、信号量打满也会导致服务降级。

3.1-服务熔断

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

服务的降级 -> 进而熔断 -> 恢复调用链路

3.3-服务限流

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

---

4-Hystrix 配置

正确 -> 错误 -> 降级、熔断 -> 恢复

4.1-提供者服务(hystrix) cloud-provider-hystrix-payment8001

a、右击父工程 mscloud，新建子模块 cloud-provider-hystrix-payment8001

b、修改子模块 cloud-provider-hystrix-payment8001 中 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-provider-hystrix-payment8001</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

c、修改子模块 cloud-provider-hystrix-payment8001，目录 /src/main/resources 中新建 application.yml

server:
  port: 8001

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      #设置与 Eureka Server 交互的地址查询服务和注册服务都需要依赖这个地址
      defaultZone: http://eureka7001.com:7001/eureka/

spring:
  application:
    name: cloud-provider-hystrix-payment

d、修改子模块 cloud-provider-hystrix-payment8001，目录 /src/main/java 中新建包 com.atguigu.springcloud

e、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud 中新建启动类 PaymentHystrixMain8001.java

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class PaymentHystrixMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentHystrixMain8001.class,args);
    }
}

f、修改子模块 cloud-provider-hystrix-payment8001，目录 /src/main/java 中新建包 com.atguigu.springcloud.service

g、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud.service 中新建类 PaymentService.java

package com.atguigu.springcloud.service;

import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {
    // 成功
    public String paymentInfo_OK(Integer id) {
        return "线程池：" + Thread.currentThread().getName() + "  paymentInfo_OK," +
                "id：  " + id + "\t" + "哈哈哈";
    }

    // 失败
    public String paymentInfo_TimeOut(Integer id) {
        int timeNumber = 3;
        try {
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() + "  paymentInfo_TimeOut," +
                "id：  " + id + "\t" + "呜呜呜" + " 耗时(秒)" + timeNumber;
    }
}

h、修改子模块 cloud-provider-hystrix-payment8001，目录 /src/main/java 中新建包 com.atguigu.springcloud.controller

i、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud.controller 中新建类 PaymentController.java

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.service.PaymentService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;
    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        String result = paymentService.paymentInfo_OK(id);
        log.info("*******result:" + result);
        return result;
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        String result = paymentService.paymentInfo_TimeOut(id);
        log.info("*******result:" + result);
        return result;
    }
}

j、测试子模块 cloud-provider-hystrix-payment8001

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001

• http://localhost:8001/payment/hystrix/ok/31
  

• http://localhost:8001/payment/hystrix/timeout/31

  每次调用耗费 5 秒钟。
  

4.2-高并发压测

上面接口在非高并发情况下，还能勉强满足。

Jmeter 压力测试：

• 开启 Jmeter，创建 2w 并发访问子模块 cloud-provider-hystrix-payment8001，2w 请求都去访问 /payment/hystrix/timeout/xx 服务。
  
  

• 再次访问：

  • http://localhost:8001/payment/hystrix/ok/31
    

  • http://localhost:8001/payment/hystrix/timeout/31
    

• 两个服务接口都在转圈圈，为什么会被卡死？

  Tomcat 默认的工作线程数被打满了，没有多余的线程来分解压力和处理。

Jmeter 压测结论：

上面只是微服务提供者(8001)自测，假如此时外部的微服务消费者(80)也来访问，微服务消费者只能干等，最终导致微服务消费者(80)不满意，微服务提供者(8001)直接被拖死。

4.3-消费者服务(hystrix) cloud-consumer-feign-hystrix-order80

a、右击父工程 mscloud，新建子模块 cloud-consumer-feign-hystrix-order80

b、修改子模块 cloud-consumer-feign-hystrix-order80 中 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-consumer-feign-hystrix-order80</artifactId>

    <dependencies>
        <dependency>
            <groupId>com.atguigu.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

c、修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/resources 中新建 application.yml

server:
  port: 80

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

spring:
  application:
    name: cloud-provider-hystrix-order

d、修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/java 中新建包 com.atguigu.springcloud

e、修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud 中新建启动类 OrderHystrixMain80.java

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
public class OrderHystrixMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderHystrixMain80.class, args);
    }
}

f、修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/java 中新建包 com.atguigu.springcloud.service

g、修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud.service 中新建接口 PaymentHystrixService.java

package com.atguigu.springcloud.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")
public interface PaymentHystrixService {
    @GetMapping("/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

h、修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/java 中新建包 com.atguigu.springcloud.controller

i、修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud.controller 中新建类 OrderHystrixController.java

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.service.PaymentHystrixService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@Slf4j
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_OK(id);
        log.info("*******result:" + result);
        return result;
    }

    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        log.info("*******result:" + result);
        return result;
    }
}

j、测试子模块 cloud-consumer-feign-hystrix-order80

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001

• 启动子模块 cloud-consumer-feign-hystrix-order80

• http://localhost/consumer/payment/hystrix/ok/31
  

• Jmeter 2w 并发压测子模块 cloud-provider-hystrix-payment8001

• http://localhost/consumer/payment/hystrix/timeout/31

  微服务消费者(80)再次访问微服务提供者(8001)，要么转圈圈等待，要么微服务消费者(80)报超时错误。
  

4.4-故障现象

故障现象和导致原因：

• 微服务提供者(8001)中其他服务接口被卡死，因为 Tomcat 线程里面的工作线程已经被挤占完毕。

• 微服务消费者(80)此时调用微服务提供者(8001)，客户端访问响应缓慢，转圈圈。

上诉结论：

正因为有上述故障或不佳表现，才有我们的降级、容错、限流等技术诞生。

如何解决？

• 超时导致服务器变慢（转圈）。

• 超时不再等待。

• 出错（宕机或程序运行出错）。

• 出错要有兜底。

解决方法：

• 微服务提供者(8001)假如超时了，微服务消费者(80)不能一直卡死等待，必须有服务降级。

• 微服务提供者(8001)假如 Down 机了，微服务消费者(80)不能一直卡死等待，必须有服务降级。

• 微服务提供者(8001)假如 OK，微服务消费者(80)自己出故障或有自我要求（自己的等待时间小于服务提供者），自己处理降级。

4.5-服务降级

降级配置：@HystrixCommand

4.5.1-提供者服务(hystrix) cloud-provider-hystrix-payment8001 服务降级

微服务提供者(8001)设置自身调用超时时间的峰值，峰值内可以正常运行，超过了需要有兜底的方法处理，作为服务降级的 Fallback。

a、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud.service 中类 PaymentService.java

故意制造两个异常：

• 计算异常：int age = 10/0;

• 超时异常：接受超时 3 秒，它运行 5 秒钟。

当前服务不可用做服务降级，兜底的方案都是 paymentInfo_TimeOutHandler。

package com.atguigu.springcloud.service;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {
    // 成功
    public String paymentInfo_OK(Integer id) {
        return "线程池：" + Thread.currentThread().getName() + "  paymentInfo_OK,id：  " + id + "\t" + "哈哈哈";
    }

    // 失败
    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")// 3 秒钟以内就是正常的业务逻辑
    })
    public String paymentInfo_TimeOut(Integer id) {
        // int timeNumber = 5;
        int age = 10 / 0;
        // try { TimeUnit.SECONDS.sleep(timeNumber); }catch (Exception e) {e.printStackTrace();}
        //return "线程池："+Thread.currentThread().getName()+"   paymentInfo_TimeOut,id：  "+id+"\t"+"呜呜呜"+" 耗时(秒)"+timeNumber;
        return "线程池：" + Thread.currentThread().getName() + "   paymentInfo_TimeOut,id：  " + id + "\t" + "呜呜呜" + " 耗时(秒)";
    }

    // 兜底方法
    public String paymentInfo_TimeOutHandler(Integer id) {
        return "线程池：" + Thread.currentThread().getName() + "   系统繁忙, 请稍候再试  ,id：  " + id + "\t" + "哭了哇呜";
    }
}

@HystrixCommand 报异常后如何处理：

一旦调用服务方法失败并抛出了错误信息后，会自动调用 @HystrixCommand 标注好的 fallbackMethod 调用类中的指定方法。

b、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud 中启动类 PaymentHystrixMain8001.java

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.circuitbreaker.EnableCircuitBreaker;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
@EnableCircuitBreaker
public class PaymentHystrixMain8001 {
    public static void main(String[] args) {
        SpringApplication.run(PaymentHystrixMain8001.class,args);
    }
}

4.5.2-消费者服务(hystrix) cloud-consumer-feign-hystrix-order80 服务降级

微服务消费者(80)更好的保护自己，可依照微服务提供者(8001)进行降级保护。

热部署方式对 Java 代码改动明显，但对 @HystrixCommand 内属性的修改建议重启微服务。

a、修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/resources 中 application.yml

server:
  port: 80

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

feign:
  hystrix:
    # 若处理自身的容错就开启，开启方式与微服务提供者不同
    enabled: true

spring:
  application:
    name: cloud-provider-hystrix-order

b、修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud.controller 中类 OrderHystrixController.java

package com.atguigu.springcloud.controller;

import com.atguigu.springcloud.service.PaymentHystrixService;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
@Slf4j
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

    @Value("${server.port}")
    private String serverPort;

    @GetMapping("/consumer/payment/hystrix/ok/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_OK(id);
        log.info("*******result:" + result);
        return result;
    }

    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    @HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1500")  //3秒钟以内就是正常的业务逻辑
    })
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        return result;
    }

    // 兜底方法
    public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id) {
        return "我是消费者80，对付支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己,(┬＿┬)";
    }
}

c、修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud 中启动类 OrderHystrixMain80.java

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.openfeign.EnableFeignClients;

@SpringBootApplication
@EnableFeignClients
@EnableHystrix
public class OrderHystrixMain80 {
    public static void main(String[] args) {
        SpringApplication.run(OrderHystrixMain80.class, args);
    }
}

4.5.3-微服务提供者、消费者模块重构

存在问题：

• 每个业务方法对应一个 Fallback 方法，代码膨胀。

• 统一和自定义的 Fallback 方法分开。

解决问题：

• 1、OpenFeign 接口统一 Fallback 方法：@DefaultProperties(defaultFallback = “”)

  修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud.controller 中类 OrderHystrixController.java
  

  package com.atguigu.springcloud.controller;
  
  import com.atguigu.springcloud.service.PaymentHystrixService;
  import com.netflix.hystrix.contrib.javanica.annotation.DefaultProperties;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
  import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
  import lombok.extern.slf4j.Slf4j;
  import org.springframework.web.bind.annotation.GetMapping;
  import org.springframework.web.bind.annotation.PathVariable;
  import org.springframework.web.bind.annotation.RestController;
  
  import javax.annotation.Resource;
  
  @RestController
  @Slf4j
  @DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")// 全局的
  public class OrderHystrixController {
  
      @Resource
      private PaymentHystrixService paymentHystrixService;
  
      @GetMapping("/consumer/payment/hystrix/ok/{id}")
      public String paymentInfo_OK(@PathVariable("id") Integer id) {
          String result = paymentHystrixService.paymentInfo_OK(id);
          return result;
      }
  
  //    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
  //    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
  //        String result = paymentHystrixService.paymentInfo_TimeOut(id);
  //        return result;
  //    }
  
      @GetMapping("/consumer/payment/hystrix/timeout/{id}")
  //    @HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod",commandProperties = {
  //            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds",value = "1500")  //1.5秒钟以内就是正常的业务逻辑
  //    })
      @HystrixCommand
      public String paymentInfo_TimeOut(@PathVariable("id") Integer id) {
          int age = 10 / 0;
          String result = paymentHystrixService.paymentInfo_TimeOut(id);
          return result;
      }
  
      // Fallback 方法
      public String paymentTimeOutFallbackMethod(@PathVariable("id") Integer id) {
          return "我是消费者80，对付支付系统繁忙请10秒钟后再试或者自己运行出错请检查自己,(┬＿┬)";
      }
  
      // 全局 Fallback 方法
      public String payment_Global_FallbackMethod() {
          return "Global 异常处理信息，请稍后再试,(┬＿┬)";
      }
  }
  

  @DefaultProperties(defaultFallback = “”)：

  • 1:1：每个方法配置一个服务降级方法，技术上可以，实际上代码膨胀。

  • 1:N：除个别重要核心业务有专属，其它普通的可以通过 @Defaultproperties(defaultFalback = “”) 跳转到统一处理结果页面。通用的和独享的各自分开，避免了代码膨胀。

---

• 2、Fallback 方法与业务逻辑混在一起（混乱）：

  服务降级：客户端去调用服务端，碰上服务端宕机或关闭。需要面对异常：运行、超时、宕机。

  本次服务降级处理是在消费者服务(80)实现完成的，与生产者服务(8001)没有关系，只需要为 Feign 客户端定义的接口添加一个服务降级处理的实现类即可实现解耦。

修改子模块 cloud-consumer-feign-hystrix-order80，根据包 com.atguigu.springcloud.service 中已有的 PaymentHystrixService 接口，新建类 PaymentFallbackService 实现该接口，统一为接口里面的方法进行异常处理。

package com.atguigu.springcloud.service;

import org.springframework.stereotype.Component;

@Component
public class PaymentFallbackService implements PaymentHystrixService {
    @Override
    public String paymentInfo_OK(Integer id) {
        return "-----PaymentFallbackService fall back-paymentInfo_OK , (┬＿┬)";
    }

    @Override
    public String paymentInfo_TimeOut(Integer id) {
        return "-----PaymentFallbackService fall back-paymentInfo_TimeOut , (┬＿┬)";
    }
}

修改子模块 cloud-consumer-feign-hystrix-order80，目录 /src/main/resources 中 application.yml

server:
  port: 80

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

feign:
  hystrix:
    # 若处理自身的容错就开启，开启方式与微服务提供者不同
    enabled: true

spring:
  application:
    name: cloud-provider-hystrix-order

修改子模块 cloud-consumer-feign-hystrix-order80，包 com.atguigu.springcloud.service 中接口 PaymentFeignClientService.java

package com.atguigu.springcloud.service;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@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);

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id);
}

测试：

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001

• 启动子模块 cloud-consumer-feign-hystrix-order80

• http://localhost/consumer/payment/hystrix/ok/31

• 关闭子模块 cloud-provider-hystrix-payment8001
  客户端自己调用提升，此时生产者(8001)已经 Down 了，但是我们做了服务降级处理，让客户端在服务端不可用时也会获得提示信息而不会挂起耗死服务器。

4.6-服务熔断

断路器：一句话就是家里的保险丝。

熔断机制概述：

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

• SpringCloud 框架中熔断机制通过 Hystrix 实现。Hystrix 会监控微服务间调用的状况，当失败的调用到一定阈值（缺省是 5 秒内 20 次调用失败），就会启动熔断机制。熔断机制的注解是 @HystrixCommand。

4.6.1-提供者服务(hystrix) cloud-provider-hystrix-payment8001 服务熔断

a、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud.service 中类 PaymentService.java

    //服务熔断
    @HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback",commandProperties = {
            @HystrixProperty(name = "circuitBreaker.enabled",value = "true"),  //是否开启断路器
            @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold",value = "10"),   //请求次数
            @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds",value = "10000"),  //时间范围
            @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage",value = "60"), //失败率达到多少后跳闸
    })
    public String paymentCircuitBreaker(@PathVariable("id") Integer id){
        if (id < 0){
            throw new RuntimeException("*****id 不能负数");
        }
        String serialNumber = IdUtil.simpleUUID();

        return Thread.currentThread().getName()+"\t"+"调用成功,流水号："+serialNumber;
    }
    public String paymentCircuitBreaker_fallback(@PathVariable("id") Integer id){
        return "id 不能负数，请稍候再试,(┬＿┬)/~~     id: " +id;
    }

b、修改子模块 cloud-provider-hystrix-payment8001，包 com.atguigu.springcloud.controller 中类 PaymentController.java

//===服务熔断
@GetMapping("/payment/circuit/{id}")
public String paymentCircuitBreaker(@PathVariable("id") Integer id){
    String result = paymentService.paymentCircuitBreaker(id);
    log.info("*******result:"+result);
    return result;
}

c、测试

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001

• 启动子模块 cloud-consumer-feign-hystrix-order80

• http://localhost:8001/payment/circuit/31

• http://localhost:8001/payment/circuit/-31
  一次正确一次错误。重点测试：多次错误,然后慢慢正确，发现刚开始不满足条件，就算是正确的访问地址也不能进行访问，需要慢慢的恢复链路。

4.6.2-服务熔断原理

熔断类型：

• 熔断打开。

  请求不再进行调用当前服务，内部设置时钟一般为 Mttr（平均故障处理时间），当打开时长达到所设时钟则进入熔断状态。

• 熔断关闭。

  熔断关闭不会对服务进行熔断。

• 熔断半开。

  部分请求根据规则调用当前服务，如果请求成功且符合规则则认为当前服务恢复正常，关闭熔断。

断路器流程图：

断路器步骤：

断路器开启、关闭条件：

• 满足一定阀值的时候（默认 10 秒内超过 20 个请求次数）。

• 失败率达到一定的时候（默认 10 秒内超过 50% 请求失败）。

到达以上阀值，断路器将会开启。当开启的时候，所有请求都不会进行转发。一段时间之后（默认是 5 秒）断路器是半开状态，会让其中一个请求进行转发。如果成功，断路器会关闭，若失败，继续开启，一直重复。

断路器配置：

4.7-服务限流

参考 SpringCloud Alibaba Sentinel 服务熔断与限流。

---

5-Hystrix 工作流程

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

Hystrix 工作流程：

---

6-Hystrix 服务监控

6.1-监控概述

除了隔离依赖服务的调用以外，Hystrix 还提供了准实时的调用监控(Hystrix Dashboard)，Hystrix 会持续地记录所有通过 Hystrix 发起的请求的执行信息，并以统计报表和图形的形式展示给用户，包括每秒执行多少请求多少成功，多少失败等。

Netflix 通过 hystrix-metrics-event-stream 项目实现了对以上指标的监控。SpringCloud 也提供了Hystrix Dashboard的整合，对监控内容转化成可视化界面。

6.2-配置示例

a、右击父工程 mscloud，新建子模块 cloud-consumer-hystrix-dashboard9001

b、修改子模块 cloud-consumer-hystrix-dashboard9001 中 pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <artifactId>cloud2020</artifactId>
        <groupId>com.atguigu.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>cloud-consumer-hystrix-dashboard9001</artifactId>

    <dependencies>
        <!-- Hystrix Dashboard -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

d、修改子模块 cloud-consumer-hystrix-dashboard9001，目录 /src/main/resources 中新建 application.yml

server:
  port: 9001

e、修改子模块 cloud-consumer-hystrix-dashboard9001，目录 /src/main/java 中新建包 com.atguigu.springcloud

f、修改子模块 cloud-consumer-hystrix-dashboard9001，包 com.atguigu.springcloud 中新建启动类 HystrixDashboardMain9001.java

package com.atguigu.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;

@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashboardMain9001 {
    public static void main(String[] args) {
        SpringApplication.run(HystrixDashboardMain9001.class, args);
    }
}

g、生产者服务(子模块 cloud-provider-hystrix-payment8001)都需要依赖监控配置

 <dependency>
 	<groupId>org.springframework.boot</groupId>
 	<artifactId>spring-boot-starter-actuator</artifactId>
 </dependency>

h、测试 Hystrix 服务监控配置

• 启动子模块 cloud-consumer-hystrix-dashboard9001

• http://localhost:9001/hystrix

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001

6.3-断路器示例

修改 cloud-provider-hystrix-payment8001，注意：新版本Hystrix需要在主启动类MainAppHystrix8001中指定监控路径

@Bean
public ServletRegistrationBean getServlet(){
    HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(streamServlet);
    registrationBean.setLoadOnStartup(1);
    registrationBean.addUrlMappings("/hystrix.stream");
    registrationBean.setName("HystrixMetricsStreamServlet");
    return registrationBean;
}

• Unable to connect to Command Metric Stream
• 404

监控测试

• 启动子模块 cloud-consumer-hystrix-dashboard9001

• http://localhost:9001/hystrix

• 启动 Eureka 集群（子模块 cloud-eureka-server7001、cloud-eureka-server7002）

• 启动子模块 cloud-provider-hystrix-payment8001
  启动1个eureka或者3个eureka集群均可
  观察监控窗口
  9001监控8001
  

       填写监控地址
       http://localhost:8001/hystrix.stream
     测试地址
       http://localhost:8001/payment/circuit/31
       http://localhost:8001/payment/circuit/-31
       上述测试通过：ok
       先访问正确地址，再访问错误地址，再正确地址，会发现图示断路器都是慢慢放开的
  

监控结果，成功

监控结果，失败

5.3.1-7 色

• 绿：成功色

• 蓝：熔断数

• 青：错误请求数

• 黄：超时数

• 紫：线程拒绝数

• 红：失败/异常数

• 灰：最近10s错误百分比

5.3.2-1 圈

实心圆：共有两种含义。它通过颜色的变化代表了实例的健康程度，它的健康度从绿色 < 黄色 < 橙色 < 红色递减。

该实心圆除了颜色的变化之外，它的大小也会根据实例的请求流量发生变化，流量越大该实心圆就越大。所以通过该实心圆的展示，就可以在大量的实例中快速的发现故障实例和高压力实例。

5.3.3-1 线

曲线：用来记录 2 分钟内流量的相对变化，可以通过它来观察到流量的上升和下降趋势。

5.3.3-整图说明

搞懂一个才能看懂复杂的：

---