重试组件 Spring Retry

spring-retry是spring社区的一个成员，它提供了一种对失败操作进行自动重试的能力，可以作为某些瞬时错误（例如短暂的网络抖动）的解决方案。

作为spring生态的一部分，spring-retry自然地支持声明式（Declarative）方式使用。此外，它也支持命令式（Impertive）方式在代码里直接调用。

1. 项目集成

引入依赖：

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

它的版本交给spring boot管理，以获得与spring良好的兼容性。

项目当前使用的是spring-boot版本为1.5.13.RELEASE，它管理的spring-retry版本是1.2.2.RELEASE。

2. 声明式使用方式

在spring boot启动类上增加@EnableRetry注解：
```
@EnableRetry(proxyTargetClass = true)
@SpringBootApplication
public class TestApplication {public static void main(String[] args) {SpringApplication.run(TestApplication.class, args);}
}
```
该注解的proxyTargetClass属性默认为false，表示使用JDK的动态代理。如果设置为true，则表示使用CGLIB作为动态代理。
在需要重试的方法上，增加@Retryable注解：
```
@Service
@Slf4j
public class RetryAnnotationTest {@Retryable(value = {RemoteAccessException.class}, maxAttempts = 5, backoff = @Backoff(delay = 1000L), recover = "recoverCall")public boolean call(String param){System.out.println(new Date());return RetryTask.retryTask(param);}@Recoverpublic boolean recoverCall(Exception e,String param) {log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:", e);return false;}
}
```
如上示例中，当call方法抛出RemoteAccessException异常时，spring retry会重新调用call方法，重试次数为5次，两次重试之间间隔为1s。

如果超过最大重试次数仍未成功，或者抛出非RemoteAccessException异常，则调用recoverCall方法。

注：@Retryable注解也可以作用在类上，作用在类上之后，spring retry会对类的全部方法进行重试。

3. 命令式使用方式

配置RetryTemplate：

@Configuration
public class SpringRetryConfig {@Bean("retryTemplateFixed")public RetryTemplate retryTemplateFixed() {// 1.重试策略// 触发条件Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();exceptionMap.put(RemoteAccessException.class, true);// 重试次数设置为3次int maxAttempts = 3;SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxAttempts, exceptionMap);// 2.重试间隔设置为1秒FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy();backOffPolicy.setBackOffPeriod(1000);// 3.构造RetryTemplateRetryTemplate retryTemplate = new RetryTemplate();retryTemplate.setRetryPolicy(retryPolicy);retryTemplate.setBackOffPolicy(backOffPolicy);return retryTemplate;}@Bean("retryTemplate")public RetryTemplate retryTemplate() {// 定义简易重试策略，最大重试次数为3次,重试间隔为3sreturn RetryTemplate.builder().maxAttempts(3).fixedBackoff(3000).retryOn(RuntimeException.class).build();}}

注：可以配置多个RetryTemplate，用以适应不同重试场景。

spring retry支持的重试策略和退避策略如下：

@Bean("retryTemplateDemo")
public RetryTemplate retryTemplateDemo() {// 1.重试策略// 不重试NeverRetryPolicy neverRetryPolicy = new NeverRetryPolicy();// 无限重试AlwaysRetryPolicy alwaysRetryPolicy = new AlwaysRetryPolicy();// 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试ExceptionClassifierRetryPolicy exceptionClassifierRetryPolicy = new ExceptionClassifierRetryPolicy();final Map<Class<? extends Throwable>, RetryPolicy> policyMap = new HashMap<>(3);policyMap.put(IOException.class, alwaysRetryPolicy);policyMap.put(InterruptedIOException.class, neverRetryPolicy);policyMap.put(UnknownHostException.class, neverRetryPolicy);exceptionClassifierRetryPolicy.setPolicyMap(policyMap);// 固定次数重试，默认最大重试次数为5次，RetryTemplate默认重试策略SimpleRetryPolicy simpleRetryPolicy = new SimpleRetryPolicy();simpleRetryPolicy.setMaxAttempts(5);// 超时时间重试，默认超时时间为1秒，在指定的超时时间内重试TimeoutRetryPolicy timeoutRetryPolicy = new TimeoutRetryPolicy();timeoutRetryPolicy.setTimeout(3000);/** 组合重试策略，有两种组合方式：*  1.悲观默认重试，有不重试的策略则不重试。*  2.乐观默认不重试，有需要重试的策略则重试。*/CompositeRetryPolicy compositeRetryPolicy = new CompositeRetryPolicy();compositeRetryPolicy.setOptimistic(true);compositeRetryPolicy.setPolicies(new RetryPolicy[]{simpleRetryPolicy, timeoutRetryPolicy});// 有熔断功能的重试CircuitBreakerRetryPolicy circuitBreakerRetryPolicy = new CircuitBreakerRetryPolicy(compositeRetryPolicy);// 5s内失败10次，则开启熔断circuitBreakerRetryPolicy.setOpenTimeout(5000);// 10s之后熔断恢复circuitBreakerRetryPolicy.setResetTimeout(10000);// 2.退避策略（上一次执行失败之后，间隔多久进行下一次重试）// 立即重试NoBackOffPolicy noBackOffPolicy = new NoBackOffPolicy();// 固定时间后重试，默认1sFixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy();fixedBackOffPolicy.setBackOffPeriod(1000);// 随机时间后重试（如下：从500ms到1500ms内取一个随机时间后进行重试）UniformRandomBackOffPolicy uniformRandomBackOffPolicy = new UniformRandomBackOffPolicy();uniformRandomBackOffPolicy.setMinBackOffPeriod(500);uniformRandomBackOffPolicy.setMaxBackOffPeriod(1500);// 指数退避策略（如下：初始休眠时间100ms，最大休眠时间30s，下一次休眠时间为当前休眠时间*2）ExponentialBackOffPolicy exponentialBackOffPolicy = new ExponentialBackOffPolicy();exponentialBackOffPolicy.setInitialInterval(100);exponentialBackOffPolicy.setMaxInterval(30000);exponentialBackOffPolicy.setMultiplier(2);// 随机指数退避策略ExponentialRandomBackOffPolicy exponentialRandomBackOffPolicy = new ExponentialRandomBackOffPolicy();exponentialRandomBackOffPolicy.setInitialInterval(100);exponentialRandomBackOffPolicy.setMaxInterval(30000);exponentialRandomBackOffPolicy.setMultiplier(2);// 3.returnRetryTemplate retryTemplate = new RetryTemplate();retryTemplate.setRetryPolicy(circuitBreakerRetryPolicy);return retryTemplate;
}

在代码中调用

@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class RetryTest {// 注入RetryTemplate@Resourceprivate RetryTemplate retryTemplateFixed;@Testpublic void test() {// 执行Boolean execute = retryTemplateFixed.execute(// 重试回调retryContext -> {System.out.println(new Date());boolean b = RetryTask.retryTask("abc");log.info("调用的结果:{}", b);return b;},// 恢复回调（达到最大重试次数，或者抛出不满足重试条件的异常）retryContext -> {log.info("已达到最大重试次数或抛出了不重试的异常~~~");return false;});log.info("执行结果:{}",execute);}}

监听重试过程

通过实现RetryListener接口，重写open、close、onError这三个方法，既可以完成对重试过程的追踪，也可以添加额外的处理逻辑。

@Slf4j
@Component
public class RetryListenerTemplate implements RetryListener {// 进入重试前调用@Overridepublic <T, E extends Throwable> boolean open(RetryContext retryContext, RetryCallback<T, E> retryCallback) {log.info("--------------------------进入重试方法--------------------------");return true;}// 重试结束后调用@Overridepublic <T, E extends Throwable> void close(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {log.info("--------------------------重试方法结束--------------------------");}// 捕获到异常时调用@Overridepublic <T, E extends Throwable> void onError(RetryContext retryContext, RetryCallback<T, E> retryCallback, Throwable throwable) {log.info("--------------------------第" + retryContext.getRetryCount() + "次重试--------------------------");log.error(throwable.getMessage(), throwable);
}
}

或者，通过继承RetryListenerSupport，也可以从open、close、onError这三个方法中，选择性的重写。

public class RetryListener4Open extends RetryListenerSupport {@Overridepublic <T, E extends Throwable> boolean open(RetryContext context, RetryCallback<T, E> callback) {return super.open(context, callback);}
}

在实例化RetryTemplate时，配置上该RetryListener实例即可。

retryTemplate.setListeners(new RetryListener[] {retryListenerTemplate});

注：

V2.0版本以后，新增一个doOnSuccess方法，可以在调用成功之后，根据返回的结果值，来决定是否要进行重试。
每个RetryTemplate可以注册多个监听器，其中onOpen、onClose方法按照注册顺序执行，onError按照注册顺序的相反顺序执行。

参考资料：

Spring-Retry 和 Guava-Retry
Spring Retry Github地址