重试框架-Easy-Retry接入之路

最新推荐文章于 2024-01-06 14:50:46 发布

竹林幽深

最新推荐文章于 2024-01-06 14:50:46 发布

阅读量233

点赞数

文章标签： spring spring boot

原文链接：https://mp.weixin.qq.com/s/HLli1NdV2AsXceEca7gpNw

版权

青苗码问 2023-06-12 21:32 发表于山东

最近在做一个paas平台，里面有功能模块“事件中心”，“审核中心”，“支付中心”等相关的一些组件。他们都有一个类似的东西。当我发起事件的时候，需要将事件通知到其他的应用，当我审核的时候，需要将审核结果返回给其他应用，当我支付完成后也会将结果推送给其他应用。然而，我们的其他应用可能会有不可用的状态，可能会导致回调通知的时候会报错，也是不难想象到我们需要做一个重试机制。

本文主要介绍相关的一些重试机制

重试框架之Spring-Retry
重试框架之Guava-Retry
重试框架之Easy-Retry

一重试框架之Spring-Retry

Spring Retry 为 Spring 应用程序提供了声明性重试支持。它用于Spring批处理、Spring集成、Apache Hadoop(等等)。它主要是针对可能抛出异常的一些调用操作，进行有策略的重试

1.1. Spring-Retry的普通使用方式

1.1.1.准备工作

我们只需要加上依赖:

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

准备一个任务方法，我这里是采用一个随机整数，根据不同的条件返回不同的值，或者抛出异常

@Slf4jpublic class RetryDemoTask {

  /**   * 重试方法   * @return   */  public static boolean retryTask(String param)  {    log.info("收到请求参数:{}",param);
    int i = RandomUtils.nextInt(0,11);    log.info("随机生成的数:{}",i);    if (i == 0) {      log.info("为0,抛出参数异常.");      throw new IllegalArgumentException("参数异常");    }else if (i  == 1){      log.info("为1,返回true.");      return true;    }else if (i == 2){      log.info("为2,返回false.");      return false;    }else{      //为其他        log.info("大于2,抛出自定义异常.");        throw new RemoteAccessException("大于2,抛出远程访问异常");      }    }
}

1.1.2 使用SpringRetryTemplate

@Slf4jpublic 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);
    Boolean execute = retryTemplate.execute(            //RetryCallback            retryContext -> {              boolean b = RetryDemoTask.retryTask("abc");              log.info("调用的结果:{}", b);              return b;            },            retryContext -> {              //RecoveryCallback              log.info("已达到最大重试次数或抛出了不重试的异常~~~");              return false;            }      );
    log.info("执行结果:{}",execute);
  }
}

简单剖析下案例代码，RetryTemplate 承担了重试执行者的角色，它可以设置 SimpleRetryPolicy(重试策略，设置重试上限，重试的根源实体)，FixedBackOffPolicy（固定的回退策略，设置执行重试回退的时间间隔）。

RetryTemplate通过 execute提交执行操作，需要准备 RetryCallback 和 RecoveryCallback 两个类实例，前者对应的就是重试回调逻辑实例，包装正常的功能操作，RecoveryCallback实现的是整个执行操作结束的恢复操作实例.

只有在调用的时候抛出了异常，并且异常是在 exceptionMap中配置的异常，才会执行重试操作，否则就调用到 excute方法的第二个执行方法 RecoveryCallback中

当然,重试策略还有很多种,回退策略也是:

1.1.3 重试策略

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

1.1.4 重试回退策略

重试回退策略，指的是每次重试是立即重试还是等待一段时间后重试。

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

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

我们可以根据自己的应用场景和需求，使用不同的策略，不过一般使用默认的就足够了。

1.2 Spring-Retry的注解使用方式

既然是Spring家族的东西，那么自然就支持和Spring-Boot整合

1.2.1.准备工作

依赖:

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

1.2.2 使用

在application启动类上加上 @EnableRetry的注解

@EnableRetrypublic class Application { ...}

@Service@Slf4jpublic class SpringRetryDemo   {
 /**   * 重试所调用方法   * @param param   * @return   */  @Retryable(value = {RemoteAccessException.class},maxAttempts = 3,backoff = @Backoff(delay = 2000L,multiplier = 2))  public boolean call(String param){      return RetryDemoTask.retryTask(param);  }
  /**   * 达到最大重试次数,或抛出了一个没有指定进行重试的异常   * recover 机制   * @param e 异常   */  @Recover  public boolean recover(Exception e,String param) {    log.error("达到最大重试次数,或抛出了一个没有指定进行重试的异常:",e);    return false;  }
}

1.2.3 注解介绍

@EnableRetry

序号	属性	类型	默认值	说明
1	proxyTargetClass	boolean	false	指示是否要创建基于子类的(CGLIB)代理，而不是创建标准的基于Java接口的代码

@Retryable

标注此注解的方法在发生异常时会进行重试

序号	属性	类型	默认值	说明
1	interceptor	String	""	将interceptor的bean名称应用到retryable()
2	value	Class[]	{}	可重试的异常类型
3	label	String	""	统计报告的唯一标签。如果没有提供，调用者可以选择忽略它，或者提供默认值
4	maxAttempts	int	3	尝试的最大次数（包括第一次失败），默认为3次
5	backoff	@Backoff	@Backoff()	指定用于重试此操作的backoff属性，默认为空

@Backoff

序号	属性	类型	默认值	说明
1	delay	long	0	如果不设置则默认使用1000millisenconds重试等待
2	maxDelay	long	0	最大重试等待时间
3	multiplier	long	0	用于计算下一个延迟的乘数（大于0生效）
4	random	boolean	false	随机重试等待时间

二重试框架之Guava-Retry

Guava retryer工具与spring-retry类似，都是通过定义重试者角色来包装正常逻辑重试，但是Guava retryer有更优的策略定义，在支持重试次数和重试频度控制基础上，能够兼容支持多个异常或者自定义实体对象的重试源定义，让重试功能有更多的灵活性。

Guava Retryer也是线程安全的，入口调用逻辑采用的是 Java.util.concurrent.Callable的call方法，示例代码如下：

2.1.1.准备工作

依赖

<dependency>   <groupId>com.github.rholder</groupId>   <artifactId>guava-retrying</artifactId>   <version>2.0.0</version></dependency>

@Slf4jpublic class RetryDemoTask {

  /**   * 重试方法   * @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我们就重试

public class GuavaRetryTest {

  @Test  public void test(){    // 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)) //设置最大重试次数            .build();
    try {        retryer.call(() -> RetryDemoTask.retryTask("abc"));    } catch (Exception e) {      e.printStackTrace();    }  }
}

我们可以更灵活的配置重试策略，比如:

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，会按照注册顺序依次调用。

.withRetryListener(new RetryListener {       @Override       public <T> void onRetry(Attempt<T> attempt) {                 logger.error("第【{}】次调用失败" , attempt.getAttemptNumber());            }  })

2.1.2 主要接口

序号	接口	描述	备注
1	Attempt	一次执行任务
2	AttemptTimeLimiter	单次任务执行时间限制	如果单次任务执行超时，则终止执行当前任务
3	BlockStrategies	任务阻塞策略	通俗的讲就是当前任务执行完，下次任务还没开始这段时间做什么，默认策略为：BlockStrategies.THREAD_SLEEP_STRATEGY
4	RetryException	重试异常
5	RetryListener	自定义重试监听器	可以用于异步记录错误日志
6	StopStrategy	停止重试策略
7	WaitStrategy	等待时长策略	（控制时间间隔），返回结果为下次执行时长

StopStrategy

提供三种：

StopAfterDelayStrategy

设定一个最长允许的执行时间，比如设定最长执行10s，无论任务执行次数，只要重试的时候超出了最长书记兼，则任务终止。并返回重试异常RetryException

NeverStopStrategy

不停止，用于需要一直轮训知道返回期望结果的情况

StopAfterAttemptStrategy

设定最大重试次数，如果超出最大重试次数则停止重试，并返回重试异常

WaitStrategy

FixedWaitStrategy

固定等待时长策略

RandomWaitStrategy

随机等待时长策略

IncrementingWaitStrategy

递增等待时长策略（提供一个初始和步长，等待时间随重试次数增加而增加）

ExponentialWaitStrategy

指数等待时长策略

FibonacciWaitStrategy

Fibonacci等待时长策略

ExceptionWaitStrategy

异常时长等待策略

CompositeWaitStrategy

复合时长等待策略

三重试框架之Easy-Retry

spring-retry 和 guava-retry 工具都是线程安全的重试，能够支持并发业务场景的重试逻辑正确性。两者都很好的将正常方法和重试方法进行了解耦，可以设置超时时间、重试次数、间隔时间、监听结果、都是不错的框架。

但是明显感觉得到，guava-retry在使用上更便捷，更灵活，能根据方法返回值来判断是否重试，而Spring-retry只能根据抛出的异常来进行重试。

但是问题来了

1、如果是分布式场景，当服务挂掉之后是否还能进行重试？

答案是肯定可以，但是如果用到spring-retry 和 guava-retry，我们可以将重试持久化，然后启动项目的时候再次唤起重试。要自己去完善该逻辑

2、如何知道我们还有多少任务，重试的情况是什么样的？

目前的不知道的，因为我们没有可视化的东西可以看到有多少任务，也看不到每个任务的执行情况，当然也可以针对这种业务场景去完善业务逻辑

3、当任务执行次数全部完成后，还能再继续进行重试吗？

目前是没有入口去主动唤起重试任务，当然也可以自己去检查数据库记录的再次唤起

以上是我想到的一些问题，如果我们要完成的更好，那么必须得再进行开发。但是目前就出现了这样的一个框架Easy-Retry

详细资料 Easy-Retry

在分布式系统大行其道的当前，系统数据的准确性和正确性是重大的挑战，基于CAP理论，采用柔性事务，保障系统可用性以及数据的最终一致性成为技术共识为了保障分布式服务的可用性，服务容错性，服务数据一致性以及服务间掉用的网络问题。依据"墨菲定律"，增加核心流程重试，数据核对校验成为提高系统鲁棒性常用的技术方案

对比

区别	SpringRetry	GuavaRetry	EasyRetry
编程语言	Java	Java	Java
退避策略	支持多种策略	支持多种策略	支持多种策略
依赖生态	Spring 框架	不依赖任何框架	Spring框架、GuavaRetry
重试类型	内存重试	内存重试	多种策略内存重试+服务端重试
存储介质	内存	内存	内存+数据库
是否管控重试流量	否	否	支持多维度管控(单机重试管控、链路重试管控、重试流速管控等)
数据安全	会丢失重试数据	会丢失重试数据	基于LOCAL_REMOTE或ONLY_REMOTE持久化数据
管理重试数据	不支持	不支持	支持暂停、停止、新增、修改重试数据

3.1.1 准备工作

<dependency>  <groupId>com.aizuda</groupId>  <artifactId>easy-retry-client-starter</artifactId>  <version>1.5.0</version></dependency>

3.1.2 如何使用

启动类上添加注解开启easy-retry功能

@SpringBootApplication@EnableEasyRetry(group = "example_group")public class ExampleApplication {    public static void main(String[] args) {        SpringApplication.run(ExampleApplication.class, args);    }}

配置服务地址:

easy-retry:  server:     host: 127.0.0.1 #服务端的地址建议使用域名    port: 1788 #服务端netty的端口号

详细文档官网已经写的很详细Easy-Retry，如果感兴趣的可以直接去查看官方的资料

3.1.3 Easy-Retry接入之路

我在接入的时候感觉还是很轻松，首先的将服务端部署起来，我们目前用的是k8s。完成之后将服务的地址写入到客户端的配置host中，客户端接入后需要在服务端配置group，由于group一般是之配置一次，所以是由服务端手动新增。

但是我觉得也可以自动接入。或者当客户端没有配置group的时候可以默认为DEFAULT_GROUP之类的，这样当服务端没有配置group的时候也可以将数据上报到服务端进行重试。