【SpringBoot】spring-retry(重试机制)

古城微笑少年丶 2022-12-23 09:32 641阅读 0赞

### 文章目录 ###

*   *  概述
     *  一.简单实现重试
     *   *  
     *  二.声明式使用Spring-Retry
     *   *  2.1.如何使用
         *  2.2.常用注解
         *  2.3.注意事项
     *  三.编程式使用Spring-Retry
     *   *  3.1.核心类
         *  3.2.RetryOperations
         *  3.3.RetryPolicy(重试策略)
         *  3.4.BackOffPolicy(重试回退(等待)策略)
         *  3.5.RetryTemplate主要流程实现源码
         *   *  3.5.1.RetryTemplate.doExecute()方法
             *  3.5.2.如何使用RetryTemplate
         *  3.6.状态重试 OR 无状态重试
         *   *  3.6.1.无状态重试
             *  3.6.2.有状态重试(回滚/熔断)
             *  3.6.3.通过RetryListener实现拦截器模式
         *  3.7.案例实践
         *   *  3.7.0.公用代码
             *  3.7.1.SimpleRetryPolicy固定次数重试策略
             *  3.7.2.AlwaysRetryPolicy无限重试策略
             *  3.7.3.TimeoutRetryPolicy超时时间重试策略
             *  3.7.4.根据返回结果值实现重试
             *  3.7.5.启用熔断器重试策略
         *  3.8.spring-retry1.3 以上构建RetryTemplate
         *  3.9.较常见的重试技术实现

> **retry**: 英`/ˌriːˈtraɪ/` 美 `/ˌriːˈtraɪ/`

## 概述 ##

[github地址 ][github_]

[官网地址][Link 1]

*  在调用第三方接口或者使用Mq时，会出现网络抖动，连接超时等网络异常，所以需要重试。
    
    > 网络抖动：标识一个网络的稳定性。抖动越小，网络越稳定。
 *  Spring Retry是从`Spring Batch 2.2.0`版本独立出来的一个功能，主要实现了`重试和熔断`。
 *  在 Spring Retry需要`指定触发重试的异常类型`，并设置`每次重试的间隔`以及`如果重试失败是继续重试还是熔断（停止重试）。`
    
    > 对于`重试是有场景限制的，不是什么场景都适合重试`，比如参数校验不合法、写操作等（要考虑写是否幂等）都不适合重试。远程调用超时、网络突然中断可以重试
    > 
    >  *  在微服务治理框架中，通常都有自己的重试与超时配置，比如dubbo可以设置retries=1，timeout=500调用失败只重试1次，超过500ms调用仍未返回则调用失败。

## 一.简单实现重试 ##

1.  异常捕获
2.  循环重试(包括：重试次数，重试间隔)

public class TestRetry { 
        //最大重试次数
        private static final Integer tryTimes = 6;
        //重试间隔时间单位秒
        private static final Integer intervalTime = 1;
     
        public static void main(String[] args) throws InterruptedException { 
            boolean flag = TestRetry.retryBuss();
            System.out.println("最终执行结果:" + (flag ? "成功" : "失败"));
        }
     
        public static boolean retryBuss() throws InterruptedException { 
            Integer retryNum = 1;
            boolean flag = false;
            while (retryNum <= tryTimes) { 
                try { 
                    flag = execute(retryNum);
                    if (flag) { 
                        System.out.println("第" + retryNum + "次执行成功!!!");
                        break;
                    }
                    System.err.println("第" + retryNum + "次执行失败...");
                    retryNum++;
                } catch (Exception e) { 
                    retryNum++;
                    TimeUnit.SECONDS.sleep(intervalTime);
                    continue;
                }
            }
     
            return flag;
        }
     
        /** * 具体业务 * @param retryNum * @return */
        private static boolean execute(int retryNum) { 
            Random random = new Random();
            int a = random.nextInt(10);
            boolean flag = true;
            try { 
                if (a != 6) { 
                    flag = false;
                    throw new RuntimeException();
                }
            } catch (Exception e) { //这里捕获异常只是为了能,返回flag的结果
            }
            return flag;
        }
    }

失败情况  
![在这里插入图片描述][20201127095415616.png_pic_center]

成功情况  
![在这里插入图片描述][2020112709553274.png_pic_center]

###  ###

## 二.声明式使用Spring-Retry ##

### 2.1.如何使用 ###

**1.引入依赖**

<dependency>
                <groupId>org.springframework.retry</groupId>
                <artifactId>spring-retry</artifactId>
            </dependency>
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
            </dependency>

**2.配置类**

*  要使用`@EnabelRetry`开启重试才行，写在`配置类或者启动类`上都是可以的

@Configuration
    @EnableRetry
    public class RetryConfiguration { 
        @Bean
        public PayService payService() { 
            return new PayService();
        }
    }

**3.实现类**

*  服务类一般写主要逻辑,在需要重试的方法上面使用`@Retryable`

//@Service
    @Slf4j
    public class PayService { 
        private final int totalNum = 100000;
        
        @Retryable(value = { Exception.class}, maxAttempts = 3, backoff = @Backoff(delay = 2000, multiplier = 1.5))
        public int minGoodsNum(int num) { 
            log.info("减库存开始=>" + LocalTime.now());
            log.info("库存=>" + totalNum);
            if (num <= 0) { 
                throw new IllegalArgumentException("数量不对");
            }
            log.info("减库存执行结束=>" + LocalTime.now());
            return totalNum - num;
        }
    
        /** * 使用@Recover注解，当重试次数达到设置的次数的时候，还是失败抛出异常，执行的回调函数。 */
        @Recover
        public int recover(Exception e) { 
            log.warn("减库存失败！！！" + LocalTime.now());
            //记日志到数据库
            return totalNum;
        }
    }

测试代码

@RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
    public class RetryTest { 
        @Autowired
        private PayService payService;
    
        /** * 应该使用 org.junit.Test 才是正确的 */
        @Test
        public void minGoodsNum() { 
            payService.minGoodsNum(-1);
        }
    }

结果  
![在这里插入图片描述][20201124142043897.png_pic_center]

`@Retryable`修饰的`minGoodsNum()`方法，如果调用期间报了`异常`，那么它将进行重试3次（默认三次），如果超过最大重试次数，则执行@Retryable修饰的`recover()`方法，

> @Retryable注解有各种配置，用于包含和排除异常类型、限制重试次数和回退策略。

### 2.2.常用注解 ###

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

**@Retryable：标记当前方法会使用`重试机制`**

>  *  value：指定抛出那些异常才会触发重试(`可以配置多个异常类型`) 默认为空
>  *  include：`就是value`，`默认为空`，当exclude也为空时，默认所有异常都可以触发重试
>  *  exclude：指定那些异常不触发重试(`可以配置多个异常类型`)，默认为空
>  *  maxAttempts：最大重试次数，`默认3次`（**包括第一次调用）**
>  *  backoff：重试等待策略 `默认使用@Backoff注解`  
>     ![在这里插入图片描述][20201124142711248.png_pic_center]

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

>  *  value: 重试的间隔时间默认为`1000L`，我们设置为`2000L`
>  *  delay：重试的间隔时间,`就是value`
>  *  maxDelay：重试次数之间的最大时间间隔，`默认为0`，如果小于delay的设置，则`默认为30000L`
>  *  multiplier：delay时间的间隔倍数，`默认为0，表示固定暂停1秒后进行重试`，如果把multiplier设置为1.5，则第一次重试为2秒，第二次为3秒，第三次为4.5秒。  
>     .

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

**@Recover标记方法为@Retryable失败时的`“兜底”处理方法`**

>  *  传参与@Retryable的配置的value必须一样
>  *  @Recover标记方法必须要`与@Retryable注解的方法“形参”保持一致`，`第一入参为要重试的异常(一定要是@Retryable方法里抛出的异常或者异常父类)`，**其他参数与@Retryable保持一致，`返回值`也要一样，否则无法执行！**

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

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

### 2.3.注意事项 ###

*  使用了`@Retryable注解`的方法`直接实例化`调用不会触发重试，要先将`实现类实例化到Spring容器`中，然后通过`注入`等方式使用
 *  **Spring-Retry是通过捕获异常的方式来触发重试的**,@Retryable标注方法产生的异常`不能使用try-catch捕获`，要在方法上抛出异常，不然不会触发重试

**重试原则**

1.  查询可以进行重试
2.  写操作要慎重，除非业务方支持重入

## 三.编程式使用Spring-Retry ##

### 3.1.核心类 ###

*  **RetryOperations** : 定义了“重试”的基本框架（模板），要求传入RetryCallback，可选传入RecoveryCallback；
 *  **RetryCallback**: 封装你需要重试的业务逻辑；
 *  **RecoverCallback**：封装在多次重试都失败后"兜底"的业务逻辑；
 *  **RetryTemplate**: `RetryOperations的具体实现`，组合了RetryListener\[\]，BackOffPolicy，RetryPolicy。
 *  **RetryContext**: `重试下的上下文`，可用于在多次Retry或者Retry 和Recover之间传递参数或状态；
 *  **RetryPolicy** : `重试的策略`，可以固定次数的重试，也可以是指定超时时间进行重试；
 *  **BackOffPolicy**: `重试的等待策略`，在业务逻辑执行发生异常时。如果需要重试，我们可能需要等一段时间(可能服务器过于繁忙，如果一直不间隔重试可能拖垮服务器)，当然这段时间可以是 0，也可以是固定的，可以是随机的
 *  **RetryListener**：典型的“监听者”，在重试的不同阶段通知“监听者”；

### 3.2.RetryOperations ###

**RetryOperations是重试的顶级接口：**

*  **RetryOperations**: 统一定义了重试的API( `定义了实现“重试”的基本框架（模板）`)
 *  **RetryTemplate**: 是`RetryOperations`的`模板模式实现`，实现了重试和熔断etryTemplate将重试、提供健壮和不易出错的API供大家使用。

提供的API如下：  
![在这里插入图片描述][20201126155341770.png_pic_center]

public interface RetryOperations { 
        <T, E extends Throwable> T execute(RetryCallback<T, E> var1) throws E;
    
        <T, E extends Throwable> T execute(RetryCallback<T, E> var1, RecoveryCallback<T> var2) throws E;
    
        <T, E extends Throwable> T execute(RetryCallback<T, E> var1, RetryState var2) throws E, ExhaustedRetryException;
    
        <T, E extends Throwable> T execute(RetryCallback<T, E> var1, RecoveryCallback<T> var2, RetryState var3) throws E;
    }

*  **RetryCallback**: `编写需要执行重试的业务逻辑`，定义好业务逻辑后，就是如何重试的问题了。
 *  **RetryTemplate**: 通过设置不同的重试策略来控制如何进行重试。`默认的重试策略是SimpleRetryPlicy(会重试3次)`
    
    > 第1次重试如果成功后面就不会继续重试了。如果3次都重试失败了流程结束或者返回兜底结果。而返回兜底结果需要配置`RecoveyCallBack`
 *  **RecoveyCallBack**：从名字可以看出这是一个兜底回调接口，`也就是重试失败后执行的逻辑。`
    
    > 当重试超过最大重试时间或最大重试次数后可以调用`RecoveryCallback进行恢复`，比如`返回假数据或托底数据。`

### 3.3.RetryPolicy(重试策略) ###

**RetryPolicy**: 重试策略的顶级接口  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]

public interface RetryPolicy extends Serializable { 
        boolean canRetry(RetryContext var1);
    
        RetryContext open(RetryContext var1);
    
        void close(RetryContext var1);
    
        void registerThrowable(RetryContext var1, Throwable var2);
    }

方法说明：

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

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

**RetryPolicy提供了如下策略实现：**

*  **NeverRetryPolicy**：只允许`调用RetryCallback一次`，不允许重试
 *  **AlwaysRetryPolicy**：允许`无限重试`，直到成功，此方式逻辑不当会导致`死循环`
 *  **SimpleRetryPolicy**：`固定次数`重试策略，默认重试最大次数为`3次`，**RetryTemplate**默认使用的策略
 *  **TimeoutRetryPolicy**：`超时时间`重试策略，默认超时时间为`1秒`，在指定的超时时间内允许重试
 *  **ExceptionClassifierRetryPolicy**：设置`不同异常`的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
 *  **CircuitBreakerRetryPolicy**：有`熔断功能`的重试策略，需设置3个参数`openTimeout、resetTimeout和delegate`
    
    > ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 1]
    > 
    >  *  delegate：真正执行的重试策略，由`构造方法传入`，当重试失败时，则执行熔断策略，`默认SimpleRetryPolicy策略`
    >  *  openTimeout：openWindow，熔断器电路打开的超时时间，当超过openTimeout之后熔断器电路变成半打开状态（主要有一次重试成功，则闭合电路），`默认5000毫秒`
    >  *  resetTimeout：timeout，重置熔断器重新闭合的超时时间。`默认20000毫秒`
 *  **CompositeRetryPolicy**：`组合重试`策略，有`两种`组合方式
    
    > 乐观组合重试策略：指只要有一个策略允许重试即可以  
    > 悲观组合重试策略：指只要有一个策略不允许重试即可以
    > 
    >  *  `但不管哪种组合方式，组合中的每一个策略都会执行`

### 3.4.BackOffPolicy(重试回退(等待)策略) ###

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

> 比如是网络错误，立即重试将导致立即失败，最好等待一小段时间后重试，还要防止很多服务同时重试导致DDos。

*  **BackOffPolicy**是回退策略的顶级接口

**BackOffPolicy 提供了如下策略实现**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 2]

*  **NoBackOffPolicy**：`无等待`策略，每次重试时立即重试
 *  **FixedBackOffPolicy**：`固定时间`的等待策略
    
    > 需设置参数`sleeper和backOffPeriod`
    > 
    >  *  sleeper指定等待策略，默认是Thread.sleep，即线程休眠
    >  *  backOffPeriod指定休眠时间，默认1000毫秒
 *  **UniformRandomBackOffPolicy**：`随机时间`回退策略
    
    > 需设置`sleeper、minBackOffPeriod和maxBackOffPeriod`  
    > 该策略在\[`minBackOffPeriod,maxBackOffPeriod`之间取一个随机休眠时间。
    > 
    >  *  sleeper指定等待策略，默认是Thread.sleep，即线程休眠
    >  *  minBackOffPeriod 默认500毫秒
    >  *  maxBackOffPeriod 默认1500毫秒
 *  **ExponentialBackOffPolicy**：`倍数`等待策略
    
    > 需设置参数`sleeper、initialInterval、maxInterval和multiplier`
    > 
    >  *  sleeper指定等待策略，默认是Thread.sleep，即线程休眠
    >  *  initialInterval指定初始休眠时间，默认100毫秒
    >  *  maxInterval指定最大休眠时间，默认30秒
    >  *  multiplier指定乘数，即下一次休眠时间为 `当前休眠时间*multiplier`,之前说过固定倍数可能会引起很多服务同时重试导致DDos，使用随机休眠时间来避免这种情况。
 *  **ExponentialRandomBackOffPolicy**：`随机倍数`等待策略，引入随机乘数可以实现随机乘数回退

### 3.5.RetryTemplate主要流程实现源码 ###

RetryTemplate类是对 `RetryOperations的具体实现`，组合了`RetryListener[]，BackOffPolicy，RetryPolicy`。

#### 3.5.1.RetryTemplate.doExecute()方法 ####

protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback,
          RecoveryCallback<T> recoveryCallback, RetryState state)
          throws E, ExhaustedRetryException { 
       //重试策略
       RetryPolicy retryPolicy = this.retryPolicy;
       //退避策略
       BackOffPolicy backOffPolicy = this.backOffPolicy;
       //重试上下文，当前重试次数等都记录在上下文中
       RetryContext context = open(retryPolicy, state);
       try { 
          //拦截器模式，执行RetryListener#open
          boolean running = doOpenInterceptors(retryCallback, context);
          //判断是否可以重试执行
          while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) { 
             try { //执行RetryCallback回调
                return retryCallback.doWithRetry(context);
             } catch (Throwable e) { //异常时，要进行下一次重试准备
                //遇到异常后，注册该异常的失败次数
                registerThrowable(retryPolicy, state, context, e);
                //执行RetryListener#onError
                doOnErrorInterceptors(retryCallback, context, e);
                //如果可以重试，执行退避算法，比如休眠一小段时间后再重试
                if (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) { 
                   backOffPolicy.backOff(backOffContext);
                }
                //在有状态重试时，如果是需要执行回滚操作的异常，则立即抛出异常
                //shouldRethrow方法只有一行代码: state != null && state.rollbackFor(context.getLastThrowable())
                if (shouldRethrow(retryPolicy, context, state)) { 
                   throw RetryTemplate.<E>wrapIfNecessary(e);
                }
             }
             //如果是有状态重试，且有GLOBAL_STATE属性，则立即跳出重试终止；当抛出的异常是非需要执行回滚操作的异常时，
             //才会执行到此处，CircuitBreakerRetryPolicy会在此跳出循环；
             if (state != null && context.hasAttribute(GLOBAL_STATE)) { 
                break;
             }
          }
          //重试失败后，如果有RecoveryCallback，则执行此回调，否则抛出异常
          return handleRetryExhausted(recoveryCallback, context, state);
       } catch (Throwable e) { 
          throw RetryTemplate.<E>wrapIfNecessary(e);
       } finally { 
          //清理环境
          close(retryPolicy, context, state, lastException == null || exhausted);
          //执行RetryListener#close，比如统计重试信息
          doCloseInterceptors(retryCallback, context, lastException);
       }
    }

#### 3.5.2.如何使用RetryTemplate ####

@Test
        public void testSimple() throws Exception { 
            @Data
            class Foo { 
                private String id;
            }
    
            RetryTemplate template = new RetryTemplate();
            //超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
            TimeoutRetryPolicy policy = new TimeoutRetryPolicy();
            policy.setTimeout(3000L);
    
            template.setRetryPolicy(policy);
            Foo result = template.execute(
                    //可能触发重试的业务逻辑
                    new RetryCallback<Foo, Exception>() { 
                        @Override
                        public Foo doWithRetry(RetryContext context) { 
                            try { 
                                System.out.println("调用百度接口。。。。");
                                TimeUnit.MILLISECONDS.sleep(500);
                                throw new RuntimeException("调用百度接口超时");
                            } catch (InterruptedException e) { 
                                //e.printStackTrace();
                            }
                            return new Foo();
                        }
    
                    },
                    //重试耗尽后的回调,配置了RecoveryCallback,超出重试次数后不会抛出异常,而是执行回调里的代码
                    new RecoveryCallback<Foo>() { //可以没有RecoveryCallback,超出重试次数后依然会抛出异常
                        @Override
                        public Foo recover(RetryContext context) throws Exception { 
                            System.out.println("调用百度接口。。。recover");
                            return new Foo();
                        }
                    });
    
            System.out.println("result=>" + result);
        }

我们模拟调用百度并将结果返回给用户，如果该调用失败，则重试该调用，直到达到超时为止。

**如果不使用RecoveryCallback,当重试失败后，当重试失败后，抛出异常**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 3]  
**如果使用RecoveryCallback,，当重试失败后，执行RecoveryCallback**  
![在这里插入图片描述][20201126110936500.png_pic_center]

### 3.6.状态重试 OR 无状态重试 ###

#### 3.6.1.无状态重试 ####

**无状态重试**： 是在一个循环中执行完重试策略，即重试上下文保持在一个线程上下文中，在一次调用中进行完整的重试策略判断。

*非常简单的情况，如`远程调用某个查询方法`时是最常见的无状态重试。* `SimpleRetryPolicy就属于无状态重试`，因为重试是在`一个循环`中完成的。

public static void main(String[] args) { 
            RetryTemplate template = new RetryTemplate();
            //重试策略：次数重试策略
            RetryPolicy retryPolicy = new SimpleRetryPolicy(3);
            template.setRetryPolicy(retryPolicy);
    
            //退避策略：倍数回退策略
            ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
            backOffPolicy.setInitialInterval(100);
            backOffPolicy.setMaxInterval(3000);
            backOffPolicy.setMultiplier(2);
            backOffPolicy.setSleeper(new ThreadWaitSleeper());
            template.setBackOffPolicy(backOffPolicy);
    
    
            String resul = template.execute(
                    new RetryCallback<String, RuntimeException>() { 
                        @Override
                        public String doWithRetry(RetryContext context) throws RuntimeException { 
                            System.out.println("retry count:" + context.getRetryCount());
                            throw new RuntimeException("timeout");
                        }
                    },
                    new RecoveryCallback<String>() { 
                        @Override
                        public String recover(RetryContext context) throws Exception { 
                            return "default";
                        }
                    });
            System.out.println("result=>" + result);
        }

![在这里插入图片描述][20201126144418370.png_pic_center]

#### 3.6.2.有状态重试(回滚/熔断) ####

**有状态重试**：就是`不在一个线程上下文`完成重试，有`2种场景`需要使用有状态重试，`事务操作需要回滚`或者`熔断器模式`。

*  在事务操作需要回滚场景时，当整个操作中抛出的是`数据库异常DataAccessException`，则不能进行`重试`需要`回滚`，而抛出其他异常则可以进行重试，可以通过`RetryState`实现：

@Test
        public void retryState () { 
            RetryTemplate template = new RetryTemplate();
            //重试策略：次数重试策略
            RetryPolicy retryPolicy = new SimpleRetryPolicy(3);
            template.setRetryPolicy(retryPolicy);
    
            //当前状态的名称，当把状态放入缓存时，通过该key查询获取
            Object key = "mykey";
            //是否每次都重新生成上下文还是从缓存中查询，即全局模式（如熔断器策略时从缓存中查询）
            boolean isForceRefresh = true;
            //对DataAccessException进行回滚
            BinaryExceptionClassifier rollbackClassifier = new BinaryExceptionClassifier(Collections.<Class<? extends Throwable>>singleton(DataAccessException.class));
    
            RetryState state = new DefaultRetryState(key, isForceRefresh, rollbackClassifier);
    
            String result = template.execute(
                    new RetryCallback<String, RuntimeException>() { 
                        @Override
                        public String doWithRetry(RetryContext context) throws RuntimeException { 
                            System.out.println("retry count:" + context.getRetryCount());
                            throw new TypeMismatchDataAccessException("");
                        }
                    },
                    new RecoveryCallback<String>() { 
                        @Override
                        public String recover(RetryContext context) throws Exception { 
                            System.out.println("recovery count:" + context.getRetryCount());
                            return "default";
                        }
                    }, state);
        }

执行结果:报异常,没有进RecoveryCallback中

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 4]  
RetryTemplate中在有状态重试时，执行`RecoveryCallback`时`报异常`

> （截图为 RetryTemplate主要流程实现doExecute方法的源码）  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 5]

什么是熔断?

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

**熔断器场景**

*  在有状态重试时，且是全局模式时，跳出重试循环

测试代码

@Test
        public void circuitBreakerRetryPolicy () { 
            RetryTemplate template = new RetryTemplate();
            //传入RetryPolicy（每个RetryPolicy实现都有自己的重试策略实现），是真正判断是否重试的策略，当重试失败时，则执行熔断策略；
            CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(3));
            //熔断器电路打开的超时时间
            retryPolicy.setOpenTimeout(5000);
            //重置熔断器重新闭合的超时时间
            retryPolicy.setResetTimeout(20000);
            template.setRetryPolicy(retryPolicy);
    
            for (int i = 0; i < 10; i++) { 
                try { 
                    Object key = "circuit";
                    boolean isForceRefresh = false;
                    RetryState state = new DefaultRetryState(key, isForceRefresh);
    
                    String result = template.execute(
                    		//重试逻辑
                            new RetryCallback<String, RuntimeException>() { 
                                @Override
                                public String doWithRetry(RetryContext context) throws RuntimeException { 
                                    System.out.println("retry count:" + context.getRetryCount());
                                    throw new RuntimeException("timeout");
                                }
                            },
                            //重试失败兜底
                            new RecoveryCallback<String>() { 
                                @Override
                                public String recover(RetryContext context) throws Exception { 
                                    return "default";
                                }
                            }, state);
                    System.out.println(result);
                } catch (Exception e) { 
                    System.out.println("catch=>" + e.getMessage());
                }
            }
        }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 6]  
为什么说是全局模式呢？

*  我们配置了`isForceRefresh为false`，则在获取上下文时是根据`key “circuit”从缓存中获取`，从而拿到`同一个上下文`。  
    ![在这里插入图片描述][20201126151320777.png_pic_center]  
    如下RetryTemplate源码说明在`有状态模式下，不会在循环中进行重试，会跳出循环`  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 7]

熔断器策略**CircuitBreakerRetryPolicy**需要配置三个参数：

*  `delegate`：当前重试策略，由`构造方法传入`，当重试失败时，则执行熔断策略
 *  `openTimeout`：熔断器电\`路打开的超时时间，当超过openTimeout之后熔断器电路变成半打开状态（主要有一次重试成功，则闭合电路）
    
    > `源码的openWindow属性`
 *  `resetTimeout`：重置熔断器重新闭合的超时时间。
    
    > `源码的timeOut属性`

**CircuitBreakerRetryPolicy.isOpen()源码**

public boolean isOpen() { 
       long time = System.currentTimeMillis() - this.start;
       boolean retryable = this.policy.canRetry(this.context);
       if (!retryable) { //重试失败
          //在重置熔断器超时后，熔断器器电路闭合，重置上下文
          if (time > this.timeout) { 
             this.context = createDelegateContext(policy, getParent());
             this.start = System.currentTimeMillis();
             retryable = this.policy.canRetry(this.context);
          } else if (time < this.openWindow) { 
             //当在熔断器打开状态时，熔断器电路打开，立即熔断
             if ((Boolean) getAttribute(CIRCUIT_OPEN) == false) { 
                setAttribute(CIRCUIT_OPEN, true);
             }
             this.start = System.currentTimeMillis();
             return true;
          }
       } else { //重试成功
          //在熔断器电路半打开状态时，断路器电路闭合，重置上下文
          if (time > this.openWindow) { 
             this.start = System.currentTimeMillis();
             this.context = createDelegateContext(policy, getParent());
          }
       }
       setAttribute(CIRCUIT_OPEN, !retryable);
       return !retryable;
    }

从如上代码可看出spring-retry的熔断策略相对简单：

*  当重试失败，且在熔断器打开时间窗口\[0,openWindow) 内，立即熔断；
 *  当重试失败，且在指定超时时间后(>timeout)，熔断器电路重新闭合；
 *  在熔断器半打开状态\[openWindow, timeout\] 时，只要重试成功则重置上下文，断路器闭合。

**使用CircuitBreakerRetryPolicy注意事项**

*  CircuitBreakerRetryPolicy的`delegate(重试策略)`应该配置`基于次数的SimpleRetryPolicy`或者`基于超时的TimeoutRetryPolicy策略`，且策略都是`全局模式`，而非局部模式，所以*要注意`次数或超时`的配置合理性*。

比如`SimpleRetryPolicy配置为3次，openWindow=5s，timeout=20s`，我们来CircuitBreakerRetryPolicy的极端情况。

#### 3.6.3.通过RetryListener实现拦截器模式 ####

Spring-retry通过`RetryListener`实现拦截器模式，`默认`提供了`StatisticsListener`实现`重试操作统计分析数据`。

*  要给RetryCallback定义一个name如“method.key”，从而查询该RetryCallback的`统计分析数据`。

@Test
        public void analyses() { 
            RetryTemplate template = new RetryTemplate();
            DefaultStatisticsRepository repository = new DefaultStatisticsRepository();
            StatisticsListener listener = new StatisticsListener(repository);
            template.setListeners(new RetryListener[]{ listener});
         
            for (int i = 0; i < 10; i++) { 
                String result = template.execute(new RetryCallback<String, RuntimeException>() { 
                    @Override
                    public String doWithRetry(RetryContext context) throws RuntimeException { 
                        context.setAttribute(RetryContext.NAME, "method.key");
                        return "ok";
                    }
                });
            }
            
            RetryStatistics statistics = repository.findOne("method.key");
            System.out.println(statistics);
        }

执行结果  
![在这里插入图片描述][20201126153531641.png_pic_center]

### 3.7.案例实践 ###

**场景描述：** num作为计数器，如果num小于5则抛出异常，num会进行自增一操作，直到等于5方正常返回，否则根据重试策略进行重试操作，如果直到最后一直未重试成功，则返回Integer最大值。在重试上下文中添加一个value变量，后续通过其值实现根据返回值判断重试应用。最后打印最终的返回值。  
公共方法

#### 3.7.0.公用代码 ####

下面案例中调用的run方法就是下面这个

/** * 运行重试方法 * * @param retryTemplate * @throws Exception */
        public void run(RetryTemplate retryTemplate) throws Exception { 
            Integer result = retryTemplate.execute(
                    new RetryCallback<Integer, Exception>() { 
                        int i = 0;
    
                        // 重试操作
                        @Override
                        public Integer doWithRetry(RetryContext retryContext) throws Exception { 
                            retryContext.setAttribute("value", i);
                            log.info("重试 {} 次.", retryContext.getRetryCount());
                            return checkLen(i++);
                        }
                    },
                    new RecoveryCallback<Integer>() { //兜底回调
                        @Override
                        public Integer recover(RetryContext retryContext) throws Exception { 
                            log.info("重试{}次后，调用兜底方法", retryContext.getRetryCount());
                            return Integer.MAX_VALUE;
                        }
    
                    });
    
            log.info("最终结果: {}", result);
        }
    
    
        /** * 根据i判断是否抛出异常 * * @param num * @return * @throws Exception */
        public int checkLen(int num) throws Exception { 
            //小于5抛出异常
            if (num < 5) throw new Exception(num + " le 5");
            //否则正常返回
            return num;
        }

#### 3.7.1.SimpleRetryPolicy固定次数重试策略 ####

@Test
        public void retryFixTimes() throws Exception { 
            //重试模板
            RetryTemplate retryTemplate = new RetryTemplate();
            //简单重试策略
            SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();
            //最大重试次数3次
            simpleRetryPolicy.setMaxAttempts(3);
            //模板设置重试策略
            retryTemplate.setRetryPolicy(simpleRetryPolicy);
            //开始执行- 超过3次最大重试次数，触发了recoveryCall，并返回Integer最大值。
            run(retryTemplate);
        }

执行结果  
![在这里插入图片描述][20201127113714357.png_pic_center]  
超过3次最大重试次数，触发了recoveryCall，并返回Integer最大值

#### 3.7.2.AlwaysRetryPolicy无限重试策略 ####

AlwaysRetryPolicy 允许无限重试，直到成功，此方式逻辑不当会导致死循环

@Test
        public void retryAlwaysTimes() throws Exception { 
            //重试模板
            RetryTemplate retryTemplate = new RetryTemplate();
            //设置为无限重试策略
            retryTemplate.setRetryPolicy(new AlwaysRetryPolicy());
            //开始执行-直到i等于5则正常返回，之前将实现无限重试。
            run(retryTemplate);
        }

执行结果  
![在这里插入图片描述][20201127113824216.png_pic_center]  
直到i等于5则正常返回，之前将实现无限重试。

#### 3.7.3.TimeoutRetryPolicy超时时间重试策略 ####

@Test
        public void retryTimeout() throws Exception { 
            //重试模板
            RetryTemplate retryTemplate = new RetryTemplate();
    
            TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();
            //超时时间为 1000 毫秒
            timeoutRetryPolicy.setTimeout(1000);
    
            //固定时间的回退策略，需设置参数sleeper和backOffPeriod，sleeper指定等待策略，默认是Thread.sleep，即线程休眠，backOffPeriod指定休眠时间，默认1秒,单位毫秒
            FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
            //休眠时间400毫秒
            fixedBackOffPolicy.setBackOffPeriod(400);
    
            //设置为超时时间重试策略
            retryTemplate.setRetryPolicy(timeoutRetryPolicy);
            //设置为固定时间的回退策略
            retryTemplate.setBackOffPolicy(fixedBackOffPolicy);
    
            //开始执行-设定1000ms后则认定为超时，每次重试等待时长400ms，故重试3次后即会超出超时阈值，触发RecoveryCallback回调，并返回Integer最大值。
            run(retryTemplate);
        }

执行策略  
![在这里插入图片描述][20201127113924807.png_pic_center]  
设定1000ms后则认定为超时，每次重试等待时长400ms，故重试3次后即会超出超时阈值，触发RecoveryCallback回调，并返回Integer最大值。

#### 3.7.4.根据返回结果值实现重试 ####

@Test
        public void retryWithResult() throws Exception { 
            //重试模板
            RetryTemplate retryTemplate = new RetryTemplate();
    
            //设置为无限重试策略
            retryTemplate.setRetryPolicy(new AlwaysRetryPolicy() { 
                private static final long serialVersionUID = 1213824522266301314L;
    
                @Override
                public boolean canRetry(RetryContext context) { 
                    //小于1则重试
                    return context.getAttribute("value") == null || Integer.parseInt(context.getAttribute("value").toString()) < 1;
                }
            });
    
            //开始执行-如果value值小于1或者为null则进行重试，反之不在进行重试，触发RecoveryCallback回调，并返回Integer最大值。
            run(retryTemplate);
        }

![在这里插入图片描述][20201127114013920.png_pic_center]  
如果value值小于1或者为null则进行重试，反之不在进行重试，触发RecoveryCallback回调，并返回Integer最大值。

#### 3.7.5.启用熔断器重试策略 ####

@Test
        public void retryCircuitBreakerTest() { 
            RetryTemplate retryTemplate = new RetryTemplate();
    
            //传入RetryPolicy（每个RetryPolicy实现都有自己的重试策略实现），是真正判断是否重试的策略，当重试失败时，则执行熔断策略；
            CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(4));
    
            //固定时间等待策略-每次重试等待300毫秒
            FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();
            fixedBackOffPolicy.setBackOffPeriod(300);
    
            // 熔断器电路打开的超时时间
            retryPolicy.setOpenTimeout(1500);
            //重置熔断器重新闭合的超时时间
            retryPolicy.setResetTimeout(2000);
    
            //设置重试策略
            retryTemplate.setRetryPolicy(retryPolicy);
            //设置回退策略
            retryTemplate.setBackOffPolicy(fixedBackOffPolicy);
    
            long startTime = System.currentTimeMillis();
    
            //
            IntStream.range(0, 10).forEach(index -> { 
                try { 
                    Thread.sleep(100);
                    RetryState state = new DefaultRetryState("circuit", false);
                    String result = retryTemplate.execute(
                            //重试业务逻辑
                            new RetryCallback<String, RuntimeException>() { 
                                @Override
                                public String doWithRetry(RetryContext context) throws RuntimeException { 
                                    log.info("重试 {} 次", context.getRetryCount());
                                    if (System.currentTimeMillis() - startTime > 1300 && System.currentTimeMillis() - startTime < 1500) { 
                                        return "retryCallback-success";
                                    }
                                    throw new RuntimeException("timeout");
                                }
                            },
                            //重试失败回调
                            new RecoveryCallback<String>() { 
                                @Override
                                public String recover(RetryContext context) throws Exception { 
                                    return "recoveryCallback-default";
                                }
                            }, state);
                    log.info("result: {}", result);
                } catch (Exception e) { 
                    log.error("报错了: type:{}:{}", e.getClass().getName(), e.getMessage());
                }
            });
        }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 8]

设定重试次数为4次，在执行1300ms至1500ms期间连续两次调用成功，无需重试，其后继续抛出异常重试，第4次重试时（1405）仍然在1500ms内，故打开了断路器，后续请求异常均会直接返回 RecoveryCallback中回调定义。

### 3.8.spring-retry1.3 以上构建RetryTemplate ###

以下代码需要引入spring-retry1.3 以上才能使用,目前`仅供参考`

RetryTemplate template = RetryTemplate.builder()
                    .maxAttempts(3)//重试次数
                    .fixedBackoff(1000)//重试时间,单位ms
                    .retryOn(RemoteAccessException.class)//触发重试异常
                    .build();
    
    template.execute(ctx -> { 
        // ... do something
    });

1.3开始可以这样构建

RetryTemplate.builder()
          .maxAttempts(10)
          .exponentialBackoff(100, 2, 10000)
          .retryOn(IOException.class)
          .traversingCauses()
          .build();
     
    RetryTemplate.builder()
          .fixedBackoff(10)
          .withinMillis(3000)
          .build();
     
    RetryTemplate.builder()
          .infiniteRetry()
          .retryOn(IOException.class)
          .uniformRandomBackoff(1000, 3000)
          .build();

### 3.9.较常见的重试技术实现 ###

1.  Spring Retry重试框架；
2.  Guava Retry重试框架；  
    [ Guava-Retry教程][Guava-Retry]
3.  Spring Cloud 重试配置；

--------------------

[spring-retry重试与熔断详解—《亿级流量》内容补充][spring-retry]

[github_]: https://github.com/spring-projects/spring-retry
[Link 1]: https://docs.spring.io/spring-batch/docs/current/reference/html/retry.html
[20201127095415616.png_pic_center]: /images/20221120/77809591cd0642a9b5c0f32669c4aa5b.png
[2020112709553274.png_pic_center]: /images/20221120/d1b48e4d2ac1436090e1cf442b8514f6.png
[20201124142043897.png_pic_center]: /images/20221120/46717a111b2f4dcaa563e3c06f14e056.png
[20201124142711248.png_pic_center]: /images/20221120/dd67caf2fe6a48848a099a7d2327d616.png
[20201126155341770.png_pic_center]: /images/20221120/e3e8a848a90c47908c8fa0ed5e09edc8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/3b55d0f3ba0e4d2f834f800d460630a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/1648390b62d24a2db15d0f0c786fd6ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/8a1ce464d1c34133ad2093d7ccdd396c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/6f36cee72af4495e8900c0bd96a97652.png
[20201126110936500.png_pic_center]: /images/20221120/b2e0a4a414474c2daa29b568b280a15e.png
[20201126144418370.png_pic_center]: /images/20221120/61c624f2207b4f64b71ec7a0ea19fbad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/6fa0d4421bdd4596832135366afb15fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221120/fbab507979304ec191c4fe3986d18dce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221120/22dea907b3464db09de3c0a41e5d74fb.png
[20201126151320777.png_pic_center]: /images/20221120/fa77a372cb5c4181b42ac55c04500967.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221120/9ab2385193d04971a3ef484b8734197b.png
[20201126153531641.png_pic_center]: /images/20221120/cd7a72cf518648e699b44740228f2c74.png
[20201127113714357.png_pic_center]: /images/20221120/489fbe547f2b4b12bb71e0ebde6b773d.png
[20201127113824216.png_pic_center]: /images/20221120/151842fbae264535b54ee087f03fb1a0.png
[20201127113924807.png_pic_center]: /images/20221120/d882271510bf496890724aa56e6c825e.png
[20201127114013920.png_pic_center]: /images/20221120/a5cfb2cff06341ac867254583846d8d0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201127115202205.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70#pic_center
[Guava-Retry]: https://blog.csdn.net/songhaifengshuaige/article/details/79440285
[spring-retry]: https://blog.csdn.net/broadview2006/article/details/80129764?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-7.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromBaidu-7.control