消息重试框架 Spring-Retry 和 Guava-Retry
消息重试框架 Spring-Retry 和 Guava-Retry
一重试框架之Spring-Retry
Spring Retry 为 Spring 应用程序提供了声明性重试支持。它主要是针对可能抛出异常的一些调用操作，进行有策略的重试。
1. Spring-Retry的普通使用方式
1.准备工作
我们只需要加上依赖:
<!-- https://mvnrepository.com/artifact/org.springframework.retry/spring-retry --> <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency>
准备一个任务方法，我这里是采用一个随机整数，根据不同的条件返回不同的值，或者抛出异常
public class RetryProcess { static Random random = new Random(); /** * 获取结果任务 * @return * @throws Exception */ public static String getResult(String param) { String result = "ok"; if (random.nextInt(2) == 1 /*true*/) { throw new RuntimeException("抛出远程访问异常"); } return result; } }
2.使用SpringRetryTemplate
这里可以写我们的代码了
import lombok.extern.slf4j.Slf4j; import org.junit.Test; import org.springframework.remoting.RemoteAccessException; import org.springframework.retry.backoff.FixedBackOffPolicy; import org.springframework.retry.policy.SimpleRetryPolicy; import org.springframework.retry.support.RetryTemplate; import java.util.HashMap; import java.util.Map; /** * @author dongliang7 * @projectName * @ClassName SpringRetryTemplateTest.java * @description: 重试任务测试 * @createTime 2023年02月07日 18:23:00 */ @Slf4j public class SpringRetryTemplateTest { /** * 重试间隔时间ms,默认1000ms * */ private long fixedPeriodTime = 1000L; /** * 最大重试次数,默认为3 */ private int maxRetryTimes = 3; /** * 表示哪些异常需要重试,key表示异常的字节码,value为true表示需要重试 */ private Map<Class<? extends Throwable>, Boolean> exceptionMap = new HashMap<>();
@Test public void test() { exceptionMap.put(RemoteAccessException.class,true); // 构建重试模板实例 RetryTemplate retryTemplate = new RetryTemplate(); // 设置重试回退操作策略，主要设置重试间隔时间 FixedBackOffPolicy backOffPolicy = new FixedBackOffPolicy(); backOffPolicy.setBackOffPeriod(fixedPeriodTime); // 设置重试策略，主要设置重试次数 SimpleRetryPolicy retryPolicy = new SimpleRetryPolicy(maxRetryTimes, exceptionMap); retryTemplate.setRetryPolicy(retryPolicy); retryTemplate.setBackOffPolicy(backOffPolicy); String execute = retryTemplate.execute( //RetryCallback retryContext -> { String result = RetryProcess.getResult("param"); log.info("调用的结果:{}", result); return result; }, retryContext -> { //RecoveryCallback log.info("已达到最大重试次数或抛出了不重试的异常~~~"); return ""; } ); log.info("执行结果:{}",execute); } }
简单剖析下案例代码，RetryTemplate 承担了重试执行者的角色，它可以设置SimpleRetryPolicy(重试策略，设置重试上限，重试的根源实体)，FixedBackOffPolicy（固定的回退策略，设置执行重试回退的时间间隔）。
RetryTemplate通过execute提交执行操作，需要准备RetryCallback 和RecoveryCallback 两个类实例，前者对应的就是重试回调逻辑实例，包装正常的功能操作，RecoveryCallback实现的是整个执行操作结束的恢复操作实例。
只有在调用的时候抛出了异常，并且异常是在exceptionMap中配置的异常，才会执行重试操作，否则就调用到excute方法的第二个执行方法RecoveryCallback中，当然,重试策略还有很多种,回退策略也是
重试策略
- NeverRetryPolicy： 只允许调用RetryCallback一次，不允许重试
- AlwaysRetryPolicy： 允许无限重试，直到成功，此方式逻辑不当会导致死循环
- SimpleRetryPolicy： 固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
- TimeoutRetryPolicy： 超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
- ExceptionClassifierRetryPolicy： 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
- CircuitBreakerRetryPolicy： 有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate
- CompositeRetryPolicy： 组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许即可以重试，悲观组合重试策略是指只要有一个策略不允许即可以重试，但不管哪种组合方式，组合中的每一个策略都会执行。
2. Spring-Retry的注解使用方式
1.准备工作
maven依赖:
<!-- https://mvnrepository.com/artifact/org.springframework.retry/spring-retry --> <dependency> <groupId>org.springframework.retry</groupId> <artifactId>spring-retry</artifactId> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-aspects</artifactId> </dependency>
2.代码
在application启动类上加上@EnableRetry的注解
@SpringBootApplication @EnableRetry(proxyTargetClass = true) public class WebsocketParentApplication { public static void main(String[] args) { SpringApplication.run(WebsocketParentApplication.class, args); } }
为了方便测试，我这里写了一个RetryController的测试接口：
@RestController @Slf4j public class RetryController { @Autowired private RetryService retryService; @GetMapping("/manually") public String manuallyRetry() { String result = retryService.retryResult("123"); return result; } }
我们只要在需要重试的方法上加@Retryable，在重试失败的回调方法上加@Recover，下面是这些注解的属性。
建一个RetryProcess类
@Service @Slf4j public class RetryService { /** * 重试任务处理 * @return * @throws Exception */ @Retryable(value = {RuntimeException.class},maxAttempts = 2,backoff = @Backoff(delay = 2000L,multiplier = 2)) public String retryResult(String param) { log.info("spring retry test, timestamp:{}", System.currentTimeMillis()/1000); return RetryProcess.getResult(param); } @Recover public String recover1(RuntimeException e, String param) { log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:",e); return param; } }
然后我们调用这个RetryProcess里面的getResult方法
这里我依然是RuntimeException的异常才重试，@Backoff(delay = 2000L,multiplier = 2))表示第一次间隔2秒，以后都是次数的2倍,也就是第二次4秒，第三次6秒.
来测试一下:
遇到了没有指定重试的异常,这里指定重试的异常是 @Retryable(value ={RuntimeException.class}，所以抛出参数异常IllegalArgumentException的时候，直接回调@Recover的方法。
二重试框架之Guava-Retry
Guava retryer工具与spring-retry类似，都是通过定义重试者角色来包装正常逻辑重试，但是Guava retryer有更优的策略定义，在支持重试次数和重试频度控制基础上，能够兼容支持多个异常或者自定义实体对象的重试源定义，让重试功能有更多的灵活性。
Guava Retryer也是线程安全的，入口调用逻辑采用的是Java.util.concurrent.Callable的call方法，示例代码如下：
pom.xml加入依赖
<!-- https://mvnrepository.com/artifact/com.github.rholder/guava-retrying --> <dependency> <groupId>com.github.rholder</groupId> <artifactId>guava-retrying</artifactId> <version>2.0.0</version> </dependency>
测试的任务方法
import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang3.RandomUtils; import org.springframework.remoting.RemoteAccessException; /** * @author dongliang7 * @ClassName RetryDemoTask.java * @description: TODO * @createTime 2023年02月09日 20:43:00 */ @Slf4j public class GuavaRetryTask { /** * 重试方法 * @return */ public static boolean retryTask(String param) { log.info("收到请求参数:{}",param); int i = RandomUtils.nextInt(0,11); log.info("随机生成的数:{}",i); if (i < 2) { log.info("为0,抛出参数异常."); throw new IllegalArgumentException("参数异常"); }else if (i < 5){ log.info("为1,返回true."); return true; }else if (i < 7){ log.info("为2,返回false."); return false; }else{ //为其他 log.info("大于2,抛出自定义异常."); throw new RemoteAccessException("大于2,抛出自定义异常"); } } }
Guava这里设定跟Spring-Retry不一样，我们可以根据返回的结果来判断是否重试，比如返回false我们就重试
import lombok.extern.slf4j.Slf4j; import org.junit.Test; import org.springframework.remoting.RemoteAccessException; import java.util.concurrent.TimeUnit; /** * @author dongliang7 * @projectName websocket-parent * @ClassName GuavaRetryTest.java * @description: TODO * @createTime 2023年02月09日 20:35:00 */ @Slf4j public class GuavaRetryTest { @Test public void guavaRetryTest(){ // RetryerBuilder 构建重试实例 retryer,可以设置重试源且可以支持多个重试源，可以配置重试次数或重试超时时间，以及可以配置等待时间间隔 Retryer<Boolean> retryer = RetryerBuilder.<Boolean> newBuilder() .retryIfExceptionOfType(RemoteAccessException.class)//设置异常重试源 .retryIfResult(res-> res==false) //设置根据结果重试 .withWaitStrategy(WaitStrategies.fixedWait(3, TimeUnit.SECONDS)) //设置等待间隔时间 .withStopStrategy(StopStrategies.stopAfterAttempt(3)) //设置最大重试次数 .withRetryListener(new MyRetryListener<>()) //设置RetryListener .build(); try { log.info("spring retry test, timestamp:{}", System.currentTimeMillis()/1000); retryer.call(() -> GuavaRetryTask.retryTask("abc")); } catch (Exception e) { e.printStackTrace(); } } }
运行测试一下
遇到了我们指定的需要重试的异常，进行重试，间隔是3秒
重试次数超过了最大重试次数，返回为true，直接结束重试
遇到了没有指定重试的异常，结束重试
返回false，重试
我们可以更灵活的配置重试策略，比如:
- retryIfException： retryIfException，抛出 runtime 异常、checked 异常时都会重试，但是抛出 error 不会重试。
- retryIfRuntimeException： retryIfRuntimeException 只会在抛 runtime 异常的时候才重试，checked 异常和error 都不重试。
- retryIfExceptionOfType： retryIfExceptionOfType 允许我们只在发生特定异常的时候才重试，比如NullPointerException 和 IllegalStateException 都属于 runtime 异常，也包括自定义的error。
如:
retryIfExceptionOfType(NullPointerException.class)// 只在抛出空指针异常重试
- retryIfResult: retryIfResult 可以指定你的 Callable 方法在返回值的时候进行重试，如
// 返回false重试 .retryIfResult(Predicates.equalTo(false)) //以_error结尾才重试 .retryIfResult(Predicates.containsPattern("_error$")) //返回为空时重试 .retryIfResult(res-> res==null)
- RetryListener： 当发生重试之后，假如我们需要做一些额外的处理动作，比如log一下异常，那么可以使用RetryListener。每次重试之后，guava-retrying 会自动回调我们注册的监听。可以注册多个RetryListener，会按照注册顺序依次调用。
·
import com.github.rholder.retry.Attempt; import com.github.rholder.retry.RetryListener; import java.util.concurrent.ExecutionException; /** * @author dongliang7 * @projectName websocket-parent * @ClassName MyRetryListener.java * @description: TODO * @createTime 2023年02月09日 21:04:00 */ public class MyRetryListener<Boolean> implements RetryListener { @Override public <Boolean> void onRetry(Attempt<Boolean> attempt) { // 第几次重试,(注意:第一次重试其实是第一次调用) System.out.print("[retry]time=" + attempt.getAttemptNumber()); // 距离第一次重试的延迟 System.out.print(",delay=" + attempt.getDelaySinceFirstAttempt()); // 重试结果: 是异常终止, 还是正常返回 System.out.print(",hasException=" + attempt.hasException()); System.out.print(",hasResult=" + attempt.hasResult()); // 是什么原因导致异常 if (attempt.hasException()) { System.out.print(",causeBy=" + attempt.getExceptionCause().toString()); } else { // 正常返回时的结果 System.out.print(",result=" + attempt.getResult()); } // bad practice: 增加了额外的异常处理代码 try { Boolean result = attempt.get(); System.out.print(",rude get=" + result); } catch (ExecutionException e) { System.err.println("this attempt produce exception." + e.getCause().toString()); } System.out.println(); } }
总结
spring-retry 和 guava-retry 工具都是线程安全的重试，能够支持并发业务场景的重试逻辑正确性。两者都很好的将正常方法和重试方法进行了解耦，可以设置超时时间、重试次数、间隔时间、监听结果、都是不错的框架。
但是明显感觉得到，guava-retry在使用上更便捷，更灵活，能根据方法返回值来判断是否重试，而Spring-retry只能根据抛出的异常来进行重试。
