spring cloud Resilience4j - 熔断器 CircuitBreaker

在微服务架构中，一般我们的独立服务是比较多的，每个独立服务之间划分责任边界，并通过约定协议接口来进行通信。当我们的调用链路复杂依赖多时，很可能会发生雪崩效应。

假设有这么一个场景，有A, B, C, D四个独立服务，A会依赖B，C，D；当D发生负载过高或网络异常等导致响应过慢或超时时，很可能A会因此堆积过多的等待链接，从而导致A的状态也转为异常，后面依赖到A的其他服务跟着发生链式反应，这将会导致大面积的服务不可用，即使本来是一些没有依赖到B，C，D的服务。

状态说明

熔断器有如下状态：

• CLOSED： 熔断器关闭，表示接口状态正常。
• OPEN：熔断器打开，表示接口状态异常，直接抛出CallNotPermittedException。如果有failback则调用failback函数。
• HALF_OPEN：半开状态，允许指定数量的请求通过，以查看后端服务是否正常。超过指定数量的请求，抛出CallNotPermittedException。
• DISABLED：停用熔断器，所有请求允许通过。
• FORCED_OPEN：强制开启熔断器，所有请求不允许通过。

状态机：

滑动窗口

Resilience4j 支持两种滑动窗口算法：

• 基于数量的滑动窗口：
  统计指定数量的请求数，请求先进先出，计算失败比例。查询失败比例的时间复杂度为O(1)，与窗口大小无关；空间复杂度为O(n)
• 基于时间的滑动窗口：
  窗口包含N个桶，N为时间秒数。分别计算每个桶的失败比例，然后计算一个总数。桶也是先进先出。查询失败比例的时间复杂度为O(1)，与窗口大小无关；空间复杂度为O(n)

参数说明

参数	默认值	说明
failureRateThreshold	50	失败比例，如果超过该值，熔断器打开
slowCallDurationThreshold	60000[ms]	超过设置的时间，则是慢请求
slowCallRateThreshold	100	慢请求比例，超过该比例，熔断器打开
permittedNumberOfCallsInHalfOpenState	10	半开状态下，允许通过的调用数量
maxWaitDurationInHalfOpenState	0	熔断器处理半开状态的最大时长，超过该时间，转为打开状态。0 表示不限
slidingWindowType	COUNT_BASED	滑动窗口类型，COUNT_BASED、TIME_BASED
slidingWindowSize	100	滑动窗口大小
minimumNumberOfCalls	100	在计算失败率或慢调用率时，窗口中至少要有多少个调用。当窗口中只有99个调用，即使都失败了，熔断器也不会打开
waitDurationInOpenState	60000 [ms]	熔断器从打开状态变为半开状态等待的时间
automaticTransitionFromOpenToHalfOpenEnabled	false	等待了waitDurationInOpenState时间后，是否自动变为半开状态。true:需要另起一个线程监控状态；false：只有有调用到来时，才会触发状态的转变
recordExceptions	空	异常列表，只有指定的异常和其子类，才会认为调用失败；其它异常会被认为是调用成功，除非指定了ignoreExceptions
ignoreExceptions	空	异常列表，忽略指定的异常，不计入成功和失败数
recordException	throwable -> true, 所有异常都认为是失败	表达式返回true表示计入调用失败，false计入调用成功。除非指定了ignoreExceptions
ignoreException	throwable -> false，没有异常被忽略	表达式返回true表示忽略该异常，false算入调用失败。

实例

配置文件

application.properties

resilience4j.circuitbreaker:
    instances:
        backendA:
            registerHealthIndicator: true
            slidingWindowSize: 100
        backendB:
            registerHealthIndicator: true
            slidingWindowSize: 10
            permittedNumberOfCallsInHalfOpenState: 3
            slidingWindowType: TIME_BASED
            minimumNumberOfCalls: 20
            waitDurationInOpenState: 50s
            failureRateThreshold: 50
            eventConsumerBufferSize: 10
            recordFailurePredicate: io.github.robwin.exception.RecordFailurePredicate

规则取名为-order

使用注解方式实现熔断

    @GetMapping("/getCoffee1")
    @io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker(name = "order"，fallbackMethod = "fallback")
    public Coffee getCoffee1() {
        Coffee list = coffeeService.getById(1l);
        log.info("Read coffee: {} coffee", list);
        return list;
    }
    private Coffee fallback(IllegalArgumentException e){
        return new Coffee();
    }
    private Coffee fallback(RuntimeException e){
        return new Coffee();
    }

使用代码注册的方式实现

  private CircuitBreaker circuitBreaker;
    public CustomerController(CircuitBreakerRegistry registry) {
        circuitBreaker = registry.circuitBreaker("order");
    }
    @GetMapping("/getCoffee2")
    public List<Coffee> getCoffee2() {
        return Try.ofSupplier(
                CircuitBreaker.decorateSupplier(circuitBreaker,
                        () -> coffeeService.getAll()))
                .recover(CircuitBreakerOpenException.class, Collections.emptyList())
                .get();
    }

响应式：

@CircuitBreaker(name = BACKEND, fallbackMethod = "fallback")
@RateLimiter(name = BACKEND)
@Bulkhead(name = BACKEND)
@Retry(name = BACKEND, fallbackMethod = "fallback")
@TimeLimiter(name = BACKEND)
public Mono<String> method(String param1) {
    return Mono.error(new NumberFormatException());
}

private Mono<String> fallback(String param1, IllegalArgumentException e) {
    return Mono.just("test");
}

private Mono<String> fallback(String param1, RuntimeException e) {
    return Mono.just("test");
}

更多

spring cloud resilience4j-retry 重试
spring cloud resilience4j - Bulkhead 线程隔离 并发控制
spring cloud Resilience4j - 熔断器 CircuitBreaker
spring cloud resilience4j - RateLimiter 流控
参考：
https://resilience4j.readme.io/docs/getting-started-3