Hystrix断路器

1、介绍

①产生原因

服务雪崩：

多个微服务之间调用，假设A调用B，C，B和C又调用其他微服务，这就是扇出。

如果扇出的链路上有某个微服务调用响应时间过长或者不可用，那么A调用会占用越来越多的系统资源，最后崩溃。这就是雪崩效应。

②解决方案

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

断路器是一种开关装置，某个服务单元故障之后，通过断路器的故障监控，向调用方法返回一个符合预期，可处理的备选响应（FallBack）而不是长时间等待或者抛出调用方无法处理的异常。。

这样能保证服务调用方的线程，不会长时间，不必要的占用，从而避免故障在分布式系统中的蔓延，雪崩。

2、Hystrix概念

①服务降级

返回一个友好提示

服务器忙，不让客户端等待立即返回一个友好提示，fallback

降级原因：

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

②服务熔断

类似保险丝，达到最大服务，直接拒绝访问，然后调用服务降级方法并且友好提示

③服务限流

秒杀等高并发操作，严禁一窝蜂调用，排队调用，每秒N个，有序进行

3、服务雪崩模拟

①无熔断降级项目搭建

1.首先将eureka的注册中心，设置为单机版

2.新建模块cloud-provider-hystrix-payment8001

pom.xml：

<dependencies>
    <!-- hystrix-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    <!-- 引用自己定义的api通用包，可以使用Payment支付Entity -->
    <dependency>
        <groupId>cn.zko0.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>1.0-SNAPSHOT</version>
    </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>
    <!--eureka client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!--热部署-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <scope>runtime</scope>
        <optional>true</optional>
    </dependency>
    <!--   一个Java工具包     -->
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
        <version>5.1.0</version>
    </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>

yml：

server:
  port: 8001

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

eureka:
  client:
    register-with-eureka: true
    fetch-registry: true
    service-url:
      #单机版
      defaultZone: http://eureka7001.com:7001/eureka
      #集群版
#      defaultZone: http://eureka7001.com:7001/eureka,http://eureka7002.com:7002/eureka,http://eureka7003.com:7003/eureka

启动类：

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

Service：

@Service
public class PaymentService {

    //正常访问
    public String paymentInfo_OK(Integer id){
        return "线程池"+Thread.currentThread().getName()+"paymentInfo_OK,id:"+id+"\t";
    }

    public String paymentInfo_ERROR(Integer id){
        try{
            TimeUnit.SECONDS.sleep(3);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        return "线程池"+Thread.currentThread().getName()+"paymentInfo_ERROR,id:"+id+"\t"+"耗时三秒";
    }

}

Controller：

@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;

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

    @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_ERROR(id);
        log.info("******result：" + result);
        return result;
    }

}

测试：

②模拟

一.provider自测

1.首先使用jmeter去设置并发请求，请求timeout的接口

这时去请求OK接口，OK接口的请求会被拖慢

Tomcat默认的线程数是10个，当Tomcat的默认工作线程被打满，就没有多余的线程来分担压力和处理了。

大规模的资源被timeout接口占用了，所以ok接口会变慢

上述都是Provider8001自测，如果使用consuemr80来访问，那么consumer只能等待，最终会导致consumer不满意，最后8001被拖死

二.搭建consumer测试

1.搭建模块cloud-consumer-feign-hystrix-order80

2.pom.xml：

<dependencies>
    <!-- openfeign -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <!--   hystrix     -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
    </dependency>
    <!--eureka client-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>
    <!-- 引用自己定义的api通用包，可以使用Payment支付Entity -->
    <dependency>
        <groupId>cn.zko0.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>1.0-SNAPSHOT</version>
    </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>

3.yml：

register-with-eureka: false，未将自己注册进eureka

server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://localhost:7001/eureka
#需要加上，否则会报错
ribbon:
  ReadTimeout: 4000
  ConnectTimeout: 4000

4.启动类：

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

5.feign-service

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

6.controller

@Slf4j
@RestController
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;
    }
}

7.这时去用jmeter对8001的timeout接口进行并发压测，访问80的consumer的ok接口

现象1：consumer的ok接口访问变慢

现象2：consumer的ok接口超时报错（ribbon设置为4s超时）

（这里我是400线程，200循环压测）

4、问题与解决方式

超时导致服务器变慢： 超时不再等待

出错： 出错有兜底

解决：

• provider超时，consumer不能一直等待，必须有服务降级
• provider宕机，consumer不能一直等待，必须服务降级
• provider正常，consumer自己故障或者有自我要求（自己的等待时间小于provider）当provider用时4s，consumer等待3s，consumer自己处理降级

5、服务降级

①Provider

1.修改8001中PaymentService的paymentInfo_TimeOut方法，并添加paymentInfo_TimeOutHandler方法

Provider出错或是超过了调用时间峰值（3秒），就会使用fallbackMethod

public class PaymentService {

    //正常访问
    public String paymentInfo_OK(Integer id){
        return "线程池"+Thread.currentThread().getName()+"paymentInfo_OK,id:"+id+"\t";
    }

    @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = {
            //设置自身超时调用时间的峰值为3秒，峰值内可以正常运行，超过了需要有兜底的方法处理，服务降级fallback
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
    })
    public String paymentInfo_TimeOut(Integer id){
        int timeNumber = 5;
        //int i = 1 / 0;
        try {
            TimeUnit.SECONDS.sleep(timeNumber);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() +
                "\tpaymentInfo_TimeOut，id：" + id + "，耗时：" + timeNumber + "秒";
    }
    public String paymentInfo_TimeOutHandler(Integer id){
        return "8001提供者，线程池：" + Thread.currentThread().getName() +
                "\tpaymentInfo_TimeOutHandler系统繁忙，请稍后再试，id：" + id;
    }
}

2.然后在8001的主启动类上添加@EnableCircuitBreaker注解，启用断路器。

3.测试：

调用8001的timeout接口，因为服务降级的峰值时间为3s，超过3s会调用fallbackMethod，而timeout接口中sleep5s，故产生了服务降级

将sleep改为int i=1/0同样能够启用服务降级，对于接口方法中出错抛出的异常，都会调用fallbackMethod产生降级

②Consumer

1.在yml中配置Ribbon保证自定义降级时间小于Ribbon最大等待时间：

2.在主启动类添加@EnableHystrix注解

3.对controller的方法添加服务降级方法

修改OrderHystrixController的paymentInfo_TimeOut方法，并添加paymentTimeOutFallbackMethod方法：

@Slf4j
@RestController
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;
    }

    @HystrixCommand(fallbackMethod = "paymentTimeOutFallbackMethod", commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1500")
    })
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    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，支付系统繁忙";
    }

}

4.测试：

情况1：consumer最大调用时间不满足或错误

consumer等待1.5s即降级。provider的接口sleep5s，3s降级。此时会调用consumer的降级方法；

③Provider和Consumer服务降级

Provider和Consumer都可以使用服务降级，但是在日常的开发中，通常将服务降级放在Consumer中；

6、全局服务降级

如果对每个方法配置fallbackMethod，代码膨胀和耦合度很高，烂！

配置全局通用服务降级fallbcakMethod，对于特定配置的即使用特定配置fallbackMethod

全局服务降级能够代替全局异常处理，并且还能够解决高并发的一些问题

①Consumer配置

1.在80的OrderHystrixController中添加全局fallback方法：

@Slf4j
@RestController
@DefaultProperties(defaultFallback = "payment_Global_FallbackMethod")
public class OrderHystrixController {

    @Resource
    private PaymentHystrixService paymentHystrixService;

    //全局fallback方法，不能有传参
    public String payment_Global_FallbackMethod(){
        return "Global异常处理信息，请稍后再试！";
    }

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

    @HystrixCommand(commandProperties = {
            @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
    })
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_TimeOut(@PathVariable("id") Integer id){
        String result = paymentHystrixService.paymentInfo_TimeOut(id);
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        return result;
    }
}

全局服务降级和定制服务降级的区别：

定制服务降级：在@HystrixCommand注解中包含fallback=xxx,这时即为特定fallbackMethod

全局服务降级：没有标注fallbackMethod，这时调用全局服务降级方法(后面的Property可以不写)

标注方法需要服务降级（在上面的代码中已经完整写出

测试：

7、通配服务降级FeignFallBack

之前我们是在Consumer的controller层上对每个方法进行服务降级配置的，这样做会导致代码很混乱。

如下，纯纯的一坨屎：

服务降级的fallbackMethod和业务代码混在一起，垃圾！！

如果我们在feign-servce层，对每个接口配置服务降级方法，不就变得很清晰了吗？好！

①Consumer配置

1.首先去yml进行配置，开启feign的hystrix

注意在开启feign的hystrix时，默认的超时时间为1s，如果这时在controller层上定制服务降级方法，会出现1s的超时，不以自定义的服务降级配置时间为准的问题，需要我们手动调整connection-timeout大于自定义降级最大时间

feign:
  hystrix:
    enabled: true
  #下面两行不要，但是需要注意
  #httpclient:
  #  connection-timeout: 5000

2.在80的service包下新建PaymentFallbackService类，实现PaymentHystrixService接口

@Component
public class PaymentFallbackService implements PaymentHystrixService{
    @Override
    public String paymentInfo_OK(Integer id) {
        return "----PaymentFallbackService\t fallback-paymentInfo_OK----";
    }

    @Override
    public String paymentInfo_TimeOut(Integer id) {
        return "----PaymentFallbackService\t fallback-paymentInfo_TimeOut----";
    }
}

3.在feign-server上的@FeignClient加上fallback指定类，这样Feign远程调用接口就能够服务降级，调用对应的重写方法

4.关闭Consumer中Controller层上的全局服务降级，同时关闭Provider上的服务降级，使我们的Feign通配的服务降级能够更好展现出来。

如下，consumer调用provider正常，没有产生服务降级。

5.关闭provider服务器，模拟宕机，这时应该产生服务降级，测试：

feign-servie服务降级方法成功调用

8、服务熔断

①概念

熔断时应对雪崩的一种微服务链路保护机制，当扇出链路的某个微服务出错不可用或者响应的时间太长了，那么就会进行服务的降级，从而熔断该节点微服务的调用，返回错误的响应信息。

当节点微服务调用响应正常之后，会尝试恢复调用链路

在SpringCloud中，熔断机制通过Hystrix实现，Hystrix会监控服务直接的调用情况。当失败的调用达到一定的阈值，缺省时5s内20次调用失败，就会启动熔断机制，熔断机制的注解时@HystrixCommand

服务熔断博客：[CircuitBreaker](CircuitBreaker (martinfowler.com))

Closed：断路器关闭

Open：断路器启动

HalfOpen（半开）：在断路器打开的状态下，先尝试请求是否能够正常响应，如果该请求正常，则关闭断路器

②Provider自测搭建

1.修改cloud-provider-hystrix-payment8001

在Service中添加方法与熔断

@HystrixProperty(name = "circuitBreaker.enabled", value = "true")开启服务熔断

circuitBreaker.requestVolumeThreshold：滑动窗口大小，即触发熔断的最小请求数量，默认为 20。举个例子，一共只有 19 个请求落在窗口内，全都失败了，也不会触发熔断

//服务熔断
@HystrixCommand(fallbackMethod = "paymentCircuitBreaker_fallback",commandProperties = {
        @HystrixProperty(name = "circuitBreaker.enabled", value = "true"),                      //开启断路器
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "10"),         //请求总数阈值（默认20）
        @HystrixProperty(name = "circuitBreaker.sleepWindowInMilliseconds", value = "10000"),   //休眠时间窗口期（休眠多久进入半开模式（单位毫秒，默认5秒））
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "60"),       //请求次数的错误率达到多少跳闸（百分率%，默认50%）
})
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;
}

2.在Controller层调用service层中开启服务熔断的方法

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

3.测试：

第一次调用，服务未熔断：

多次输入-1，使得服务熔断产生，断路器打开，这时输入正确的数据，依然会使用fallbackMethod来工作

circuitBreaker.sleepWindowInMilliseconds秒之后，（本配置设置为10s），10s后断路器处于半开状态，如果这时，请求服务正常调用（>0），断路器就会关闭，否则断路器依然会打开，再次产生熔断

③总结

断路器的三个重要参数：

1. 快照时间窗：

   断路器曲儿是否打开需要统计一些请求和错误数据，而统计的时间泛微就是快照时间窗，默认为最近的10s

2. 请求总数阈值

   在快照时间窗内，必须满足请求总数阈值才有可能熔断，默认为20

   （默认在10s内，如果该接口调用不足20次，那么即使全部失败，断路器也不会打开）

3. 错误百分比阈值

   请求总数在快照时间窗内超过阈值，比如发生了30次调用，如果在30次调用内，有15次发生了超时异常，也就是超过50%的错误百分比，那么断路器就会被打开

Hystrix流程图：

由图可见可见，服务降级有三种情况：

1. 断路器打开（服务熔断）
2. 信号量或者线程池满了
3. 方法运行异常或超时

9、Dashboard仪表板

Dashboard：对Hystrix进行图形化的监控

Hystrix提供准实时的调用监控，Hystrix会以统计报表和图形的形式展现给用户，包括每秒多少请求，多少成功，多少失败等。

①Dashboard工程搭建

1.新建子模块cloud-consumer-hystrix-dashboard9001

<dependencies>
    <!--   hystrix仪表盘图形化     -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
    </dependency>
    <dependency>
        <groupId>cn.zko0.cloud</groupId>
        <artifactId>cloud-api-commons</artifactId>
        <version>1.0-SNAPSHOT</version>
    </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>

2.yml：

server:
  port: 9001

3.启动类：

@EnableHystrixDashboard //启用Hystrix仪表板
@SpringBootApplication
public class HystrixDashboard9001 {
    public static void main(String[] args) {
        SpringApplication.run(HystrixDashboard9001.class, args);
    }
}

4.启动：成功

②Provider接入Dashboard

所有微服务提供者都需要在pom中引入监控依赖。

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

在启动类上添加：

/**
 * 此配置是为了服务监控而配置，与服务容错本身无关，springcloud升级后的坑
 * ServletRegistrationBean因为SpringBoot的默认路径不是 “/hystrix.stream"
 * 只要在自己的项目里配置上下的servlet就可以了
 */
@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;
}

启动7001，8001，9001：

配置Dashboard的监控地址：

如果显示Loading，需要先调用一次监控项目的接口，才能显示

疯狂调用8001接口，观察Dashboard：

多次调用接口，使其错误，开启服务熔断：

可以看到paymentCircuitBreaker的断路器打开了

③怎么看Dashborad

六种颜色，代表对应服务上调用不同状态的次数

一个圈圈：

颜色：健康程度：绿色>黄色>橙色> 红色

大小：流量越大实心圈越大

总体含义图：