六、Hystrix服务降级与熔断

青旅半醒 2023-01-10 13:21 159阅读 0赞

> 卑微程序员：各位客官，走过看过，不求三联，只需点赞

--------------------

**SpringCloud系列目录：**

*  [一、SpringCloud简介][SpringCloud]
 *  [二、Eureka服务注册与发现][Eureka]
 *  [三、Eureka注册与发现之Eureka Comsumer][Eureka_Eureka Comsumer]
 *  [四、Eureka、Server Provider集群配置][Eureka_Server Provider]
 *  [五、Ribbon和OpenFeign][Ribbon_OpenFeign]
 *  [六、Hystrix服务降级与熔断][Ribbon_OpenFeign]

--------------------

##### 一、前言 #####

当今环境下分布式已是当今系统架构的发展方向，但分布式同样面临着许多的问题。本文将从分布式系统面临的问题、解决方案、能解决哪些问题，并结合代码去演示。文章中的代码都已提交到Github，如需自取。

##### 二、分布式系统面临的问题 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70]  
**服务雪崩**:

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

**解决方案（Hystrix）**

> 当依赖的服务发生故障时，对该服务做**降级或者是熔断**处理，降低对整个应用的影响  
> 官网地址：[https://github.com/Netflix/Hystrix/wiki/How-To-Use][https_github.com_Netflix_Hystrix_wiki_How-To-Use]  
> 目前Hystrix已不再更新，进入维护阶段。当然以后很多优秀的可用的方案，比如Sentinel。受限于篇幅，此文只涉及服务降级与熔断

###### 2.1 能干什么 ######

1）服务降级

> 服务器忙，请稍后再试，不让客户端等待并立刻返回一个友好的提示  
> 降级触发：程序运行异常、调用超时、服务熔断触发降级、线程池/信号量打满

2）服务熔断

> 达到设定的最大的服务访问，直接拒绝访问，然后**调用服务降级**方法并返回友好提示  
> 熔断过程：服务降级->熔断->恢复调用链路

3）服务限流

> 秒杀等高并发操作，设定并发量

##### 2.1 服务降级 #####

###### 2.1.1 项目搭建与测试 ######

> **注**：项目可以单独建立，不适用Eureka，如果需要使用请参考之前的几篇文章，项目中所有的代码均已提交到github

**项目搭建，结构如下：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 1]

1）新建cloud-provider-hystrix-payment8001  
2）添加pom依赖

<dependencies>
            
            <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>com.atguigu.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>
    
            <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

server:
      port: 8001
    
    eureka:
      client:
        register-with-eureka: true    #表识不向注册中心注册自己
        fetch-registry: true   #表示自己就是注册中心，职责是维护服务实例，并不需要去检索服务
        service-url:
          #设置与eureka server交互的地址查询服务和注册服务都需要依赖这个地址(此处我有修改hosts配置文件)
          defaultZone: http://eureka7001.com:7001/eureka/,http://eureka7002.com:7002/eureka/
    
    spring:
      application:
        name: cloud-provider-hystrix-payment

4）主启动类

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

5）业务代码

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

**测试两个接口**  
先启动两个Eureka服务，然后再启动8001服务，这里我们分别测试两个接口。

![在这里插入图片描述][2021012422430285.png]  
![在这里插入图片描述][20210124224336467.png]  
代码很简单，服务也是可以跑通的。如果在高并发的情况下上述的服务又会如何呢？接下来我们使用Jmater来简单的压测一下，当然在实际的项目中仅仅使用Jmater是远远不够的，此处仅供测试使用

**使用压测timeout接口**

1）新建一个线程组  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 2]  
2）在线程组下新建一个http请求  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 3]  
3）设置协议、服务器名称、端口号、路径  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 4]  
4）ctrl+s保存之后执行  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 5]

5）访问没有休眠的方法发现该方法有了延时  
http://localhost:8001/payment/get/info/ok/3  
![在这里插入图片描述][2021012422490874.png]

> 以上是对服务提供者进行压测，如果有客户端调用8001服务，那结果同样是等待

**故障现象和原因**

> 8001同一层次的其他接口服务迪被调用过多，导致tomcat线程中的线程全部被占用，如果再调用8001服务中的其他接口，就需要等待线程被释放。

###### 2.1.2 解决方式 ######

*  超时导致服务器变慢：超时不再等待
 *  出错（宕机或程序运行出错）出错有兜底

> 通过设置自身调用超时时间峰值，峰值内可以正常运行，超过了需要有兜底的方法处理，作为降级的fallback

1）业务类启用@HystrixCommand

> 一旦调用服务方法失败并抛出了错误信息后，会自动调用@HystrixCommand标注好的fallbackMethod调用类中的指定方法。当方法paymentInfo\_Timeout()执行时间超过设定好的之间自动执行降级方法paymentInfo\_TimeOutHandler()，当然此处也可以写自己的降级逻辑

@Service
    public class PaymentServiceImpl implements IPaymentService { 
    
        @Override
        public String paymentInfo_Ok(Integer id) { 
            return "线程池" + Thread.currentThread().getName() + " paymentInfo_Ok id" + id;
        }
    
        @HystrixCommand(fallbackMethod = "paymentInfo_TimeOutHandler", commandProperties = { 
                @HystrixProperty(name = "execution.isolation.thread.timeoutinMilliseconds", value = "3000")
        })
        public String paymentInfo_Timeout(Integer id) { 
            try { 
                TimeUnit.SECONDS.sleep(4);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            return "线程池" + Thread.currentThread().getName() + " id" + id;
        }
    
        public String paymentInfo_TimeOutHandler(Integer id) { 
            return "线程池" + Thread.currentThread().getName() + " paymentInfo_TimeOutHandler方法超时" + id;
        }

2）主启动类激活

> 添加新注解@EnableCircuitBreaker

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

注：服务端与客户端的降级使用注解以及配置略有差别，当然原理是相同的  
  
3）降级测试

> 接下来我们直接调用timeout方法来进行测试

##### 2.2 服务熔断 #####

--------------------

*  [上一篇 【五、Ribbon和OpenFeign】][Ribbon_OpenFeign]

[SpringCloud]: https://blog.csdn.net/gwz_6903/article/details/110672126
[Eureka]: https://blog.csdn.net/gwz_6903/article/details/110674130
[Eureka_Eureka Comsumer]: https://blog.csdn.net/gwz_6903/article/details/110729300
[Eureka_Server Provider]: https://blog.csdn.net/gwz_6903/article/details/110900700
[Ribbon_OpenFeign]: https://blog.csdn.net/gwz_6903/article/details/111462923
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70]: /images/20221119/90490acf0bd7445590591258754cebc8.png
[https_github.com_Netflix_Hystrix_wiki_How-To-Use]: https://github.com/Netflix/Hystrix/wiki/How-To-Use
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 1]: /images/20221119/a584b929c0594796b4317c213f7de907.png
[2021012422430285.png]: /images/20221119/06a93e0a37ad47d19df8388d4f380162.png
[20210124224336467.png]: /images/20221119/15e8d00974374e28b45fdf8cec6ae75a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 2]: /images/20221119/6dab449744b64c8b839ca17353b64918.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 3]: /images/20221119/d92c77ca63ac4efe8251ecfa925bd484.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 4]: /images/20221119/5f79cc5d687d4c7e96cd5078c7008f82.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 5]: /images/20221119/ea0dd10a557c40008dc2a76a7fec2785.png
[2021012422490874.png]: /images/20221119/3c1fcb2e54324e0eac0312d2789c4dcb.png