详解重试框架Spring retry实践

spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断。这篇文章主要介绍了详解重试框架Spring retry实践，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

spring retry是从spring batch独立出来的一个能功能，主要实现了重试和熔断。对于重试是有场景限制的，不是什么场景都适合重试，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。远程调用超时、网络突然中断可以重试。在微服务治理框架中，通常都有自己的重试与超时配置，比如dubbo可以设置retries=1，timeout=500调用失败只重试1次，超过500ms调用仍未返回则调用失败。在spring retry中可以指定需要重试的异常类型，并设置每次重试的间隔以及如果重试失败是继续重试还是熔断（停止重试）。

设计与实现

RetryOperations定义重试的API，RetryTemplate是API的模板模式实现，实现了重试和熔断。提供的API如下：

1. public interface RetryOperations {
2. <T, E extends Throwable>T execute(RetryCallback<T, E>retryCallback) throws E;
3. }
4. // 其他API已省略

RetryCallback定义了需要执行重试的操作，定义好操作后，就是如何重试的问题了。RetryTemplate通过制定不同的重试策略来执行如何重试的逻辑。默认的重试策略是SimpleRetryPlicy，也就是会重试3次。重试第1次如果成功后面就不会继续重试了。那么如果3尺都重试失败了呢？流程结束或者返回兜底结果。要返回兜底结果需要配置RecoveyCallBack，从名字可以看出这是一个兜底回调接口，也就是重试失败后执行的逻辑。除了SimpleRetryPolicy还有其他重试策略，先来看下RetryPolicy接口：

1. public interface RetryPolicy extends Serializable {
2. boolean canRetry(RetryContext context);
3. RetryContext open(RetryContext parent);
4. void close(RetryContext context);
5. void registerThrowable(RetryContext context, Throwable throwable);
6. }

canRetry在每次重试的时候调用，是否可以继续重试的判断条件
open重试开始前调用，会创建一个重试上下文到RetryContext，保存重试的堆栈等信息
registerThrowable每次重试异常时调用（有异常会继续重试）

以SimpleRetryPolicy为例，当重试次数达到3（默认3次）停止重试，重试次数保存在重试上下文中。

提供如下重试策略实现：

 

1. NeverRetryPolicy：只允许调用RetryCallback一次，不允许重试
2. AlwaysRetryPolicy：允许无限重试，直到成功，此方式逻辑不当会导致死循环
3. SimpleRetryPolicy：固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
4. TimeoutRetryPolicy：超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
5. ExceptionClassifierRetryPolicy：设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
6. CircuitBreakerRetryPolicy：有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate
7. CompositeRetryPolicy：组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许重试即可以，悲观组合重试策略是指只要有一个策略不允许重试即可以，但不管哪种组合方式，组合中的每一个策略都会执行

重试回退策略，指的是每次重试是立即重试还是等待一段时间后重试。默认情况下是立即重试，如果需要配置等待一段时间后重试则需要指定回退策略BackoffRetryPolicy。BackoffRetryPolicy有如下实现：

 

1. NoBackOffPolicy：无退避算法策略，每次重试时立即重试
2. FixedBackOffPolicy：固定时间的退避策略，需设置参数sleeper和backOffPeriod，sleeper指定等待策略，默认是Thread.sleep，即线程休眠，backOffPeriod指定休眠时间，默认1秒
3. UniformRandomBackOffPolicy：随机时间退避策略，需设置sleeper、minBackOffPeriod和maxBackOffPeriod，该策略在[minBackOffPeriod,maxBackOffPeriod之间取一个随机休眠时间，minBackOffPeriod默认500毫秒，maxBackOffPeriod默认1500毫秒
4. ExponentialBackOffPolicy：指数退避策略，需设置参数sleeper、initialInterval、maxInterval和multiplier，initialInterval指定初始休眠时间，默认100毫秒，maxInterval指定最大休眠时间，默认30秒，multiplier指定乘数，即下一次休眠时间为当前休眠时间*multiplier
5. ExponentialRandomBackOffPolicy：随机指数退避策略，引入随机乘数可以实现随机乘数回退

有状态重试 OR 无状态重试

所谓无状态重试是指重试在一个线程上下文中完成的重试，反之不在一个线程上下文完成重试的就是有状态重试。之前的SimpleRetryPolicy就属于无状态重试，因为重试是在一个循环中完成的。那么什么会后会出现或者说需要有状态重试呢？通常有两种情况：事务回滚和熔断。

数据库操作异常DataAccessException，不能执行重试，而如果抛出其他异常可以重试。

熔断的意思不在当前循环中处理重试，而是全局重试模式（不是线程上下文）。熔断会跳出循环，那么必然会丢失线程上下文的堆栈信息。那么肯定需要一种“全局模式”保存这种信息，目前的实现放在一个cache（map实现的）中，下次从缓存中获取就能继续重试了。

Quick Start

在需要执行重试的类上使用@EnableRetry，如果设置了proxyTargetClass=true这使用CGLIB动态代理：

1. @Configuration
2. @EnableRetry(proxyTargetClass = true)
3. @Component
4. public class RetryExamples {
5.  
6. }

基于最大重试次数策略的重试，如果重试了3次仍然抛出异常则停止重试，执行兜底回调，所以最后的输出结果是Integer.MAX_VALUE：

1. private void retryExample3() throws Exception {
2. RetryTemplate retryTemplate = new RetryTemplate();
3.  
4. SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
5. simpleRetryPolicy.setMaxAttempts(3);
6.  
7. retryTemplate.setRetryPolicy(simpleRetryPolicy);
8.  
9. Integer result = retryTemplate.execute(new RetryCallback<Integer, Exception>() {
10. int i = 0;
11.  
12. // 重试操作
13. @Override
14. public Integer doWithRetry(RetryContext retryContext) throws Exception {
15. log.info("retry count: {}", retryContext.getRetryCount());
16. return len(i++);
17. }
18. }, new RecoveryCallback<Integer>() { //兜底回调
19. @Override
20. public Integer recover(RetryContext retryContext) throws Exception {
21. log.info("after retry: {}, recovery method called!", retryContext.getRetryCount());
22. return Integer.MAX_VALUE;
23. }
24. });
25. log.info("final result: {}", result);
26. }
27.  
28. private int len(int i) throws Exception {
29. if (i < 10) throw new Exception(i + " le 10");
30. return i;
31. }

下面介绍如何使用熔断重试策略模式（CircuitBreakerRetryPolicy），需要设置如下三个参数：

1. delegate：传入RetryPolicy（每个RetryPolicy实现都有自己的重试策略实现），是真正判断是否重试的策略，当重试失败时，则执行熔断策略
2. openTimeout：openWindow，配置熔断器电路打开的超时时间，当超过openTimeout之后熔断器电路变成半打开状态（只要有一次重试成功，则闭合电路）
3. resetTimeout：timeout，配置重置熔断器重新闭合的超时时间

断路器开闭实现判断：

 

1. 当重试失败，且在熔断器打开时间窗口[0,openWindow) 内，立即熔断
2. 当重试失败，且超过timeout，熔断器电路重新闭合
3. 在熔断器半打开状态[openWindow, timeout] 时，只要重试成功则重置上下文，断路器闭合

测试代码如下：

1. RetryTemplate template = new RetryTemplate();
2. CircuitBreakerRetryPolicy retryPolicy =
3. new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(3));
4. retryPolicy.setOpenTimeout(5000);
5. retryPolicy.setResetTimeout(20000);
6. template.setRetryPolicy(retryPolicy);
7.  
8. for (int i = 0; i < 10; i++) {
9. //Thread.sleep(100);
10. try {
11. Object key = "circuit";
12. boolean isForceRefresh = false;
13. RetryState state = new DefaultRetryState(key, isForceRefresh);
14. String result = template.execute(new RetryCallback<String, RuntimeException>() {
15. @Override
16. public String doWithRetry(RetryContext context) throws RuntimeException {
17. log.info("retry count: {}", context.getRetryCount());
18. throw new RuntimeException("timeout");
19. }
20. }, new RecoveryCallback<String>() {
21. @Override
22. public String recover(RetryContext context) throws Exception {
23. return "default";
24. }
25. }, state);
26. log.info("result: {}", result);
27. } catch (Exception e) {
28. System.out.println(e);
29. }
30. }

这里由于设置了isForceRefresh = false，则key = "circuit"的值（也就是RetryContext）会从缓存中获取，所以当重试失败且满足this.time < this.openWindow发生熔断的时候，后面仍然可以继续已全局模式实现重试（拿到的RetryContext是同一个）。

注解开发

如果每次有重试需求的时候都写一个RetryTemplate太臃肿了，使用注解可以大大简化开发，减少重复代码。下面是一个使用注解实现的最大重试策略的重试：

1. @Retryable(value = SQLDataException.class, backoff = @Backoff(value = 0L))
2. public String service3() throws SQLDataException {
3. log.info("service3 open");
4. throw new SQLDataException();
5. }
6.  
7. @Recover
8. public String recover(SQLDataException ne) {
9. return "SQLDataException recover";
10. }

注解包括：

@EnableRetry

@Retryable

@Recover

@Backoff

@CircuitBreaker

@EnableRetry：能否重试，proxyTargetClass属性为true时（默认false），使用CGLIB代理

@Retryable：注解需要被重试的方法

1. include 指定处理的异常类。默认为空
2. exclude指定不需要处理的异常。默认为空
3. vaue指定要重试的异常。默认为空
4. maxAttempts 最大重试次数。默认3次
5. backoff 重试等待策略。默认使用@Backoff注解

@Backoff：重试回退策略（立即重试还是等待一会再重试）

1. 不设置参数时，默认使用FixedBackOffPolicy，重试等待1000ms
2. 只设置delay()属性时，使用FixedBackOffPolicy，重试等待指定的毫秒数
3. 当设置delay()和maxDealy()属性时，重试等待在这两个值之间均态分布
4. 使用delay()，maxDealy()和multiplier()属性时，使用ExponentialBackOffPolicy
5. 当设置multiplier()属性不等于0时，同时也设置了random()属性时，使用ExponentialRandomBackOffPolicy

@Recover: 用于方法。用于@Retryable失败时的“兜底”处理方法。 @Recover注释的方法必须要与@Retryable注解的方法“签名”保持一致，第一入参为要重试的异常，其他参数与@Retryable保持一致，返回值也要一样，否则无法执行！

@CircuitBreaker：用于方法，实现熔断模式。

1. include 指定处理的异常类。默认为空
2. exclude指定不需要处理的异常。默认为空
3. vaue指定要重试的异常。默认为空
4. maxAttempts 最大重试次数。默认3次
5. openTimeout 配置熔断器打开的超时时间，默认5s，当超过openTimeout之后熔断器电路变成半打开状态（只要有一次重试成功，则闭合电路）
6. resetTimeout 配置熔断器重新闭合的超时时间，默认20s，超过这个时间断路器关闭

更多的例子欢迎到我的Github(https://github.com/happyxiaofan/springboot-learning-example) star。谢谢

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。

本文标题: 详解重试框架Spring retry实践

本文地址: http://www.cppcns.com/ruanjian/java/227353.html