使用Guava-retrying优雅地解决异常重试场景

àì夳堔傛蜴生んèń 2022-10-08 05:57 437阅读 0赞

### 熟悉的重试场景 ###

我们在日常系统开发中，经常会遇到使用Http或者RPC调用跨系统应用的场景。由于是跨系统间调用，不可避免地会遇到网络问题或者服务方限流等原因导致的异常，这时我们就需要对失败的调用进行重试，这会引入了一系列的问题：

哪些异常需要重试？

应该重试多少次？

重试的时间间隔是多少？

每次重试时间的累加如何设定？

超时时间是多少？

### 场景模拟 ###

我们使用代码来模拟实际场景，MockService模拟一个远程调用，使用Random随机数模拟返回的请求结果。为了让重试行为更加明显，这里设置了返回随机数\[0, 9\]，只有返回0才是请求成功，剩余情况都是超时，也就是十分之一的调用成功率。

@Slf4j
    public class MockService { 
    		
      	// 模拟远程服务调用 
        public static Response call() { 
            Random rand = new Random();
            int result = rand.nextInt(10);
    
            if(result == 0) {        // 成功
                return new Response(200, "处理成功");
            } else { 
                try { 
                    Thread.sleep(1 * 1000);
                } catch (Exception e) { 
                    log.error(e.getMessage(), e);
                }
                throw new RuntimeException("处理超过1s，超时");
            }
        }
    }

@AllArgsConstructor
    @Data
    public class Response { 
    
        private int code;       // 状态码
    
        private String msg;     // 返回结果
    }

### Java原生的解决方案 ###

public Response commonRetry() { 
            int retryTimes = 1;
            while(retryTimes <= 10) { 
                try { 
                    log.info("第{}次调用", retryTimes);
                    Response response = MockService.call();
                    if(response.getCode() == 200) { 
                        return response;
                    }
                    Thread.sleep(1000);		// 失败，等待下次调用
                    retryTimes++;
                } catch (Exception e) { 
                    log.error(e.getMessage(), e);
                    try { 
                        Thread.sleep(1000);
                    } catch (Exception e2) { 
                        log.error(e2.getMessage(), e2);
                    }
                    retryTimes++;
                }
            }
            throw new RuntimeException("重试失败");
        }

一般我们可以通过try/catch的方式来设置重试的行为，retryTimes代表重试的次数，每次调用时查看结果的返回码，如果是200则返回结果，如果不是200或者服务抛异常则等待1秒钟，然后重试直到达到最大的重试次数。

可以看到代码比较繁琐，可读性较差。另外，重试策略和业务处理的代码耦合，如果再考虑不同异常的处理方式和重试间隔时间的累加，代码会更加复杂。

### Guava的retrying工具 ###

Guava提供了专门的重试工具来帮我们进行解耦，它对重试逻辑进行了抽象，提供了多种重试策略，而且扩展起来非常方便，可以监控每次充实的结果和行为，提升远程调用方代码的简洁性与实用性。

使用前，我们需要引入guava-retrying包

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

使用方式相当简单，首先声明Retryer对象，通过链式调用配置重试策略，再通过回调函数实现代码逻辑，

public Response graceRetry() { 
            Retryer<Response> retryer = RetryerBuilder.<Response>newBuilder()
                    .retryIfException()		// 当发生异常时重试
                    .retryIfResult(response -> response.getCode() != 200)		// 当返回码不为200时重试
                    .withWaitStrategy(WaitStrategies.fibonacciWait(1000, 10, TimeUnit.SECONDS))	// 等待策略：使用斐波拉契数列递增等待
                    .withStopStrategy(StopStrategies.stopAfterAttempt(10))		// 重试达到10次时退出
                    .build();
            try { 
                return retryer.call(new Callable<Response>() { 
                    @Override
                    public Response call() throws Exception { 
                        log.info("重试调用");
                        return MockService.call();
                    }
                });
            } catch (Exception e) { 
                log.error(e.getMessage(), e);
            }
            throw new RuntimeException("重试失败");
        }

日志结果如下：

19:20:01.862 [main] INFO RetryTest - 重试调用
    19:20:03.868 [main] INFO RetryTest - 重试调用
    19:20:05.874 [main] INFO RetryTest - 重试调用
    19:20:08.882 [main] INFO RetryTest - 重试调用
    19:20:12.892 [main] INFO RetryTest - 重试调用
    19:20:18.897 [main] INFO RetryTest - 重试调用
    19:20:27.900 [main] INFO RetryTest - 重试调用
    19:20:38.903 [main] INFO RetryTest - 重试调用
    19:20:49.909 [main] INFO RetryTest - 重试调用
    19:21:00.919 [main] INFO RetryTest - 重试调用
    19:21:00.921 [main] INFO RetryTest - Response(code=200, msg=处理成功)

可以看出，每次重试的时长根据斐波拉契数列递增，直到递增到每次10秒后就不再递增，并且实际调用在10次内成功。

重试的实现逻辑全部通过配置策略来实现，实现了代码的解耦，可读性显著提升。

下面是主要用到的重试与停止策略：

*  **retryIfException()** 表示抛出Exception异常及其子异常时重试
 *  **retryIfResult(response)** 可通过返回的response对象判断哪些返回码需要重试
 *  **withWaitStrategy(WaitStrategies)** 配置等待策略，常见的有：
    
     *  **WaitStrategies.fixedWait()** 固定等待n的时间
     *  **WaitStrategies.randomWait()** 等待随机时间后重试，可配置等待上限和等待下限
     *  **WaitStragegies.incrementingWait()** 按照等差数列增加等待时间
     *  **WaitStragegies.exponentialWait()** 按照指数级别增长等待时间
     *  **WaitStragegies.fibonacciWait()** 按照斐波拉契数列增加等待时间
 *  **withStopStrategy(StopStrategies)** 配置停止重试的策略，常见的有：
    
     *  **StopStrategies.neverStop()** 一直重试，直到返回成功为止
     *  **StopStrategies.stopAfterAttempt()** 重试多少次停止
     *  **StopStrategies.stopAfterDelay()** 一直重试直到成功或者超过设置的时长为止
 *  **withRetryListener()** 注册一个回调函数，当重试时记录重试失败的次数或者日志

### 小小收获 ###

可以看出，和自己实现的代码相比，使用Guava的retrying小工具实现的重试代码简洁很多，重用性相当高，代码API也设计得相当优雅。

我们在日常的代码编写中，也应该多学习开源项目的设计思路和实现，体会高手是如何对代码进行抽象与解耦，对自己的代码水平也是很好的提高与锻炼。

written by Ryan.Ou