Guava-Retry实践

前言

在实际业务中，有非常多场景需要我们进行重试操作，编码中通过采用各种回调的方式来抽象重试的实现，但都不是那么理想。通过简单的调研，目前主要有Guava-Retry和Spring-Retry作为三方库比较流行，本章节将介绍Guava-Retry的实际应用。

Guave在github地址( https://github.com/rholder/guava-retrying)，可以看到其已经有很长一段时间没有更新维护，但这并不影响其正常使用，他已经足够的稳定。其相比较于Spring-Retry在是否重试的判断条件上有更多的选择性，如类似的 retryIf方法。

其主要接口及策略介绍：

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 ：复合时长等待策略；

本章概要

1、根据结果判断是否重试

2、根据异常判断是否重试

3、重试策略——设定无限重试

4、重试策略——设定最大的重试次数

5、等待策略——设定重试等待固定时长策略

6、等待策略——设定重试等待时长固定增长策略

7、等待策略——设定重试等待时长按指数增长策略

8、等待策略——设定重试等待时长按斐波那契数列增长策略

9、等待策略——组合重试等待时长策略

10、重试监听器——RetryListener实现重试过程细节处理

根据结果判断是否重试

场景：如果返回值不是'good'则需要重试，返回值通过counter控制，直到等于5方会返回’good‘。

示例代码：

private < T > T run(Retryer< T > retryer, Callable< T > callable) {

try {

return retryer.call(callable);

} catch (RetryException | ExecutionException e) {

LOGGER .trace(ExceptionUtils. getFullStackTrace (e));

LOGGER .warn(e.getMessage());

}

return null ;

}

private Callable<String> callableWithResult() {

return new Callable<String>() {

int counter = 0 ;

public String call() throws Exception {

counter ++;

LOGGER .info( "do sth : {}" , counter );

if ( counter < 5 ) {

return "sorry" ;

}

return "good" ;

}

};

}

@Test

public void retryWithResult() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfResult(result -> !result.contains( "good" ))

.withStopStrategy(StopStrategies. neverStop ())

.build();

run(retryer, callableWithResult());

}

打印：

根据异常判断是否重试

场景：如果counter值小于5则抛出异常，等于5则正常返回停止重试；

示例代码：

private Callable<String> callableWithException() {

return new Callable<String>() {

int counter = 0 ;

public String call() throws Exception {

counter ++;

LOGGER .info( "do sth : {}" , counter );

if ( counter < 5 ) {

throw new RuntimeException( "sorry" );

}

return "good" ;

}

};

}

@Test

public void retryWithException() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

重试策略——设定无限重试

场景：在有异常情况下，无限重试，直到返回正常有效结果；

示例代码：

@Test

public void retryNeverStop() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

重试策略——设定最大的重试次数

场景：在有异常情况下，最多重试3次，如果超过3次则会抛出异常；

示例代码：

@Test

public void retryStopAfterAttempt() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. stopAfterAttempt ( 3 ))

.withWaitStrategy(WaitStrategies. fixedWait ( 100 , TimeUnit. MILLISECONDS ))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

等待策略——设定重试等待固定时长策略

场景：设定每次重试等待间隔固定为100ms；

示例代码：

@Test

public void retryWaitFixStrategy() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withWaitStrategy(WaitStrategies. fixedWait ( 100 , TimeUnit. MILLISECONDS ))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

基本每次的间隔维持在100ms。

等待策略——设定重试等待时长固定增长策略

场景：设定初始等待时长值，并设定固定增长步长，但不设定最大等待时长；

示例代码：

@Test

public void retryWaitIncreaseStrategy() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withWaitStrategy(WaitStrategies. incrementingWait ( 200 , TimeUnit. MILLISECONDS , 100 , TimeUnit. MILLISECONDS ))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

可以看到，等待时长依次为 200ms、300ms、400ms、500ms，符合策略约定。

等待策略——设定重试等待时长按指数增长策略

场景：根据multiplier值按照指数级增长等待时长，并设定最大等待时长；

示例代码：

@Test

public void retryWaitExponentialStrategy() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withWaitStrategy(WaitStrategies. exponentialWait ( 100 , 1000 , TimeUnit. MILLISECONDS ))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

可以看到，等待时长依次为200ms、400ms、800ms、1000ms，符合策略约定。

等待策略——设定重试等待时长按斐波那契数列增长策略

场景：根据multiplier值按照 斐波那契数列增长等待时长，并设定最大等待时长，斐波那契数列：1、1、2、3、5、8、13、21、34、……

示例代码：

@Test

public void retryWaitFibonacciStrategy() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withWaitStrategy(WaitStrategies. fibonacciWait ( 100 , 1000 , TimeUnit. MILLISECONDS ))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

可以看到，等待时长依次为 100ms、100ms、200ms、300ms，符合策略约定。

等待策略——组合重试等待时长策略

场景：组合 ExponentialWaitStrategy和 FixedWaitStrategy策略。

示例代码：

@Test

public void retryWaitJoinStrategy() {

Retryer<String> retryer = RetryerBuilder.<String> newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withWaitStrategy(WaitStrategies. join (WaitStrategies. exponentialWait ( 25 , 500 , TimeUnit. MILLISECONDS )

, WaitStrategies. fixedWait ( 50 , TimeUnit. MILLISECONDS )))

.build();

LOGGER .info( "result : " + run(retryer, callableWithException()));

}

打印：

可以看到，等待时长依次为 100(50+50)ms、150(100+50)ms、250(200+50)ms、450(400+50)ms，符合策略约定。

监听器——RetryListener实现重试过程细节处理

场景：定义两个监听器，分别打印重试过程中的细节，未来可更多的用于异步日志记录，亦或是特殊处理。

示例代码：

private RetryListener myRetryListener() {

return new RetryListener() {

@Override

public < T > void onRetry(Attempt< T > attempt) {

// 第几次重试,(注意:第一次重试其实是第一次调用)

LOGGER .info( "[retry]time=" + attempt.getAttemptNumber());

// 距离第一次重试的延迟

LOGGER .info( ",delay=" + attempt.getDelaySinceFirstAttempt());

// 重试结果: 是异常终止, 还是正常返回

LOGGER .info( ",hasException=" + attempt.hasException());

LOGGER .info( ",hasResult=" + attempt.hasResult());

// 是什么原因导致异常

if (attempt.hasException()) {

LOGGER .info( ",causeBy=" + attempt.getExceptionCause().toString());

} else {

// 正常返回时的结果

LOGGER .info( ",result=" + attempt.getResult());

}

// 增加了额外的异常处理代码

try {

T result = attempt.get();

LOGGER .info( ",rude get=" + result);

} catch (ExecutionException e) {

LOGGER .error( "this attempt produce exception." + e.getCause().toString());

}

}

};

}

private RetryListener myRetryListener2() {

return new RetryListener() {

@Override

public < T > void onRetry(Attempt< T > attempt) {

LOGGER .info( "myRetryListener2 : [retry]time=" + attempt.getAttemptNumber());

}

};

}

private < T > T runWithFixRetryAndListener(Callable< T > callable) {

Retryer< T > retryer = RetryerBuilder.< T > newBuilder ()

.retryIfRuntimeException()

.withStopStrategy(StopStrategies. neverStop ())

.withRetryListener(myRetryListener())

.withRetryListener(myRetryListener2())

.build();

return run(retryer, callable);

}

@Test

public void retryWithRetryListener() {

LOGGER .info( "result : " + runWithFixRetryAndListener(callableWithException()));

}

打印：

RetryListener会根据注册顺序执行。