Guava Retry 重试机制流程分析

最新推荐文章于 2024-09-03 08:29:00 发布

Java八股文

最新推荐文章于 2024-09-03 08:29:00 发布

阅读量348

点赞数 5

文章标签： guava php 开发语言

本文链接：https://blog.csdn.net/CXY123654654321/article/details/141105509

版权

Guava Retry 重试机制源码分析

在进行重试时，我们要考虑以下几点：

何时启动重试机制（发生异常、网络延迟等）；
何时结束重试（调用成功）；
重试的时间间隔是多久，即计算等待时间（固定时间、指数退避等）；
如何进行等待（Thread.sleep）

而在 Guava Retry 库中都提供了这些的解决方法。

一、Guava Retry 重试机制使用

引入 guava-retry 库：

java

代码解读

复制代码

<dependency> <groupId>com.github.rholder</groupId> <artifactId>guava-retrying</artifactId> <version>2.0.0</version> </dependency>

示例代码：

java

代码解读

复制代码

@Slf4j public class FixIntervalRetryStrategy implements RetryStrategy<RpcResponse> { @Override public RpcResponse doRetry(Callable<RpcResponse> callable) throws Exception { Retryer<RpcResponse> retryer = RetryerBuilder.<RpcResponse>newBuilder() .retryIfExceptionOfType(Exception.class) .withStopStrategy(StopStrategies.stopAfterAttempt(3)) .withWaitStrategy(WaitStrategies.fixedWait(3, TimeUnit.SECONDS)) .withRetryListener(new RetryListener() { @Override public <V> void onRetry(Attempt<V> attempt) { // 监听重试机制 log.info("重试次数：{}", attempt.getAttemptNumber()); } }) .build(); return retryer.call(callable); } }

retryIfExceptionOfType：在发生什么类型的异常时进行重试；
withStopStrategy：何时结束重试；
withWaitStrategy：每次等待多久后进行再次重试；
withRetryListener：定义重试的监听器；

1）对于何时进行重试，Guava 的 RetryerBuilder 类给我们提供了很多方法：

java

代码解读

复制代码

// 在发生Exception异常时触发重试 public RetryerBuilder<V> retryIfException() { rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionClassPredicate<V>(Exception.class)); return this; } // 在发生RuntimeException异常时触发重试 public RetryerBuilder<V> retryIfRuntimeException() { rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionClassPredicate<V>(RuntimeException.class)); return this; } // 在发生指定Exception异常时触发重试 public RetryerBuilder<V> retryIfExceptionOfType(@Nonnull Class<? extends Throwable> exceptionClass) { Preconditions.checkNotNull(exceptionClass, "exceptionClass may not be null"); rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionClassPredicate<V>(exceptionClass)); return this; } public RetryerBuilder<V> retryIfException(@Nonnull Predicate<Throwable> exceptionPredicate) { Preconditions.checkNotNull(exceptionPredicate, "exceptionPredicate may not be null"); rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionPredicate<V>(exceptionPredicate)); return this; } public RetryerBuilder<V> retryIfResult(@Nonnull Predicate<V> resultPredicate) { Preconditions.checkNotNull(resultPredicate, "resultPredicate may not be null"); rejectionPredicate = Predicates.or(rejectionPredicate, new ResultPredicate<V>(resultPredicate)); return this; }

2）对于重试间隔，Guava 的 WaitStrategies 给我们提供了很多种策略：

FixedWaitStrategy：固定时间进行重试；
RandomWaitStrategy：随机等待时间进行重试；
IncrementingWaitStrategy：根据失败次数计算等待时间
ExponentialWaitStrategy：随着指数倍数增长；
FibonacciWaitStrategy：随着失败尝试次数的增加，等待时间按照斐波那契数列增长；
CompositeWaitStrategy：这个策略类的特点是将多个不同的等待策略组合在一起，并按顺序将这些策略的等待时间相加，以计算总的等待时间；
ExceptionWaitStrategy：根据指定异常自定义过期时间；

3）对于何时结束重试，Guava 的 StopStrategies 给我们提供了很多种策略：

StopAfterDelayStrategy：在延迟多久后停止重试；
StopAfterAttemptStrategy：在重试指定次数后停止重试；
NeverStopStrategy：从不停止重试；

4）对于等待调用，Guava 只提供了一个类 ThreadSleepStrategy：

java

代码解读

复制代码

@Immutable private static class ThreadSleepStrategy implements BlockStrategy { @Override public void block(long sleepTime) throws InterruptedException { Thread.sleep(sleepTime); } }

实质上是调用 Thread.sleep 方法进行阻塞等待；

二、重试机制的核心流程

2.1 构建 Retry 类

我们先看看 RetryBuilder 的 build 方法，它是如何构建出 Retry 的：

java

代码解读

复制代码

public Retryer<V> build() { AttemptTimeLimiter<V> theAttemptTimeLimiter = attemptTimeLimiter == null ? AttemptTimeLimiters.<V>noTimeLimit() : attemptTimeLimiter; StopStrategy theStopStrategy = stopStrategy == null ? StopStrategies.neverStop() : stopStrategy; WaitStrategy theWaitStrategy = waitStrategy == null ? WaitStrategies.noWait() : waitStrategy; BlockStrategy theBlockStrategy = blockStrategy == null ? BlockStrategies.threadSleepStrategy() : blockStrategy; return new Retryer<V>(theAttemptTimeLimiter, theStopStrategy, theWaitStrategy, theBlockStrategy, rejectionPredicate, listeners); }

该方法会设置停止策略，阻塞策略，等待策略以及 theAttemptTimeLimiter，其中 theAttemptTimeLimiter 的作用是确保重试方法调用时不会超过指定时间限制，避免阻塞进程，它可以设置为无限制等待或者指定时间等待。
我们还需要注意 rejectionPredicate 这个参数，这个参数是判断是否进行重试的关键。

rejectionPredicate 的构建我们需要 RetryBuilder 类里面的方法：

java

代码解读

复制代码

public RetryerBuilder<V> retryIfExceptionOfType(@Nonnull Class<? extends Throwable> exceptionClass) { Preconditions.checkNotNull(exceptionClass, "exceptionClass may not be null"); rejectionPredicate = Predicates.or(rejectionPredicate, new ExceptionClassPredicate<V>(exceptionClass)); return this; } public static <T extends @Nullable Object> Predicate<T> or( Predicate<? super T> first, Predicate<? super T> second) { return new OrPredicate<>(Predicates.<T>asList(checkNotNull(first), checkNotNull(second))); } // 這個是OrPredicate的構造函數 private OrPredicate(List<? extends Predicate<? super T>> components) { this.components = components; }

通过将Predicate的判断实现类封装到 components 数组中，然后遍历该数组查找符合条件当前重试条件的一个，如果没有符合条件意味着当前不需要重试；

其中 Predicate 接口的实现类是 ExceptionClassPredicate，是 RetryBuilder 的内部类：

java

代码解读

复制代码

private static final class ExceptionClassPredicate<V> implements Predicate<Attempt<V>> { private Class<? extends Throwable> exceptionClass; public ExceptionClassPredicate(Class<? extends Throwable> exceptionClass) { this.exceptionClass = exceptionClass; } @Override public boolean apply(Attempt<V> attempt) { // 判断当前重试中是否存在异常 if (!attempt.hasException()) { return false; } return exceptionClass.isAssignableFrom(attempt.getExceptionCause().getClass()); } }

Attempt 是当前重试动作的抽象；

2.2 执行重试流程

创建出 Retry 后，我们看看 Retry 的 call 方法：

java

代码解读

复制代码

public V call(Callable<V> callable) throws ExecutionException, RetryException { long startTime = System.nanoTime(); // 循环记录重试次数 for (int attemptNumber = 1; ; attemptNumber++) { Attempt<V> attempt; try { // 执行callable接口方法 V result = attemptTimeLimiter.call(callable); // 封装重试结果 attempt = new ResultAttempt<V>(result, attemptNumber, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)); } catch (Throwable t) { // 重试执行如果发生异常就封装到ExceptionAttempt中 attempt = new ExceptionAttempt<V>(t, attemptNumber, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime)); } // 调用重试监听器 for (RetryListener listener : listeners) { listener.onRetry(attempt); } // 判断是否需要进行重试 if (!rejectionPredicate.apply(attempt)) { return attempt.get(); } // 停止策略判断是否需要终止当前重试流程 if (stopStrategy.shouldStop(attempt)) { throw new RetryException(attemptNumber, attempt); } else { // 调用等待机制计算等待时间 long sleepTime = waitStrategy.computeSleepTime(attempt); try { // 阻塞策略进行睡眠等待 blockStrategy.block(sleepTime); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new RetryException(attemptNumber, attempt); } } } }

该方法就是调用重试机制核心方法，它的主流程包括以下步骤：