Spring（34）——Spring Retry介绍

缺乏、安全感 2022-01-30 08:47 177阅读 0赞

# Spring Retry介绍 #

Spring retry是Spring提供的一种重试机制的解决方案。它内部抽象了一个RetryOperations接口，其定义如下。

public interface RetryOperations { 
    
      <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback) throws E;
    
      <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback) throws E;
    
      <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RetryState retryState) throws E, ExhaustedRetryException;
    
      <T, E extends Throwable> T execute(RetryCallback<T, E> retryCallback, RecoveryCallback<T> recoveryCallback, RetryState retryState)
              throws E;
    
    }

从定义中可以看到它定义了几个重载的`execute()`，它们之间的差别就在于RetryCallback、RecoveryCallback、RetryState，其中核心参数是RetryCallback。RetryCallback的定义如下，从定义中可以看到它就定义了一个`doWithRetry()`，该方法的返回值就是RetryOperations的`execute()`的返回值，RetryCallback的范型参数中定义的Throwable是中执行可重试方法时可抛出的异常，可由外部进行捕获。

public interface RetryCallback<T, E extends Throwable> { 
    
      T doWithRetry(RetryContext context) throws E;
      
    }

当RetryCallback不能再重试的时候，如果定义了RecoveryCallback，就会调用RecoveryCallback，并以其返回结果作为`execute()`的返回结果。其定义如下。RetryCallback和RecoverCallback定义的接口方法都可以接收一个RetryContext参数，通过它可以获取到尝试次数，也可以通过其`setAttribute()`和`getAttribute()`来传递一些信息。

public interface RecoveryCallback<T> { 
    
      T recover(RetryContext context) throws Exception;
    
    }

Spring Retry包括有状态的重试和无状态的重试，对于有状态的重试，它主要用来提供一个用于在RetryContextCache中保存RetryContext的Key，这样可以在多次不同的调用中应用同一个RetryContext（无状态的重试每次发起调用都是一个全新的RetryContext，在整个重试过程中是一个RetryContext，其不会进行保存。有状态的重试因为RetryContext是保存的，其可以跨或不跨线程在多次`execute()`调用中应用同一个RetryContext）。

使用Spring Retry需要引入如下依赖。

<dependency>
        <groupId>org.springframework.retry</groupId>
        <artifactId>spring-retry</artifactId>
        <version>1.2.4.RELEASE</version>
    </dependency>

Spring Retry提供了一个RetryOperations的实现，RetryTemplate，通过它我们可以发起一些可重试的请求。其内部的重试机制通过RetryPolicy来控制。RetryTemplate默认使用的是SimpleRetryPolicy实现，SimpleRetryPolicy只是简单的控制尝试几次，包括第一次调用。RetryTemplate默认使用的是尝试3次的策略。所以下面的单元策略是可以通过的，第一二次尝试都失败，此时counter变为3了，第3次尝试成功了，counter变为4了。

@Test
    public void test() { 
      RetryTemplate retryTemplate = new RetryTemplate();
      AtomicInteger counter = new AtomicInteger();
      RetryCallback<Integer, IllegalStateException> retryCallback = retryContext -> { 
        if (counter.incrementAndGet() < 3) { //内部默认重试策略是最多尝试3次，即最多重试两次。
          throw new IllegalStateException();
        }
        return counter.incrementAndGet();
      };
      Integer result = retryTemplate.execute(retryCallback);
    
      Assert.assertEquals(4, result.intValue());
    }

接着来看一个使用RecoveryCallback的例子。我们把上面的例子简单改了下，改为调用包含RecoveryCallback入参的`execute()`，RetryCallback内部也改为了即使尝试了3次后仍然会失败。此时将转为调用RecoveryCallback，RecoveryCallback内部通过RetryContext获取了尝试次数，此时RetryCallback已经尝试3次了，所以RetryContext获取的尝试次数是3，RecoveryCallback的返回结果30将作为`execute()`的返回结果。

@Test
    public void testRecoveryCallback() { 
    
      RetryTemplate retryTemplate = new RetryTemplate();
      AtomicInteger counter = new AtomicInteger();
      RetryCallback<Integer, IllegalStateException> retryCallback = retryContext -> { 
        //内部默认重试策略是最多尝试3次，即最多重试两次。还不成功就会抛出异常。
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
        return counter.incrementAndGet();
      };
    
      RecoveryCallback<Integer> recoveryCallback = retryContext -> { 
        //返回的应该是30。RetryContext.getRetryCount()记录的是尝试的次数，一共尝试了3次。
        return retryContext.getRetryCount() * 10;
      };
      //尝试策略已经不满足了，将不再尝试的时候会抛出异常。此时如果指定了RecoveryCallback将执行RecoveryCallback，
      //然后获得返回值。
      Integer result = retryTemplate.execute(retryCallback, recoveryCallback);
    
      Assert.assertEquals(30, result.intValue());
    }

## RetryPolicy ##

RetryTemplate内部的重试策略是由RetryPolicy控制的。RetryPolicy的定义如下。

public interface RetryPolicy extends Serializable { 
    
      /** * @param context the current retry status * @return true if the operation can proceed */
      boolean canRetry(RetryContext context);
    
      /** * Acquire resources needed for the retry operation. The callback is passed * in so that marker interfaces can be used and a manager can collaborate * with the callback to set up some state in the status token. * @param parent the parent context if we are in a nested retry. * * @return a {@link RetryContext} object specific to this policy. * */
      RetryContext open(RetryContext parent);
    
      /** * @param context a retry status created by the * {@link #open(RetryContext)} method of this policy. */
      void close(RetryContext context);
    
      /** * Called once per retry attempt, after the callback fails. * * @param context the current status object. * @param throwable the exception to throw */
      void registerThrowable(RetryContext context, Throwable throwable);
    
    }

### SimpleRetryPolicy ###

RetryTemplate内部默认时候用的是SimpleRetryPolicy。SimpleRetryPolicy默认将对所有异常进行尝试，最多尝试3次。如果需要调整使用的RetryPolicy，可以通过RetryTemplate的`setRetryPolicy()`进行设置。比如下面代码就显示的设置了需要使用的RetryPolicy是不带参数的SimpleRetryPolicy，其默认会尝试3次。

public void testSimpleRetryPolicy() { 
      RetryPolicy retryPolicy = new SimpleRetryPolicy();
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      Integer result = retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        }
        return counter.get();
      });
      Assert.assertEquals(3, result.intValue());
    }

如果希望最多尝试10次，只需要传入构造参数10即可，比如下面这样。

RetryPolicy retryPolicy = new SimpleRetryPolicy(10);

在实际使用的过程中，可能你不会希望所有的异常都进行重试，因为有的异常重试是解决不了问题的。所以可能你会想要指定可以重试的异常类型。通过SimpleRetryPolicy的构造参数可以指定哪些异常是可以进行重试的。比如下面代码我们指定了最多尝试10次，且只有IllegalStateException是可以进行重试的。那么在运行下面代码时前三次抛出的IllegalStateException都会再次进行尝试，第四次会抛出IllegalArgumentException，此时不能继续尝试了，该异常将会对外抛出。

@Test
    public void testSimpleRetryPolicy() { 
      Map<Class<? extends Throwable>, Boolean> retryableExceptions = Maps.newHashMap();
      retryableExceptions.put(IllegalStateException.class, true);
      RetryPolicy retryPolicy = new SimpleRetryPolicy(10, retryableExceptions);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        } else if (counter.incrementAndGet() < 6) { 
          throw new IllegalArgumentException();
        }
        return counter.get();
      });
    }

看到这里可能你会有疑问，可以进行重试的异常定义为什么使用的是Map结构，而不是简单的通过Set或List来定义可重试的所有异常类似，而要多一个Boolean类型的Value来定义该异常是否可重试。这样做的好处是它可以实现包含/排除的逻辑，比如下面这样，我们可以指定对所有的RuntimeException都是可重试的，唯独IllegalArgumentException是一个例外。所以当你运行如下代码时其最终结果还是抛出IllegalArgumentException。

@Test
    public void testSimpleRetryPolicy() { 
      Map<Class<? extends Throwable>, Boolean> retryableExceptions = Maps.newHashMap();
      retryableExceptions.put(RuntimeException.class, true);
      retryableExceptions.put(IllegalArgumentException.class, false);
      RetryPolicy retryPolicy = new SimpleRetryPolicy(10, retryableExceptions);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        } else if (counter.incrementAndGet() < 6) { 
          throw new IllegalArgumentException();
        }
        return counter.get();
      });
    }

SimpleRetryPolicy在判断一个异常是否可重试时，默认会取最后一个抛出的异常。我们通常可能在不同的业务层面包装不同的异常，比如有些场景我们可能需要把捕获到的异常都包装为BusinessException，比如说把一个IllegalStateException包装为BusinessException。我们程序中定义了所有的IllegalStateException是可以进行重试的，如果SimpleRetryPolicy直接取的最后一个抛出的异常会取到BusinessException。这可能不是我们想要的，此时可以通过构造参数traverseCauses指定可以遍历异常栈上的每一个异常进行判断。比如下面代码，在`traverseCauses=false`时，只会在抛出IllegalStateException时尝试3次，第四次抛出的Exception不是RuntimeException，所以不会进行重试。指定了`traverseCauses=true`时第四次尝试时抛出的Exception，再往上找时会找到IllegalArgumentException，此时又可以继续尝试，所以最终执行后counter的值会是6。

@Test
    public void testSimpleRetryPolicy() throws Exception { 
      Map<Class<? extends Throwable>, Boolean> retryableExceptions = Maps.newHashMap();
      retryableExceptions.put(RuntimeException.class, true);
      RetryPolicy retryPolicy = new SimpleRetryPolicy(10, retryableExceptions, true);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        } else if (counter.incrementAndGet() < 6) { 
          try { 
            throw new IllegalArgumentException();
          } catch (Exception e) { 
            throw new Exception(e);
          }
        }
        return counter.get();
      });
    }

SimpleRetryPolicy除了前面介绍的3个构造方法外，还有如下这样一个构造方法，它的第四个参数表示当抛出的异常是在retryableExceptions中没有定义是否需要尝试时其默认的值，该值为true则表示默认可尝试。

public SimpleRetryPolicy(int maxAttempts, Map<Class<? extends Throwable>, Boolean> retryableExceptions,
                             boolean traverseCauses, boolean defaultValue)

下面代码中通过retryableExceptions指定了抛出IllegalFormatException时不进行重试，然后通过SimpleRetryPolicy的第四个参数指定了其它异常默认是可以进行重试的。所以下面的代码也可以正常运行，运行结束后counter的值是6。

@Test
    public void testSimpleRetryPolicy() throws Exception { 
      Map<Class<? extends Throwable>, Boolean> retryableExceptions = Maps.newHashMap();
      retryableExceptions.put(IllegalFormatException.class, false);
      RetryPolicy retryPolicy = new SimpleRetryPolicy(10, retryableExceptions, false, true);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        } else if (counter.incrementAndGet() < 6) { 
          throw new IllegalArgumentException();
        }
        return counter.get();
      });
    }

### AlwaysRetryPolicy ###

顾名思义就是一直重试，直到成功为止。所以对于下面代码而言，其会一直尝试100次，第100次的时候它就成功了。

@Test
    public void testRetryPolicy() { 
      RetryPolicy retryPolicy = new AlwaysRetryPolicy();
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      Integer result = retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 100) { 
          throw new IllegalStateException();
        }
        return counter.get();
      });
      Assert.assertEquals(100, result.intValue());
    }

### NeverRetryPolicy ###

与AlwaysRetryPolicy相对的一个极端是从不重试，NeverRetryPolicy的策略就是从不重试，但是第一次调用还是会发生的。所以对于下面代码而言，如果第一次获取的随机数不是3的倍数，则可以正常执行，否则将抛出IllegalStateException。

@Test
    public void testRetryPolicy() { 
      RetryPolicy retryPolicy = new NeverRetryPolicy();
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      retryTemplate.execute(retryContext -> { 
        int value = new Random().nextInt(100);
        if (value % 3 == 0) { 
          throw new IllegalStateException();
        }
        return value;
      });
    }

### TimeoutRetryPolicy ###

TimeoutRetryPolicy用于在指定时间范围内进行重试，直到超时为止，默认的超时时间是1000毫秒。

@Test
    public void testRetryPolicy() throws Exception { 
      TimeoutRetryPolicy retryPolicy = new TimeoutRetryPolicy();
      retryPolicy.setTimeout(2000);//不指定时默认是1000
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      Integer result = retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 10) { 
          TimeUnit.MILLISECONDS.sleep(20);
          throw new IllegalStateException();
        }
        return counter.get();
      });
      Assert.assertEquals(10, result.intValue());
    }

### ExceptionClassifierRetryPolicy ###

之前介绍的SimpleRetryPolicy可以基于异常来判断是否需要进行重试。如果你需要基于不同的异常应用不同的重试策略怎么办呢？ExceptionClassifierRetryPolicy可以帮你实现这样的需求。下面的代码中我们就指定了当捕获的是IllegalStateException时将最多尝试5次，当捕获的是IllegalArgumentException时将最多尝试4次。其执行结果最终是抛出IllegalArgumentException的，但是在最终抛出IllegalArgumentException时counter的值是多少呢？换句话说它一共尝试了几次呢？答案是8次。按照笔者的写法，进行第5次尝试时不会抛出IllegalStateException，而是抛出IllegalArgumentException，它对于IllegalArgumentException的重试策略而言是第一次尝试，之后会再尝试3次，5+3=8，所以counter的最终的值是8。

@Test
    public void testRetryPolicy() throws Exception { 
      ExceptionClassifierRetryPolicy retryPolicy = new ExceptionClassifierRetryPolicy();
    
      Map<Class<? extends Throwable>, RetryPolicy> policyMap = Maps.newHashMap();
      policyMap.put(IllegalStateException.class, new SimpleRetryPolicy(5));
      policyMap.put(IllegalArgumentException.class, new SimpleRetryPolicy(4));
      retryPolicy.setPolicyMap(policyMap);
    
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 5) { 
          throw new IllegalStateException();
        } else if (counter.get() < 10) { 
          throw new IllegalArgumentException();
        }
        return counter.get();
      });
    }

### CircuitBreakerRetryPolicy ###

CircuitBreakerRetryPolicy是包含了断路器功能的RetryPolicy，它内部默认包含了一个SimpleRetryPolicy，最多尝试3次。在固定的时间窗口内（默认是20秒）如果底层包含的RetryPolicy的尝试次数都已经耗尽了，则其会打开断路器，默认打开时间是5秒，在这段时间内如果还有其它请求过来就不会再进行调用了。CircuitBreakerRetryPolicy需要跟RetryState一起使用，下面的代码中RetryTemplate使用的是CircuitBreakerRetryPolicy，一共调用了5次`execute()`，每次调用RetryCallback都会抛出IllegalStateException，并且会打印counter的当前值，前三次RetryCallback都是可以运行的，之后断路器打开了，第四五次执行`execute()`时就不会再执行RetryCallback了，所以你只能看到只进行了3次打印。

@Test
    public void testCircuitBreakerRetryPolicy() throws Exception { 
      CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy();
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(retryPolicy);
      AtomicInteger counter = new AtomicInteger();
      RetryState retryState = new DefaultRetryState("key");
      for (int i=0; i<5; i++) { 
        try { 
          retryTemplate.execute(retryContext -> { 
            System.out.println(LocalDateTime.now() + "----" + counter.get());
            TimeUnit.MILLISECONDS.sleep(100);
            if (counter.incrementAndGet() > 0) { 
              throw new IllegalStateException();
            }
            return 1;
          }, null, retryState);
        } catch (Exception e) { 
          
        }
      }
    }

断路器默认打开的时间是5秒，5秒之后断路器又会关闭，RetryCallback又可以正常调用了。判断断路器是否需要打开的时间窗口默认是20秒，即在20秒内所有的尝试次数都用完了，就会打开断路器。如果在20秒内只尝试了两次（默认3次），则在新的时间窗口内尝试次数又将从0开始计算。可以通过如下方式进行这两个时间的设置。

SimpleRetryPolicy delegate = new SimpleRetryPolicy(5);
      //底层允许最多尝试5次
      CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy(delegate);
      retryPolicy.setOpenTimeout(2000);//断路器打开的时间
      retryPolicy.setResetTimeout(15000);//时间窗口

### CompositeRetryPolicy ###

CompositeRetryPolicy可以用来组合多个RetryPolicy，可以设置必须所有的RetryPolicy都是可以重试的时候才能进行重试，也可以设置只要有一个RetryPolicy可以重试就可以进行重试。默认是必须所有的RetryPolicy都可以重试才能进行重试。下面代码中应用的就是CompositeRetryPolicy，它组合了两个RetryPolicy，最多尝试5次的SimpleRetryPolicy和超时时间是2秒钟的TimeoutRetryPolicy，所以它们的组合就是必须尝试次数不超过5次且尝试时间不超过2秒钟才能进行重试。`execute()`中执行的RetryCallback的逻辑是counter的值小于10时就抛出IllegalStateException，否则就返回counter的值。第一次尝试的时候会失败，第二次也是，直到第5次尝试也还是失败的，此时SimpleRetryPolicy已经不能再尝试了，而TimeoutRetryPolicy此时还是可以尝试的，但是由于前者已经不能再尝试了，所以整体就不能再尝试了。所以下面的执行会以抛出IllegalStateException告终。

@Test
    public void testCompositeRetryPolicy() { 
      CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
      RetryPolicy policy1 = new SimpleRetryPolicy(5);
      TimeoutRetryPolicy policy2 = new TimeoutRetryPolicy();
      policy2.setTimeout(2000);
      RetryPolicy[] policies = new RetryPolicy[]{ policy1, policy2};
      compositeRetryPolicy.setPolicies(policies);
    
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(compositeRetryPolicy);
      AtomicInteger counter = new AtomicInteger();
      retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
        return counter.get();
      });
    }

CompositeRetryPolicy也支持组合的RetryPolicy中只要有一个RetryPolicy满足条件就可以进行重试，这是通过参数optimistic控制的，默认是false，改为true即可。比如下面设置了`setOptimistic(true)`，那么中尝试5次后SimpleRetryPolicy已经不满足了，但是TimeoutRetryPolicy还满足条件，所以最终会一直尝试，直到counter的值为10。

@Test
    public void testCompositeRetryPolicy() { 
      CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();
      RetryPolicy policy1 = new SimpleRetryPolicy(5);
      TimeoutRetryPolicy policy2 = new TimeoutRetryPolicy();
      policy2.setTimeout(2000);
      RetryPolicy[] policies = new RetryPolicy[]{ policy1, policy2};
      compositeRetryPolicy.setPolicies(policies);
      compositeRetryPolicy.setOptimistic(true);
    
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setRetryPolicy(compositeRetryPolicy);
      AtomicInteger counter = new AtomicInteger();
      Integer result = retryTemplate.execute(retryContext -> { 
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
        return counter.get();
      });
      Assert.assertEquals(10, result.intValue());
    }

## BackOffPolicy ##

BackOffPolicy用来定义在两次尝试之间需要间隔的时间，RetryTemplate内部默认使用的是NoBackOffPolicy，其在两次尝试之间不会进行任何的停顿。对于一般可重试的操作往往是基于网络进行的远程请求，它可能由于网络波动暂时不可用，如果立马进行重试它可能还是不可用，但是停顿一下，过一会再试可能它又恢复正常了，所以在RetryTemplate中使用BackOffPolicy往往是很有必要的。

### FixedBackOffPolicy ###

FixedBackOffPolicy将在两次重试之间进行一次固定的时间间隔，默认是1秒钟，也可以通过`setBackOffPeriod()`进行设置。下面代码中指定了两次重试的时间间隔是1秒钟，第一次尝试会失败，等一秒后会进行第二次尝试，第二次尝试会成功。

@Test
    public void testFixedBackOffPolicy() { 
    
      FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();
      backOffPolicy.setBackOffPeriod(1000);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setBackOffPolicy(backOffPolicy);
    
      long t1 = System.currentTimeMillis();
      long t2 = retryTemplate.execute(retryContext -> { 
        if (System.currentTimeMillis() - t1 < 1000) { 
          throw new IllegalStateException();
        }
        return System.currentTimeMillis();
      });
      Assert.assertTrue(t2 - t1 > 1000);
      Assert.assertTrue(t2 - t1 < 1100);
    }

### ExponentialBackOffPolicy ###

ExponentialBackOffPolicy可以使每一次尝试的间隔时间都不一样，它有3个重要的参数，初始间隔时间、后一次间隔时间相对于前一次间隔时间的倍数和最大的间隔时间，它们的默认值分别是100毫秒、2.0和30秒。下面的代码使用了ExponentialBackOffPolicy，指定了初始间隔时间是1000毫秒，每次间隔时间以2倍的速率递增，最大的间隔时间是5000毫秒，它最多可以尝试10次。所以当第1次尝试失败后会间隔1秒后进行第2次尝试，之后再间隔2秒进行第3次尝试，之后再间隔4秒进行第4次尝试，之后都是间隔5秒再进行下一次尝试，因为再翻倍已经超过了设定的最大的间隔时间。

@Test
    public void testExponentialBackOffPolicy() { 
      ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy();
      backOffPolicy.setInitialInterval(1000);
      backOffPolicy.setMaxInterval(5000);
      backOffPolicy.setMultiplier(2.0);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setBackOffPolicy(backOffPolicy);
      int maxAttempts = 10;
      retryTemplate.setRetryPolicy(new SimpleRetryPolicy(maxAttempts));
    
      long t1 = System.currentTimeMillis();
      long t2 = retryTemplate.execute(retryContext -> { 
        if (retryContext.getRetryCount() < maxAttempts-1) { //最后一次尝试会成功
          throw new IllegalStateException();
        }
        return System.currentTimeMillis();
      });
      long time = 0 + 1000 + 1000 * 2 + 1000 * 2 * 2 + 5000 * (maxAttempts - 4);
      Assert.assertTrue((t2-t1) - time < 100);
    }

### ExponentialRandomBackOffPolicy ###

ExponentialRandomBackOffPolicy的用法跟ExponentialBackOffPolicy的用法是一样的，它继承自ExponentialBackOffPolicy，在确定间隔时间时会先按照ExponentialBackOffPolicy的方式确定一个时间间隔，然后再随机的增加一个0-1的。比如取得的随机数是0.1即表示增加10%，每次需要确定重试间隔时间时都会产生一个新的随机数。如果指定的初始间隔时间是100毫秒，增量倍数是2,最大间隔时间是2000毫秒，则按照ExponentialBackOffPolicy的重试间隔是100、200、400、800,而ExponentialRandomBackOffPolicy产生的间隔时间可能是111、256、421、980。下面代码使用了ExponentialRandomBackOffPolicy，它打印出了每次重试时间的间隔。如果你有兴趣，你运行它会看到它会在ExponentialBackOffPolicy的基础上每次都随机的增长0-1倍。

@Test
    public void testExponentialRandomBackOffPolicy() { 
      ExponentialRandomBackOffPolicy backOffPolicy = new ExponentialRandomBackOffPolicy();
      backOffPolicy.setInitialInterval(1000);
      backOffPolicy.setMaxInterval(5000);
      backOffPolicy.setMultiplier(2.0);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setBackOffPolicy(backOffPolicy);
      int maxAttempts = 10;
      retryTemplate.setRetryPolicy(new SimpleRetryPolicy(maxAttempts));
    
      String lastAttemptTime = "lastAttemptTime";
      retryTemplate.execute(retryContext -> { 
        if (retryContext.hasAttribute(lastAttemptTime)) { 
          System.out.println(System.currentTimeMillis() - (Long) retryContext.getAttribute(lastAttemptTime));
        }
        retryContext.setAttribute(lastAttemptTime, System.currentTimeMillis());
        if (retryContext.getRetryCount() < maxAttempts-1) { //最后一次尝试会成功
          throw new IllegalStateException();
        }
        return System.currentTimeMillis();
      });
    }

### UniformRandomBackOffPolicy ###

UniformRandomBackOffPolicy用来每次都随机的产生一个间隔时间，默认的间隔时间是在500-1500毫秒之间。可以通过`setMinBackOffPeriod()`设置最小间隔时间，通过`setMaxBackOffPeriod()`设置最大间隔时间。

@Test
    public void testUniformRandomBackOffPolicy() { 
      UniformRandomBackOffPolicy backOffPolicy = new UniformRandomBackOffPolicy();
      backOffPolicy.setMinBackOffPeriod(1000);
      backOffPolicy.setMaxBackOffPeriod(3000);
      RetryTemplate retryTemplate = new RetryTemplate();
      retryTemplate.setBackOffPolicy(backOffPolicy);
      int maxAttempts = 10;
      retryTemplate.setRetryPolicy(new SimpleRetryPolicy(maxAttempts));
    
      String lastAttemptTime = "lastAttemptTime";
      retryTemplate.execute(retryContext -> { 
        if (retryContext.hasAttribute(lastAttemptTime)) { 
          System.out.println(System.currentTimeMillis() - (Long) retryContext.getAttribute(lastAttemptTime));
        }
        retryContext.setAttribute(lastAttemptTime, System.currentTimeMillis());
        if (retryContext.getRetryCount() < maxAttempts-1) { //最后一次尝试会成功
          throw new IllegalStateException();
        }
        return System.currentTimeMillis();
      });
    }

## 监听器 ##

RetryTemplate中可以注册一些RetryListener，它可以用来对整个Retry过程进行监听。RetryListener的定义如下，它可以在整个Retry前、整个Retry后和每次Retry失败时进行一些操作。

public interface RetryListener { 
    
      /** * 在第一次尝试之前调用。如果方法的返回值是false，则不会进行尝试，反而会抛出TerminatedRetryException。 * * @param <E> RetryCallback可抛出的异常类型 * @param <T> RetryCallback的返回值类型 * @param context 当前RetryContext. * @param callback 当前RetryCallback. * @return 如果需要继续尝试则返回true. */
      <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback);
    
      /** * 在最后一次尝试后调用，而不管最后一次尝试是成功的还是失败的。 * * @param context 当前RetryContext. * @param callback 当前RetryCallback. * @param throwable RetryCallback抛出的最后一个异常. * @param <E> RetryCallback可抛出的异常类型 * @param <T> RetryCallback的返回值类型 */
      <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);
    
      /** * 每一次尝试失败都会调用一次 * * @param context 当前RetryContext. * @param callback 当前RetryCallback. * @param throwable RetryCallback抛出的最后一个异常. * @param <E> RetryCallback可抛出的异常类型 * @param <T> RetryCallback的返回值类型 */
      <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable);
    }

下面是一个简单的使用RetryListener的示例。

@Test
    public void testListener() { 
      RetryTemplate retryTemplate = new RetryTemplate();
      AtomicInteger counter = new AtomicInteger();
      RetryCallback<Integer, IllegalStateException> retryCallback = retryContext -> { 
        //内部默认重试策略是最多尝试3次，即最多重试两次。还不成功就会抛出异常。
        if (counter.incrementAndGet() < 3) { 
          throw new IllegalStateException();
        }
        return counter.incrementAndGet();
      };
    
      RetryListener retryListener = new RetryListener() { 
        @Override
        public <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) { 
          System.out.println("---open----在第一次重试时调用");
          return true;
        }
    
        @Override
        public <T, E extends Throwable> void close(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) { 
          System.out.println("close----在最后一次重试后调用（无论成功与失败）。" + context.getRetryCount());
        }
    
        @Override
        public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) { 
          System.out.println("error----在每次调用异常时调用。" + context.getRetryCount());
        }
      };
    
      retryTemplate.registerListener(retryListener);
      retryTemplate.execute(retryCallback);
    
    }

如果只想关注RetryListener的某些方法，则可以选择继承RetryListenerSupport，它默认实现了RetryListener的所有方法。

## 声明式的重试（使用注解） ##

Spring Retry支持对Spring bean使用声明式的重试，在需要重试的bean方法上加上`@Retryable`。使用这种机制需要在`@Configuration`类上加上`@EnableRetry`。

@EnableRetry
    @Configuration
    public class RetryConfiguration { 
    
      @Bean
      public HelloService helloService() { 
        return new HelloService();
      }
    
    }

这样就启用了声明式的重试机制，其会对使用了`@Retryable`标注的方法对应的bean创建对应的代理。使用`@Retryable`标注的方法如果不特殊声明的话，默认最多可以尝试3次。

public class HelloService { 
    
      @Retryable
      public void hello(AtomicInteger counter) { 
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
      }
    
    }

`@Retryable`也可以加在Class上，当加在Class上时表示该bean所有的对外方法都是可以重试的。当Class上和方法上都加了`@Retryable`时，方法上的优先级更高。默认的最大尝试次数是3次，可以通过maxAttempts属性进行自定义。默认会对所有的异常进行重试，如有需要可以通过value和include属性指定需要重试的异常，也可以通过exclude属性指定不需要进行重试的异常。可以通过backoff属性指定BackOffPolicy相关的信息，它对应一个`@BackOff`，默认使用的BackOffPolicy将每次都间隔1000毫秒，如果默认值不能满足要求可以通过`@BackOff`指定初始的间隔时间。可以通过`@BackOff`的multiplier属性指定间隔之间的倍数，默认是0,即每次都是固定的间隔时间。当指定了multiplier后可以通过maxDelay属性指定最大的间隔时间，默认是0，表示不限制，即取ExponentialBackOffPolicy的默认值30秒。

@Retryable
    public class HelloService { 
    
      @Retryable(maxAttempts = 5, backoff = @Backoff(delay = 100, maxDelay = 2000, multiplier = 2))
      public void hello(AtomicInteger counter) { 
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
      }
    
    }

上面这些参数都是直接在代码里面写死的，如果你想改你还得修改代码，这很麻烦，所以对于这种可能会进行修改的参数我们一般会配置在配置文件中。上面这些属性都有增加Expression后缀的属性，比如maxAttempts对应的是maxAttemptsExpression，它是字符串类型，在里面可以使用占位符，从而允许我们在配置文件中配置这些信息。

### Recover ###

使用注解的可重试方法，如果重试次数达到后还是继续失败的就会抛出异常，它可以通过`@Recover`标记同一Class中的一个方法作为RecoveryCallback。`@Recover`标记的方法的返回类型必须与`@Retryable`标记的方法一样。方法参数可以与`@Retryable`标记的方法一致，也可以不带参数，带了参数就会传递过来。

@Retryable
    public class HelloService { 
    
      @Retryable(maxAttemptsExpression = "${retry.maxAttempts:5}",
              backoff = @Backoff(delayExpression = "${retry.delay:100}",
                      maxDelayExpression = "${retry.maxDelay:2000}",
                      multiplierExpression = "${retry.multiplier:2}"))
      public void hello(AtomicInteger counter) { 
        if (counter.incrementAndGet() < 10) { 
          throw new IllegalStateException();
        }
      }
    
      @Recover
      public void helloRecover(AtomicInteger counter) { 
        counter.set(1000);
      }
    
    }

`@Recover`标记的方法还可以选择包含一个Exception类型的参数，它对应于`@Retryable`标记的方法最后抛出的异常，如果需要包含异常参数该参数必须是第一个参数。当定义了多个`@Recover`方法时，Spring Retry将选择更精确的那一个。此时的RecoveryCallback将选择第二个helloRecover方法。

### 监听器 ###

使用声明式的Spring Retry，如果需要使用RetryListener，只需把它们定义为一个Spring bean即可。比如下面这样。

@EnableRetry
    @Configuration
    @PropertySource("classpath:/application.properties")
    public class RetryConfiguration { 
    
      @Bean
      public HelloService helloService() { 
        return new HelloService();
      }
    
      @Bean
      public RetryListener retryListener() { 
        return new RetryListenerSupport() { 
          @Override
          public <T, E extends Throwable> void onError(RetryContext context, RetryCallback<T, E> callback, Throwable throwable) { 
            super.onError(context, callback, throwable);
            System.out.println("发生异常：" + context.getRetryCount());
          }
        };
      }
    
    }

（注：本文是基于Spring Retry1.2.2所写）