SpringCloud - Circuit Breaker Hystrix

Introduction

Hystrix is an open source project of Netflix. It can prevent cascading failures of services and cause service avalanches by isolating system-dependent services in the event of service failure. At the same time, Hystrix also provides a failure rollback mechanism, which enables the system to recover from exceptions faster. Hystrix provides protection and control for inter-service calls.

Hystrix has the following functions:

It can provide a protection mechanism for the system when there is a high delay or the call fails to call the service through the client
In complex distributed scenarios, the service avalanche effect can be prevented
Provides fail fast (Fail Fast) and fast recovery
Provide failure rollback and graceful service degradation mechanism
Provides near real-time monitoring, alarming and operation and maintenance control

Hystrix can be used in a variety of ways in the actual application process, either through annotations or by integrating HystrixCommand and HystrixObservableCommand. This article will briefly illustrate how to use it through a case.

Environmental preparation

category	value
JDK	1.8.0_162
SOFABoot / SpringBoot	3.0.0/2.0.x.RELEASE
SpringCloud	Finchley.RC1
HERE	IDEA

Engineering background

This section will create a sofa-hystrix-client project to implement the fuse and downgrade of the service through the load balancer hystrix provided by Spring Cloud.

Create a new sofa-hystrix-client

This project continues to use the parent project in "SpringCloud-Eureka Service Registration" to build.

Right-click on the parent project of sofa-eureka-parent -> New -> Module, select the Maven project here;

artifactId：sofa-hystrix-client

Modify the pom file

Add hysterix dependencies to the pom file

<dependencies>
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-eureka-client</artifactId></dependency>    
        
        
    

    <dependency>
<groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-netflix-ribbon</artifactId></dependency>        
        
    

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

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

configuration file

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
spring:
  application:
    name: hystrix-client
server:
  port: 8787

There is no special configuration, and it still exists as an eureka-client.

startup class

Add the annotation @EnableCircuitBreaker to enable the circuit breaker on the startup class

@SpringBootApplication
@EnableCircuitBreaker
public class SofaHystrixApplication {

    @Bean
@LoadBalancedpublic RestTemplate restTemplate(){returnnew RestTemplate();    }publicstaticvoidmain(String[] args){        SpringApplication.run(SofaHystrixApplication.class, args);    }}

resource class

NormalService

中通过@HystrixCommand标准一个受保护的资源方法 getByServiceId()。getByServiceId 中通过restTemplate 来调用远程服务。@HystrixCommand注解的 fallbackMethod 属性指定当服务不可用时需要执行的 fallback 方法。

@Service
public class NormalService {
    @Autowired
    private RestTemplate restTemplate;

    @HystrixCommand(fallbackMethod = "fallBack")
    public String getByServiceId(){
        return restTemplate.getForObject("http://HELLOSOFABOOTSERVICE/hello",String.class);
    }

    private String fallBack(){
        return "Filed to get data";
    }
}

HystrixRibbonController：通过instanceService调用上面的NormalService资源类

@RestController
public class HystrixRibbonController {
    @Autowired
    public NormalService instanceService;
    @RequestMapping("/hystrix")
    public String test(){
        return instanceService.getByServiceId();
    }
}

启动&验证

先后启动sofa-eureka-server-center 、sofa-eureka-provider、sofa-hystrix-client 三个工程。浏览器中输入：

http://localhost:8787/hystrix ，结果如下：

1	Hello SOFA! Now Port is 8086 And hostname is HelloSOFABootService

关闭 sofa-eureka-provider ，刷新浏览器：

1	Filed to get data

执行了 NormalService 中的 fallback 方法了。

资源隔离

hystrix 中提供了两中隔离策略，一种是基于线程池的隔离、另外一种是基于信号量的隔离。本篇只演示案例，具体原理请参看 hystrix 原理分析相关文章。

基于线程池的隔离实现

新建一个 SofaThreadPoolHystrixCommand 类，继承 HystrixCommand。代码如下：

public class SofaThreadPoolHystrixCommand extends HystrixCommand {

    private RestTemplate restTemplate;

    public SofaThreadPoolHystrixCommand(RestTemplate restTemplate) {
        super(initailize());
        this.restTemplate = restTemplate;
    }

    public static HystrixCommand.Setter initailize(){
        // 线程池配置
        HystrixThreadPoolProperties.Setter hystrixThreadPoolProperties = 
            HystrixThreadPoolProperties.Setter()
                .withCoreSize(5)
                .withKeepAliveTimeMinutes(5)
                // 线程等待队列最大长度,默认值:-1 表示不等待直接拒绝,测试表明线程池使用直接决绝策略+ 合适大小的非回缩线程池效率最高.所以不建议修改此值。
                .withMaxQueueSize(10)
                .withQueueSizeRejectionThreshold(100);

        // 命令属性配置,这里指定隔离策略是 THREAD
        HystrixCommandProperties.Setter hystrixCommand = 
            HystrixCommandProperties.Setter() .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.THREAD)
                //意味着线程最多允许执行fallback的并发数为10,超过10 报fallback execution rejected
                .withFallbackIsolationSemaphoreMaxConcurrentRequests(10);

        HystrixCommand.Setter setter = HystrixCommand.Setter
            .withGroupKey(HystrixCommandGroupKey.Factory.asKey("SofaThreadPoolHystrixCommand"))
                .andCommandKey(HystrixCommandKey.Factory.asKey("sofaBootService"))
                .andCommandPropertiesDefaults(hystrixCommand)
                .andThreadPoolPropertiesDefaults(hystrixThreadPoolProperties)
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("sofa-hystrix-thread"));

        return setter;
    }

    /**
     * 受保护的资源
     * @return
     * @throws Exception
     */
    @Override
    protected Object run() throws Exception {
        return restTemplate.getForObject("http://HELLOSOFABOOTSERVICE/hello",String.class);
    }

    /**
     * 失败执行的保护方法
     * @return
     */
    @Override
    protected Object getFallback() {
        return "this is fail back policy";
    }
}

基于信号量隔离

新建一个 SofaSemaphoreHystrixCommand 类，继承 HystrixCommand。代码如下：

public class SofaSemaphoreHystrixCommand extends HystrixCommand {
    private RestTemplate restTemplate;
    public SofaSemaphoreHystrixCommand(RestTemplate restTemplate) {
        super(initailize());
        this.restTemplate = restTemplate;
    }
    public static HystrixCommand.Setter initailize(){
        // 命令属性配置,这里指定隔离策略是 THREAD
        HystrixCommandProperties.Setter hystrixCommand = HystrixCommandProperties.Setter()
                .withExecutionIsolationStrategy(HystrixCommandProperties.ExecutionIsolationStrategy.SEMAPHORE)
                 //至少有10个请求，熔断器才进行错误率的计算
                .withCircuitBreakerRequestVolumeThreshold(0)
                //熔断器中断请求5秒后会进入半打开状态,放部分流量过去重试
                .withCircuitBreakerSleepWindowInMilliseconds(5000)
                //错误率达到50开启熔断保护
                .withCircuitBreakerErrorThresholdPercentage(50)
                //最大并发请求量
                .withExecutionIsolationSemaphoreMaxConcurrentRequests(10)
                //意味着信号量最多允许执行fallback的并发数为10,超过10 报fallback execution rejected
                .withFallbackIsolationSemaphoreMaxConcurrentRequests(10);

        HystrixCommand.Setter setter = HystrixCommand.Setter.
                withGroupKey(HystrixCommandGroupKey.Factory.asKey("SofaSemaphoreHystrixCommand"))
                .andCommandKey(HystrixCommandKey.Factory.asKey("sofaBootService"))
                .andCommandPropertiesDefaults(hystrixCommand)
                .andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey("sofa-hystrix-thread"));

        return setter;
    }

    /**
     * 受保护的资源
     * @return
     * @throws Exception
     */
    @Override
    protected Object run() throws Exception {
        return restTemplate.getForObject("http://HELLOSOFABOOTSERVICE/hello",String.class);
    }

    /**
     * 失败执行的保护方法
     * @return
     */
    @Override
    protected Object getFallback() {
        return "this is fail back policy";
    }
}

同样使用 CountDownLatch 来模拟并发。在 HystrixRibbonController 中添加 testSemaphore 资源方法：

@RequestMapping("/testSemaphore")
    public String testSemaphore(){
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < THREAD_NUM; i ++) {
            new Thread(new ConsumerSemaphore(countDownLatch)).start();
        }
        countDownLatch.countDown();
        return "data";
    }

内部定义一个内部类 ConsumerSemaphore ，模拟调用：

class ConsumerSemaphore implements Runnable {
        private final CountDownLatch startLatch;
        public ConsumerSemaphore(CountDownLatch startLatch) {
            this.startLatch = startLatch;
        }
        @Override
        public void run() {
            try {
                // 线程等待
                startLatch.await();
                // 执行操作
                SofaSemaphoreHystrixCommand sofaThreadPoolHystrixCommand = new SofaSemaphoreHystrixCommand(restTemplate);
                System.out.println(sofaThreadPoolHystrixCommand.execute().toString());

            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

结果和线程隔离的差不多。不贴结果了。