Resilience4j的使用_ringbuffersizeinhalf-优快云博客

本文链接：https://blog.youkuaiyun.com/java_zjh/article/details/85119124

本文详细介绍Resilience4j库中CircuitBreaker、Retry和TimeLimiter组件的配置与使用方法，通过实例演示如何在Java应用中实现熔断、重试和超时策略，提升系统的稳定性和响应能力。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Resilience4j的CircuitBreaker使用

此方法有点复杂，看如下图：

failureRateThreshold，默认为50，即失败率阈值为50%
ringBufferSizeInHalfOpenState，设置当断路器处于HALF_OPEN状态下的ring buffer的大小，它存储了最近一段时间请求的成功失败状态，默认为10
ringBufferSizeInClosedState，设置当断路器处于CLOSED状态下的ring buffer的大小，它存储了最近一段时间请求的成功失败状态，默认为100
waitDurationInOpenState，用来指定断路器从OPEN到HALF_OPEN状态等待的时长，默认是60秒
recordFailurePredicate，用于判断哪些异常应该算作失败纳入断路器统计，默认是Throwable类型
automaticTransitionFromOpenToHalfOpenEnabled，当waitDurationInOpenState时间一过，是否自动从OPEN切换到HALF_OPEN，默认为true

CircuitBreakerConfig circuitBreakerConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(30)
        .waitDurationInOpenState(Duration.ofMillis(1000))
        .ringBufferSizeInHalfOpenState(5)
        .ringBufferSizeInClosedState(10)
        .build();

final Random random = new Random(100);
CircuitBreakerRegistry circuitBreakerRegistry = CircuitBreakerRegistry.of(circuitBreakerConfig);
CircuitBreaker circuitBreaker = circuitBreakerRegistry.circuitBreaker("uniqueName", circuitBreakerConfig);
CheckedFunction0<String> decoratedSupplier = CircuitBreaker
        .decorateCheckedSupplier(circuitBreaker, () -> {
            long num = random.nextInt(100);
            if (num > 0 && num < 30) {
                throw new RuntimeException("EX:" + num);
            }
            return "" + num;
        });
int index = 0;
for (; index < 100; index++) {
    Try<String> result = Try.of(decoratedSupplier);
    result.onFailure(f -> {
        System.out.println(f.getMessage() +">"+ circuitBreaker.getState());

    });
    result.onSuccess(f -> {
        System.out.println(f +"="+ circuitBreaker.getState());
    });
    TimeUnit.MILLISECONDS.sleep(100);
}

Resilience4j的Retry使用

RetryConfig config = RetryConfig.custom()
        .maxAttempts(2) //最少重试次数
        .waitDuration(Duration.ofMillis(100)) //间隔多少时间发一次重试机制
        .retryOnException(throwable -> API.Match(throwable).of(
                API.Case($(Predicates.instanceOf(WebServiceException.class)), true),//表示调用方法如果Throw WebServiceException，则启动重试机制
                API.Case($(), false) //其它异常对象忽略))
                        .build();
Retry retry = Retry.of("dd", config);//装载可能会要重试方法
CheckedFunction0<String> retryableSupplier = Retry.decorateCheckedSupplier(retry, () -> {
    System.out.println("1");
    throw new WebServiceException();
});
//调用方法，如果失败，会执行recover方法，进入异常修复方法。
Try<String> result = Try.of(retryableSupplier).recover((throwable -> {
    System.out.println(throwable.getMessage());
    return "hello";
}));

Resilience4j的TimeLimiter使用

TimeLimiterConfig config = TimeLimiterConfig.custom()
        .timeoutDuration(Duration.ofMillis(5000)) //超时时间
        .cancelRunningFuture(true)  //是否Cancel Future
        .build();
TimeLimiter timeLimiter = TimeLimiter.of(config);
Supplier<Future<Integer>> futureSupplier = () -> CompletableFuture.supplyAsync(() -> {
    try {

        TimeUnit.MILLISECONDS.sleep(6000);

    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return 9;
});

Callable restrictedCall = TimeLimiter
        .decorateFutureSupplier(timeLimiter, futureSupplier);
Try.ofCallable(restrictedCall).onFailure(f -> System.out.println(f));

Resilience4j的使用说明文档:http://resilience4j.github.io/resilience4j/#_set_up_3