Spring-Cloud使用Resilience4j实现熔断、限流-spring cloud 熔断降级限流

由于hystrix官方已经停止维护了，目前spring-cloud推荐使用resilience4j来代替hystrix实现熔断、限流。

熔断一般指客户端调用服务端接口出现异常时客户端侧的处理，当然也可以是服务端的处理出现异常时熔断快速返回，可以暂时切断对下游服务的调用，是一种牺牲局部保全整体的有效措施（同时此客户端也可能是服务端）。

限流一般是指限制在指定时间间隔内的请求量，避免因请求过多导致服务崩溃，限流被看作是服务端的自我保护能力。

1、客户端openfeign使用resilience4j实现熔断

模拟一个客户端，通过feign调用一个服务端接口来模拟此功能。

使用spring-boot的版本为2.7.3，spring-cloud版本为2021.0.4，关键的依赖如下：

引入关键依赖

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-feign</artifactId>
</dependency>

application.yaml增加以下熔断配置。

resilience4j:
  circuitbreaker:
    instances:
      ApiService:
        registerHealthIndicator: true
        slidingWindowSize: 7
        slidingWindowType: COUNT_BASED
        waitDurationInOpenState: 5000
        permittedNumberOfCallsInHalfOpenState: 6
feign:
  client:
    config:
      default:
        readTimeout: 1000
        connectTimeout: 1000
  circuitbreaker:
    enabled: true
logging:
  level:
    root: info
  pattern:
    console: "%d{${LOG_DATEFORMAT_PATTERN:HH:mm:ss.SSS}} %m%n"

需要注意的是feign需要开启circuitbreaker，并在启动类中增加@EnableFeignClients，spring-boot默认情况下会使用logback来管理日志，为了便于观察调整参数后的效果调整一下日志格式，在此案例中默认的日志格式在org.springframework.boot.logging.logback.DefaultLogbackConfiguration类中defaults方法中定义，此类在包spring-boot:2.7.3中。

增加feign客户端请求类并需要增加fallback方法处理熔断后的默认返回，简单写一个测试类完成测试，观察对应的参数情况。

编写一个feign client端。

//ApiClient.java
@FeignClient(name = "ApiService", url = "http://localhost:8082")
public interface ApiClient {
    @GetMapping("/api/test")
    @CircuitBreaker(name = "ApiService", fallbackMethod = "getUserFallback")
    String getUser(@RequestParam(name = "param") String param, @RequestParam(name = "time") int time);

    default String getUserFallback(String param, int time, Exception exc) {
        return "default value";
    }

}

编写一个单元测试模拟调用。

//ResilienceTest.java
@Slf4j
@SpringBootTest
class ResilienceTest {
    @Autowired
    private ApiClient apiClient;
    @Autowired
    private CircuitBreakerRegistry circuitBreakerRegistry;
    @Test
    void test() throws Exception {
        for (int i = 0; i < 1000; i++) {
            apiClient.getUser("test", 500);
            status();
            Thread.sleep(500);
        }
    }
    private void status(){
        CircuitBreaker breaker = circuitBreakerRegistry.circuitBreaker("ApiService");
        CircuitBreaker.Metrics metrics = breaker.getMetrics();
        log.info("state={},metrics[failureRate={},bufferedCalls={},failedCalls={},successCalls={},maxBufferCalls={},notPermittedCalls={}]"
                , breaker.getState(), metrics.getFailureRate(), metrics.getNumberOfBufferedCalls(), metrics.getNumberOfFailedCalls()
                , metrics.getNumberOfSuccessfulCalls(), metrics.getNumberOfBufferedCalls(), metrics.getNumberOfNotPermittedCalls());
    }

}

在没有任务服务端的情况下，运行单元测试即可模拟熔断的效果。另外需要注意配置的feign调用的超时，单元测试中增加获取metrics并打印以便观察效果。

运行结果如下：

简单分析一下，滑动窗口的大小slidingWindowSize为7，滑动窗口类型slidingWindowType为计数器，熔断器从打开到半开的状态等待时间为5秒，熔断器半开状态下允许的数量permittedNumberOfCallsInHalfOpenState为6。

failureRateThreshold的含义：如60（即%60），这个阈值控制两个状态的变化，从CLOSE=>OPEN时，表示当错误率高于60%时开启熔断，而状态从HALF_OPEN=>CLOSE时，表示当错误率低于60%时关闭熔断。

2、服务端使用resilience4j实现限流

使用一个服务端的接口简单模拟一下限流的方式，如设定5秒内最多10个请求，观察异常情况。

同样是使用spring-boot的版本2.7.3，spring-cloud版本2021.0.4进行模拟。

引入关键依赖。

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
</dependency>

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

application.yaml配置文件增加ratelimiter配置。

resilience4j:
  ratelimiter:
    instances:
      ApiService:
        limitForPeriod: 10
        limitRefreshPeriod: 5s
        timeoutDuration: 0

limitRefreshPeriod表示刷新周期，limitForPeriod表示一个时间周期内请求的总数，配置表示5秒内允许10个请求。

写一个controller接收请求，service处理请求并增加限流控制，同时增加一个限流后异常处理。

//ApiController.java
@Slf4j
@RequestMapping("/api")
@RestController
public class ApiController {
    @Autowired
    private ApiService apiService;
    @GetMapping("/limit")
    public String limit() {
        return apiService.limit();
    }
}
//ApiService.java
@Slf4j
@Service
public class ApiService {
    @RateLimiter(name = "ApiService", fallbackMethod = "testFallback")
    public String limit() {
        return "success";
    }
    @SneakyThrows
    public String testFallback(java.lang.Throwable exception) {
        throw exception;
    }
}
//Advice.java
@Slf4j
@ControllerAdvice
public class Advice {
    @ExceptionHandler(RequestNotPermitted.class)
    @ResponseStatus(HttpStatus.TOO_MANY_REQUESTS)
    public void error(){
        log.error("Too Many Requests");
    }
}

编写一个ControllerAdvice通过处理RequestNotPermitted异常，返回客户端响应码429。

编写一个测试类模拟限流情况。

@Slf4j
@SpringBootTest
class ResilienceTest {
    private RestTemplate restTemplate = new RestTemplate();
    @Test
    void limit() throws Exception {
        for (int i = 1; i <= 99; i++) {
            try {
                ResponseEntity<String> response = restTemplate.getForEntity("http://localhost:9999/api/limit", String.class);
                log.info("status code {} {}", String.format("%02d", i), response.getStatusCode());
            } catch (HttpClientErrorException e) {
                log.error("status code {}", e.getStatusCode());
            }
            Thread.sleep(400);
        }
    }
}

可以适当减少单元测试的休眠时间，观察发生限流的情况。