简介

The guava-retrying module provides a general purpose method for retrying arbitrary Java code with specific stop, retry, and exception handling capabilities that are enhanced by Guava's predicate matching.

maven依赖

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

使用说明

简单的demo

Callable<Boolean> callable = new Callable<Boolean>() {
    public Boolean call() throws Exception {
        return true; // do something useful here
    }
};

Retryer<Boolean> retryer = RetryerBuilder.<Boolean>newBuilder()
        .retryIfResult(Predicates.<Boolean>isNull())
        .retryIfExceptionOfType(IOException.class)
        .retryIfRuntimeException()
        .withStopStrategy(StopStrategies.stopAfterAttempt(3))
        .build();
try {
    retryer.call(callable);
} catch (RetryException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
}

首先重试的内容主体必须是一个Callable的实现，重试是根据其call方法的执行状态（异常、返回值）定制的重试策略来进行重试的。
比如上面的列子。重试者retryer由建造者RetryerBuilder创建的，RetryerBuilder提供了各种方法来定制重试策略。

根据返回是否是null来决定是否重试

.retryIfResult(Predicates.<Boolean>isNull())

根据异常类型是否是IOException来决定是否重试

.retryIfExceptionOfType(IOException.class)

多个类型的时候还可以使用Predicate

Retryer<Void> retryer1 = RetryerBuilder.<Void>newBuilder()
        .retryIfException(Predicates.or(Predicates.instanceOf(NullPointerException.class),
                                        Predicates.instanceOf(IllegalStateException.class)))
        .withStopStrategy(StopStrategies.stopAfterAttempt(3)) // 重试3次后停止
        .build();

根据异常是否是RuntimeException来决定是否重试

.retryIfRuntimeException()

设置重试的终止策略，尝试3次后终止

.withStopStrategy(StopStrategies.stopAfterAttempt(3))

除了上述重试判断外判断重试的方式与策略还有很多，比如

重试判断

返回值匹配

.retryIfResult(Predicates.containsPattern("_error$"))

.retryIfResult(Predicates.equalTo(2))

终止策略

常用的终止策略在com.github.rholder.retry.StopStrategies中。

尝试3次后终止

.withStopStrategy(StopStrategies.stopAfterAttempt(3))

30s后终止

.withStopStrategy(StopStrategies.stopAfterDelay(30,TimeUnit.SECONDS))

不终止

.withStopStrategy(StopStrategies.neverStop())

等待策略

很多场景下并不是立即重试（环境影响，立即重试的失败率依旧很高），一般会等待一段时间后继续重试。
提供了等待策略，常用策略在com.github.rholder.retry.WaitStrategies中。

比如

等待固定时间

.withWaitStrategy(WaitStrategies.fixedWait(5L, TimeUnit.SECONDS))

每次等待时间递增

.withWaitStrategy(WaitStrategies.incrementingWait(3, TimeUnit.SECONDS,1,TimeUnit.SECONDS))

斐波那契式等待

.withWaitStrategy(WaitStrategies.fibonacciWait())

重试监听

guava-retrying提供每次重试的监听机制，每次重试后会回调注册的监听者，按顺序依次执行。

监听者必须实现RetryListener.onRetry的方法。参数attempt是每次尝试的记录。

public class MyRetryListener<Boolean> implements RetryListener {

    @Override
    public <Boolean> void onRetry(Attempt<Boolean> attempt) {

        // 第几次重试,(注意:第一次重试其实是第一次调用)
        System.out.print("[retry]time=" + attempt.getAttemptNumber());

        // 距离第一次重试的延迟
        System.out.print(",delay=" + attempt.getDelaySinceFirstAttempt());

        // 重试结果: 是异常终止, 还是正常返回
        System.out.print(",hasException=" + attempt.hasException());
        System.out.print(",hasResult=" + attempt.hasResult());

        // 是什么原因导致异常
        if (attempt.hasException()) {
            System.out.print(",causeBy=" + attempt.getExceptionCause().toString());
        } else {
            // 正常返回时的结果
            System.out.print(",result=" + attempt.getResult());
        }

        // bad practice: 增加了额外的异常处理代码
        try {
            Boolean result = attempt.get();
            System.out.print(",rude get=" + result);
        } catch (ExecutionException e) {
            System.err.println("this attempt produce exception." + e.getCause().toString());
        }

        System.out.println();
    }
}

增加监听者（可以增加多个，顺序执行）

.withRetryListener(new MyRetryListener<>())
.withRetryListener(new RetryListener() {
            @Override
            public <V> void onRetry(Attempt<V> attempt) {
                if (attempt.hasException()){
                    attempt.getExceptionCause().printStackTrace();
                }
            }
        })

核心逻辑

long startTime = System.nanoTime();
for (int attemptNumber = 1; ; attemptNumber++) {
    Attempt<V> attempt;
    try {
        // 执行成功
        V result = attemptTimeLimiter.call(callable);
        attempt = new ResultAttempt<V>(result, attemptNumber, TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime));
    } catch (Throwable t) {
        // 执行失败
        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);
        }
    }
}

主要接口

Attempt

一次执行任务

AttemptTimeLimiter

单次任务执行时间限制（如果单次任务执行超时，则终止执行当前任务）

BlockStrategies

任务阻塞策略（通俗的讲就是当前任务执行完，下次任务还没开始这段时间做什么）

默认策略为：BlockStrategies.THREAD_SLEEP_STRATEGY 也就是调用 Thread.sleep(sleepTime);

RetryException

重试异常

RetryListener

自定义重试监听器，可以用于异步记录错误日志；

StopStrategy

停止重试策略，提供三种

• StopAfterDelayStrategy ：设定一个最长允许的执行时间比如设定最长执行10s，无论任务执行次数，只要重试的时候超出了最长时间，则任务终止，并返回重试异常RetryException
• NeverStopStrategy ：不停止，用于需要一直轮训知道返回期望结果的情况
• StopAfterAttemptStrategy ：设定最大重试次数，如果超出最大重试次数则停止重试，并返回重试异常

WaitStrategy

等待时长策略（控制时间间隔），返回结果为下次执行时长

• FixedWaitStrategy：固定等待时长策略
• RandomWaitStrategy：随机等待时长策略（可以提供一个最小和最大时长，等待时长为其区间随机值）
• IncrementingWaitStrategy：递增等待时长策略（提供一个初始值和步长，等待时间随重试次数增加而增加）
• ExponentialWaitStrategy：指数等待时长策略
• FibonacciWaitStrategy ：Fibonacci 等待时长策略
• ExceptionWaitStrategy ：异常时长等待策略
• CompositeWaitStrategy ：复合时长等待策略