🍻 正在加载今日诗词....

SpringCloud Alibaba入门到精通（八）- 服务熔断Hystrix（已过时）

阅读数： 次
原创 字数统计: 5.5k字   |   预计阅读时长≈ 24分钟

此文章主要讲解 springcloud 中服务熔断 Hystrix（豪猪哥）的相关知识。

服务容错的核心知识

雪崩效应

  • 在微服务架构中，一个请求需要调用多个服务是非常常见的。如客户端访问 A 服务，而 A 服务需要调用 B 服务，B 服务需要调用 C 服务，由于网络原因或者自身的原因，如果 B 服务或 C 服务不能及时响应，A 服务将处于阻塞状态，直到 B 服务 C 服务响应。此时如果有大量的请求涌入，容器的线程资源会被消耗完毕，导致服务瘫痪。服务和服务之间的依赖性，故障会传播，造成连锁反应，会对整个微服务系统造成灾难性的严重后果，这就是服务故障的“雪崩”效应。

雪崩效应.jpg

  • 雪崩是系统中的蝴蝶效应，导致其发生的原因多种多样，有不合理的容量设计，或者是高并发下某一个方法响应变慢，亦或是某台机器的资源耗尽。从源头上我们无法完全杜绝雪崩源头的发生，但是雪崩的根本原因来源于服务之间的强依赖，所以我们可以提前评估，做好熔断、隔离、限流。

服务隔离

  • 顾名思义，它是指系统按照一定的原则划分若干个服务模块，各个模块之间相互独立，无强依赖性。当有故障发生时，能将问题和影响隔离在某个模块内部，而不扩散风险，不涉及到其他模块，不影响整体的系统服务。

熔断降级

  • 熔断，这一概念来源于电子工程中的断路器（Circuit Breaker）。在互联网系统中，当下游服务因为当问压力过大而响应变慢或失败，上游服务为了保护系统整体的可用性，可以暂时切断对下游服务的调用。这种牺牲局部，保全整体的措施就叫熔断。

熔断降级.jpg

  • 所谓降级，就是当某个服务熔断之后，服务将不再被调用，此时客户端可以自己准备一个本地的 fallback 回调，返回一个缺省值。也可以理解为兜底。

服务限流

  • 限流可以认为是服务降级的一种，限流就是限制系统的输入和输出流量来达到保护系统的目的。一般来说，系统的吞吐量是可以被测算的，为了保证系统的稳固运行，一旦到达需要限制的阈值，就需要限制流量并采取少量措施以完成限制流量的目的。比如：推迟解决、拒绝解决或者是部分拒绝解决等等。

Hystrix

介绍

  • Hystrix 是由 Netflix 公司开源的一个延迟和容错库，用于隔离访问远程系统、服务或第三方库，防止级联失败，从而提升系统的可用性和容错性。Hystrix 主要通过以下的几点实现延迟和容错：

  • 包裹请求：使用 HystrixCommand 包裹对依赖的调用逻辑，每个命令在独立线程中执行。使用了设计模式中的命令模式。

  • 跳闸机制：当某服务的错误率超过一定的阈值时，Hystrix 可以自动或者手动跳闸，停止请求该服务一段时间。

  • 资源隔离：Hystrix 为每个依赖度维护了一个小型的线程池（或者信号量）。如果该线程池已满，发往该依赖的请求就被立即拒绝，而不是排队等待，从而加速失败判定。

  • 监控：Hystrix 可以近乎实时的监控运行指标和配置的变化，例如成功、失败、超时、被拒绝的请求等等。

  • 回退机制：当请求失败、超时、被拒绝、或当断路器打开时，执行回退逻辑。回退逻辑由开发人员自行提供，例如返回一个缺省值。

  • 自我修复：断路器打开一段时间后，会自动进入“半开”状态。

概述

Github 官方地址： https://github.com/Netflix/Hystrix/wiki/How-To-Use ，可以看出已经停止更新进入维护状态了。

1597468299249

1597468336180

重要概念

服务降级

服务器忙碌或者网络拥堵时，不让客户端等待并立刻返回一个友好提示，fallback

哪些情况会触发服务降级：

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

服务熔断

break

1597552633205

服务限流

flowlimit

1597468986791

可见，上面的技术不论是消费者还是提供者，根据真实环境都是可以加入配置的，一般用在消费端。

案例

首先构建一个 eureka 作为服务中心的单机版微服务架构 ，这里使用之前 cloud-eureka-server7001 模块，作为服务中心

提供者模块

新建模块

cloud-provider-hystrix-payment8001

POM 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
<?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">
    <parent>
        <artifactId>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

    <dependencies>

        <!-- 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通用包-->
        <dependency>
            <groupId>com.itjing.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</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>
        <!--mybatis整合spring依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <!--lombok-->
        <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>

YML 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 端口号
server:
  port: 8001
spring:
  application:
    name: cloud-provider-hystrix-payment
  # 数据源
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/springcloud2020?useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: root
    password: root

# mybatis 相关
mybatis:
  mapper-locations: classpath:mapper/*.xml
  type-aliases-package: com.itjing.springcloud.entities # 所有Entity 别名类所在包

eureka:
  client:
    # 注册进 Eureka 的服务中心
    register-with-eureka: true
    # 是否从eureka抓取已有的注册信息，默认为true。单节点无所谓，集群必须设置为true才能配合ribbon使用负载均衡
    fetch-registry: true
    service-url:
      # 设置与 Eureka Server 交互的地址
      defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/

主启动类

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

Service

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.itjing.springcloud.service;

import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {
    /**
     * 可以正常访问的方法
     *
     * @param id
     * @return
     */
    public String paymentinfo_Ok(Integer id) {
        return "线程池：" + Thread.currentThread().getName() + "--paymentInfo_OK，id:" + id;
    }

    /**
     * 超时访问的方法
     */
    public String paymentinfo_Timeout(Integer id) {
        int interTime = 3;
        try {
            TimeUnit.SECONDS.sleep(interTime);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return "线程池：" + Thread.currentThread().getName() + "--paymentInfo_Timeout，id:" + id + " 耗时" + interTime + "秒钟--";
    }
}

Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@RestController
@Slf4j
public class PaymentController {
    @Resource
    private PaymentService paymentService;

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

    @GetMapping("/payment/hystrix/{id}")
    public String paymentInfo_OK(@PathVariable("id") Integer id) {
        log.info("paymentInfo_OK");
        return paymentService.paymentinfo_Ok(id);
    }

    @GetMapping("/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
        log.info("paymentInfo_timeout");
        return paymentService.paymentinfo_Timeout(id);
    }
}

启动测试

  1. 启动 注册中心 Eureka
  2. 启动服务提供者 cloud-provider-hystrix-payment8001
  3. 访问测试

http://localhost:8001/payment/hystrix/1

image-20210118104931401

http://localhost:8001/payment/hystrix/timeout/1

image-20210118105125418

模拟高并发

这里使用 JMeter 压力测试器

下载压缩包，解压，双击 /bin/ 下的 jmeter.bat 即可启动

1597471683432

1597471750363

ctrl + S 保存。

1597472029967

从测试可以看出，当模拟的超长请求被高并发以后，访问普通的小请求速率也会被拉低。

消费者模块

新建模块

cloud-consumer-feign-hystrix-order80，以 feign 为服务调用，eureka 为注册中心

POM 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
<?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">
    <parent>
        <artifactId>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

    <dependencies>
        <!-- hystrix -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
        </dependency>
        <!-- Open Feign -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <!-- eureka Client -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>

        <!-- 引入自己定义的api通用包-->
        <dependency>
            <groupId>com.itjing.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</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>
        <!--lombok-->
        <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>

YML 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

# 设置feign客户端超时时间（OpenFeign默认支持ribbon）
ribbon:
  # 指的是建立连接后从服务器读取到可用资源所用的时间
  ReadTimeout: 5000
  # 指的是建立连接所用的时间，适用于网络状况正常的情况下，两端连接所用的时间
  ConnectTimeout: 5000

主启动类

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

Service 接口

1
2
3
4
5
6
7
8
9
10
11
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT")  //服务名称，要和eureka上面的一致才行
public interface PaymentHystrixService {

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


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

Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RestController
@Slf4j
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

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


    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
        return paymentHystrixService.paymentInfo_Timeout(id);
    }
}

测试

测试可见，当启动高并发测试时，消费者访问也会变得很慢，甚至出现超时报错。

结论

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

如何解决

超时导致服务器变慢（转圈）——–> 超时不再等待

出错（宕机或程序运行出错）——–> 出错要有兜底

解决思路：

对方服务(8001)超时了，调用者(80)不能一直卡死等待，必须有服务降级。

对方服务(8001)down 机了，调用者(80)不能一直卡死等待，必须有服务降级。

对方服务(8001)OK，调用者(80)自己出故障或有自我要求（自己的等待时间小于服务提供者），自己处理降级。

服务降级

一般服务降级放在客户端，即消费者端 ，但是提供者端一样能使用。

首先提供者，即 8001 先从自身找问题，设置自身调用超时的峰值，峰值内正常运行，超出峰值需要有兜底的方法处理，作服务降级fallback。

8001 服务降级

首先 对 8001 的 service 进行配置（对容易超时的方法进行配置) ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
 * 超时访问的方法
 */
@HystrixCommand(fallbackMethod = "paymentInfo_timeoutHandler", commandProperties = {
        // 设置峰值，超过 3 秒，就会调用兜底方法，这个时间也可以由feign控制
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
})
public String paymentinfo_Timeout(Integer id) {
    int interTime = 3;
    try {
        TimeUnit.SECONDS.sleep(interTime);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return "线程池：" + Thread.currentThread().getName() + "--paymentInfo_Timeout，id:" + id + " 耗时" + interTime + "秒钟";
}

// 兜底方法，根据上述配置，程序内发生异常、或者运行超时，都会执行该兜底方法
public String paymentInfo_timeoutHandler() {
    return "系统繁忙或者运行报错，请稍后再试，当前线程名字" + Thread.currentThread().getName();
}

主启动类添加注解： @EnableCircuitBreaker

80 服务降级

YML 文件

1
2
3
4
5
6
7
8
9
10
11
12
13
server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

# 用于服务降级
feign:
  hystrix:
    enabled: true # 在feign中开启 hystrix

主启动类添加注解： @EnableHystrix

然后对 80 进行服务降级：很明显 service 层是接口，所以我们对消费者，在它的 controller 层进行降级

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@HystrixCommand(fallbackMethod = "paymentInfo_timeoutHandler", commandProperties = {
        //设置峰值，超过 3 秒，就会调用兜底方法
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000")
})
@GetMapping("/consumer/payment/hystrix/timeout/{id}")
public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
    return paymentHystrixService.paymentInfo_Timeout(id);
}

//兜底方法，注意，兜底方法参数随意
public String paymentInfo_timeoutHandler() {
    log.info("paymentInfo_timeout--handler");
    return "对方支付系统繁忙请10秒钟后再试或者自己运行出错，请检查自己！";
}

测试

记录下遇到的坑

controller 中超时时间配置不生效原因：

1
2
3
4
5
#关键在于
feign:
  hystrix:
	enabled: true
# 的作用，官网解释“Feign将使用断路器包装所有方法”，也就是将@FeignClient标记的那个service接口下所有的方法进行了hystrix包装（类似于在这些方法上加了一个@HystrixCommand），这些方法会应用一个默认的超时时间为1s，所以你的service方法也有一个1s的超时时间，service 1s就会报异常，controller立马进入备用方法，controller上那个3秒那超时时间就没有效果了。

Hystrix 的默认超时时间为 1 秒，我们可以通过如下的配置修改默认的超时设置：

1
2
3
4
5
6
7
hystrix:
  command:
    default:
      execution:
        isolation:
          thread:
            timeoutInMilliseconds: 3000

然后 ribbon 的超时时间也需加上超时控制：

1
2
3
ribbon:
  ReadTimeout: 5000
  ConnectTimeout: 5000

注意，消费者降级设置的超时时间和提供者的没有任何关系，就算提供者峰值是 5 秒，而消费者峰值是 3 秒，那么消费者依然报错。就是每个模块在服务降级上，都是独立的。

全局服务降级

上面的降级策略，很明显造成了代码的杂乱，提升了耦合度，而且按照这样，每个方法都需要配置一个兜底方法，很繁琐。

现在将降级处理方法（兜底方法）做一个全局的配置，设置共有的兜底方法和独享的兜底方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@RestController
@Slf4j
//全局配置降级方法的注解
@DefaultProperties(defaultFallback = "paymentInfo_timeoutHandler")
public class OrderHystrixController {
    @Resource
    private PaymentHystrixService paymentHystrixService;

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

    @HystrixCommand
    @GetMapping("/consumer/payment/hystrix/timeout/{id}")
    public String paymentInfo_Timeout(@PathVariable("id") Integer id) {
        return paymentHystrixService.paymentInfo_Timeout(id);
    }

    //兜底方法，注意，兜底方法参数随意
    public String paymentInfo_timeoutHandler() {
        log.info("paymentInfo_timeout--handler");
        return "Global异常处理信息，请稍后再试！";
    }
}

问题，跟业务逻辑混合，解决（解耦）：

在这种方式一般是在客户端，即消费者端，首先上面在 controller 中添加的 @HystrixCommand 和 @DefaultProperties 两个注解去掉，就是保持原来的 Controller

1、YML文件配置

1
2
3
4
5
6
7
8
9
10
11
12
13
server:
  port: 80

eureka:
  client:
    register-with-eureka: false
    service-url:
      defaultZone: http://eureka7001.com:7001/eureka/

# 用于服务降级 在注解@FeignClient 中添加 fallback 属性值
feign:
  hystrix:
    enabled: true # 在feign中开启 hystrix

2、编写一个类实现Service接口

1
2
3
4
5
6
7
8
9
10
11
12
@Component
public class OrderFallbackService implements PaymentHystrixService {//注意这里，它实现了service接口
    @Override
    public String paymentInfo_OK(Integer id) {
        return "OrderFallbackService --发生异常";
    }

    @Override
    public String paymentInfo_Timeout(Integer id) {
        return "OrderFallbackService --发生异常--paymentInfo_Timeout";
    }
}

3、修改service接口

1
2
3
4
5
6
7
8
9
10
11
@Component
@FeignClient(value = "CLOUD-PROVIDER-HYSTRIX-PAYMENT", fallback = OrderFallbackService.class) // 这里是重点
public interface PaymentHystrixService {

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


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

新问题，这样配置如何设置超时时间？

首先要知道 下面两个 yml 配置项：

1
2
3
4
5
6
7
hystrix.command.default.execution.timeout.enable=true    ## 默认值

## 为false则超时控制由ribbon控制，为true则hystrix超时和ribbon超时都是用，但是谁小谁生效，默认为true

hystrix.command.default.execution.isolation.thread.timeoutInMilliseconds=1000  ## 默认值

## 熔断器的超时时长默认1秒，最常修改的参数

看懂以后，所以只需要在 yml 配置里面配置 Ribbon 的 超时时长即可。

注意：hystrix 默认自带 ribbon 包。

1
2
3
ribbon:
	ReadTimeout: xxxx
	ConnectTimeout: xxx

服务熔断

实际上 服务熔断 和 服务降级 没有任何关系，就像 java 和 javaScript

服务熔断，就像家里的保险丝一样

概述

1597552755235

实操

修改 cloud-provider-hystrix-payment8001

service 层的方法设置服务熔断

双击 shift 搜索 HystrixCommandProperties，查看相关属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//=====服务熔断
@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"),  // 失败率达到多少后跳闸
        //整体意思：10秒内 10次请求，有6次失败，就跳闸
})
public String paymentCircuitBreaker(Integer id) {
    //模拟发生异常
    if (id < 0) {
        throw new RuntimeException("*****id，不能为负数");
    }
    String serialNumber = IdUtil.simpleUUID();
    return Thread.currentThread().getName() + "\t" + "调用成功，流水号：" + serialNumber;
}

public String paymentCircuitBreaker_fallback(Integer id) {
    return "id 不能为负数，请稍后再试....";
}
controller
1
2
3
4
5
//====服务熔断
@GetMapping("/payment/circuit/{id}")
public String paymentCircuitBreaker(@PathVariable("id")Integer id){
    return paymentService.paymentCircuitBreaker(id);
}
测试

自测：http://localhost:8001/payment/circuit/1

成功：

image-20210118142752748

失败：

image-20210118142809791

多次错误，然后慢慢正确，发现刚开始不满足条件，就算是正确的访问地址也不能进行正确输出，过一会才恢复正常，慢慢恢复调用链路。

image-20210118143414061

1597555381295

关于解耦以后的全局配置说明：

例如上面提到的全局服务降级，并且是 feign+hystrix 整合，即 service 实现类的方式，如何做全局配置？

1
2
3
4
5
6
7
8
hystrix:
  command:
    default:
      circuitBreaker:
        enabled: true
        requestVolumeThreshold: 10
        sleepWindowInMilliseconds: 10000
        errorThresholdPercentage: 60

服务限流

后面学习 Sentinel 的时候再说。

服务监控

Hystrix DashBoard 仪表盘

概述

1597556913055

Hystrix 官方提供了基于图形化的 DashBoard（仪表盘）监控平台，用来直观的展示系统的运行状态。Hystrix 仪表盘可以显示每个断路器的状态。

搭建

新建模块

cloud-consumer-hystrix-dashboard9001

POM 文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
<?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">
    <parent>
        <artifactId>spring_cloud_atguigu_2020</artifactId>
        <groupId>com.itjing.springcloud</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

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

    <dependencies>
        <!-- hystrix Dashboard-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-hystrix-dashboard</artifactId>
        </dependency>

        <!-- 引入自己定义的api通用包-->
        <dependency>
            <groupId>com.itjing.springcloud</groupId>
            <artifactId>cloud-api-commons</artifactId>
            <version>${project.version}</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>
        <!--lombok-->
        <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>
YML 文件
1
2
server:
  port: 9001
主启动类

加注解： @EnableHystrixDashboard

1
2
3
4
5
6
7
@SpringBootApplication
@EnableHystrixDashboard
public class HystrixDashboardMain9001 {
    public static void main(String[] args) {
        SpringApplication.run(HystrixDashboardMain9001.class, args);
    }
}
服务提供者的依赖说明

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

1
2
3
4
5
<!--监控信息完善-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
测试

启动 9001 ，访问： http://localhost:9001/hystrix

image-20210118150402899

监控实战

下面使用上面 9001 Hystrix Dashboard 项目，来监控 8001 项目 Hystrix 的实时情况：

1597557620438

修改服务提供者

在服务提供者 cloud-provider-hystrix-payment8001 主启动类中加入以下内容：

1
2
3
4
5
6
7
8
9
@Bean
public ServletRegistrationBean getServlet(){
    HystrixMetricsStreamServlet streamServlet = new HystrixMetricsStreamServlet();
    ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(streamServlet);
    servletRegistrationBean.setLoadOnStartup(1);
    servletRegistrationBean.addUrlMappings("/hystrix.stream");
    servletRegistrationBean.setName("HystrixMetricsStreamServlet");
    return servletRegistrationBean;
}
监控测试
  1. 启动 cloud-eureka-server7001
  2. 启动 cloud-consumer-hystrix-dashboard9001
  3. 启动 cloud-provider-hystrix-payment8001

9001 监控 8001 ，输入 http://localhost:8001/hystrix.stream ，然后进去

image-20210118151346549

先访问测试 http://localhost:8001/payment/circuit/1

image-20210118151556022

然后在仪表盘可以看到：

1597558486510

#

本文作者： LiJing
发布时间： 2021-01-18
最后更新： 2024-06-24
本文标题： SpringCloud Alibaba入门到精通（八）- 服务熔断Hystrix（已过时）
本文链接： https://blog-yilia.xiaojingge.com/posts/b7119e83.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！
知识共享许可协议
赏

谢谢你请我吃糖果

支付宝
微信
本站总访问量次 | 本站访客数人

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

喜欢看书、打代码、吃吃吃！我从没被谁知道，所以也没被谁忘记。在别人的回忆中生活，并不是我的目的。我只不过是自己一个人在努力罢了。