1 重试之Spring-Retry

1.1 简介

Spring Retry是Spring框架提供的一个模块，它通过提供注解或编程方式的方式，帮助我们实现方法级别的重试机制。在Spring Boot中，可以很方便地集成并使用Spring Retry

b02168e4a2e20b83e39c61d53767c162_7b8db2586a8540e3a7ab7c3efbe76f78.png

1.2 直接使用

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

1.2.1 pom.xml

准备工作
我们只需要加上依赖:

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

1.2.2 重试任务

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

package com.zgd.demo.thread.retry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

/**
 * @Description:
 */
@Slf4j
public 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.2.3 使用SpringRetryTemplate

这里可以写我们的代码了

package com.zgd.demo.thread.retry.spring;

import com.zgd.demo.thread.retry.RetryDemoTask;
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;

/**
 * @Description: spring-retry 重试框架
 */
@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);

    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 两个类实例

• RetryCallback：对应的就是重试回调逻辑实例，包装正常的功能操作
• RecoveryCallback：实现的是整个执行操作结束的恢复操作实例

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

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

• 重试策略
  • NeverRetryPolicy： 只允许调用RetryCallback一次，不允许重试
  • AlwaysRetryPolicy： 允许无限重试，直到成功，此方式逻辑不当会导致死循环
  • SimpleRetryPolicy： 固定次数重试策略，默认重试最大次数为3次，RetryTemplate默认使用的策略
  • TimeoutRetryPolicy： 超时时间重试策略，默认超时时间为1秒，在指定的超时时间内允许重试
  • ExceptionClassifierRetryPolicy： 设置不同异常的重试策略，类似组合重试策略，区别在于这里只区分不同异常的重试
  • CircuitBreakerRetryPolicy： 有熔断功能的重试策略，需设置3个参数openTimeout、resetTimeout和delegate
  • CompositeRetryPolicy： 组合重试策略，有两种组合方式，乐观组合重试策略是指只要有一个策略允许即可以重试，悲观组合重试策略是指只要有一个策略不允许即可以重试，但不管哪种组合方式，组合中的每一个策略都会执行
• 重试回退策略
  重试回退策略，指的是每次重试是立即重试还是等待一段时间后重试。
  默认情况下是立即重试，如果需要配置等待一段时间后重试则需要指定回退策略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秒，重试的异常是RemoteAccessException，下面就是测试代码的情况: 重试第二次成功的情况:

在这里插入图片描述

重试一次以后，遇到了没有指出需要重试的异常，直接结束重试，调用retryContext

在这里插入图片描述

重试了三次后，达到了最大重试次数，调用retryContext

在这里插入图片描述

1.3 注解使用方式

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

1.3.1 注解介绍

我们只要在需要重试的方法上加@Retryable，在重试失败的回调方法上加@Recover，下面是这些注解的属性

@EnableRetry，表示是否开启重试

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

@Backoff

1.3.2 pom.xml

 <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.3.3 代码

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

@EnableRetry
public class Application {
 ...
}

为了方便测试，这里写了一个SpringBootTest的测试基类，需要使用SpringBootTest的只要继承这个类就好了

package com.zgd.demo.thread.test;

/**
 * @Author: zgd
 * @Description:
 */

import com.zgd.demo.thread.Application;
import lombok.extern.slf4j.Slf4j;
import org.junit.After;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Author: zgd
 * @Date: 18/09/29 20:33
 * @Description:
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
@Slf4j
public class MyBaseTest {


  @Before
  public void init() {
    log.info("----------------测试开始---------------");
  }

  @After
  public void after() {
    log.info("----------------测试结束---------------");
  }

}

建一个service类

package com.zgd.demo.thread.retry.spring;

import com.zgd.demo.thread.retry.RetryDemoTask;
import com.zgd.demo.thread.test.MyBaseTest;
import lombok.extern.slf4j.Slf4j;
import org.springframework.remoting.RemoteAccessException;
import org.springframework.retry.ExhaustedRetryException;
import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Recover;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Component;

/**
 * @Author: zgd
 * @Description:
 */
@Service
@Slf4j
public 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;
  }

}

然后我们调用这个service里面的call方法

package com.zgd.demo.thread.retry.spring;

import com.zgd.demo.thread.test.MyBaseTest;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * @Author: zgd
 * @Description:
 */
@Component
@Slf4j
public class SpringRetryDemoTest extends MyBaseTest {

  @Autowired
  private SpringRetryDemo springRetryDemo;

  @Test
  public void retry(){
    boolean abc = springRetryDemo.call("abc");
    log.info("--结果是:{}--",abc);
  }

}

这里我依然是RemoteAccessException的异常才重试，@Backoff(delay = 2000L,multiplier = 2))表示第一次间隔2秒，以后都是次数的2倍，也就是第二次4秒，第三次6秒.

1.3.4 测试结果

遇到了没有指定重试的异常，这里指定重试的异常是 @Retryable(value = {RemoteAccessException.class}...,所以抛出参数异常IllegalArgumentException的时候，直接回调@Recover的方法

在这里插入图片描述

重试达到最大重试次数时，调用@Recover的方法

在这里插入图片描述

重试到最后一次没有报错，返回false

在这里插入图片描述

1.4 @Retryable和@Recover注解使用问题

@Retryable和@Recover是Spring Framework中的注解，用于支持在方法执行期间发生异常时的重试和恢复操作。

• @Retryable：注解用于标记方法，在方法执行期间发生异常时进行重试。重试行为可以使用Spring Retry框架提供的默认策略或自定义策略来定义。可以指定要重试的异常类型以及最大重试次数和重试间隔等参数。
• @Recover：注解用于标记一个恢复方法，在最终重试失败后执行该方法。恢复方法应具有与原始方法相同的参数和返回类型，并且应在同一类中声明。如果未指定恢复方法，则重试失败后将抛出最后一次异常。

1.4.1 @Retryable和@Recover必须定义在一个类当中吗

@Retryable和@Recover注解必须定义在同一个类中。这是因为@Retryable注解标记的方法需要调用重试逻辑，而@Recover注解标记的方法需要提供重试失败后的恢复逻辑。因此，这两个方法必须在同一个类中，以便它们能够相互调用。

例如，以下示例演示了@Retryable和@Recover注解在同一个类中的使用

@Service
public class MyService {
 
    @Retryable(RuntimeException.class)
    public void myMethod() {
        // Some code that may throw a RuntimeException
    }
 
    @Recover
    public void recover() {
        // Recovery logic goes here
    }
}

在上面的示例中，MyService类中的myMethod()方法使用@Retryable注解进行标记，以便在发生RuntimeException异常时进行重试。如果重试最终失败，则recover()方法将被调用以提供恢复逻辑。由于这两个方法在同一个类中定义，因此它们可以相互调用。

1.4.2 如果一个类中有多个@Recover和@Retryable怎么区分

如果一个类中有多个方法标记了@Retryable和@Recover注解，你可以通过value属性来区分它们。value属性允许你指定一个异常类型的数组，以区分在方法执行期间抛出的不同异常类型。

例如，以下示例演示了在同一个类中有多个使用@Retryable和@Recover注解的方法的情况：

@Service
public class MyService {
 
    @Retryable(value = {IOException.class})
    public void methodA() throws IOException {
        // Some code that may throw an IOException
    }
 
    @Recover
    public void recoverA(IOException e) {
        // Recovery logic for methodA() goes here
    }
 
    @Retryable(value = {NullPointerException.class})
    public void methodB() throws NullPointerException {
        // Some code that may throw a NullPointerException
    }
 
    @Recover
    public void recoverB(NullPointerException e) {
        // Recovery logic for methodB() goes here
    }
}

在上面的示例中，methodA()和methodB()方法都标记为@Retryable注解，以便在抛出IOException或NullPointerException异常时进行重试。然后，对于每个方法，都定义了一个恢复方法recoverA()和recoverB()，分别提供特定于该方法的恢复逻辑。由于每个方法都在@Retryable注解的value属性中指定了不同的异常类型，因此Spring框架可以区分它们，并在适当的时候调用相应的方法。

1.4.3 如果异常也一样呢

如果多个方法在抛出相同的异常时都需要进行重试和恢复操作，你可以在每个方法上使用相同的@Retryable和@Recover注解。在这种情况下，Spring框架会自动根据需要调用相应的恢复方法。

例如，以下示例演示了在同一个类中有多个方法抛出相同异常，并且都需要重试和恢复的情况：

@Service
public class MyService {
 
    @Retryable(RuntimeException.class)
    public void methodA() {
        // Some code that may throw a RuntimeException
    }
 
    @Retryable(RuntimeException.class)
    public void methodB() {
        // Some code that may throw a RuntimeException
    }
 
    @Recover
    public void recover() {
        // Recovery logic goes here
    }
}

在上面的示例中，methodA()和methodB()方法都标记为@Retryable注解，以便在抛出RuntimeException异常时进行重试。由于它们都使用相同的异常类型和重试策略，因此它们也可以使用相同的恢复方法recover()。在最终重试失败时，Spring框架将调用recover()方法以提供恢复逻辑。

1.4.4 那怎么在recover中知道是哪个方法发生了异常呢

在@Recover注解标记的恢复方法中，可以通过方法的参数获取抛出异常的方法和异常信息。具体来说，@Recover方法可以接受与@Retryable注解标记的方法相同的参数，以便在恢复操作中访问异常信息和方法参数。

例如，以下示例演示了在@Retryable方法和@Recover方法中访问异常和方法参数的方式：

@Service
public class MyService {
 
    @Retryable(RuntimeException.class)
    public void methodA(String arg) {
        // Some code that may throw a RuntimeException
    }
 
    @Retryable(RuntimeException.class)
    public void methodB(int arg) {
        // Some code that may throw a RuntimeException
    }
 
    @Recover
    public void recover(Exception e, Object... args) {
        if (args[0] instanceof String) {
            // Recovery logic for methodA() goes here
        } else if (args[0] instanceof Integer) {
            // Recovery logic for methodB() goes here
        }
    }
}

在上面的示例中，methodA()和methodB()方法都标记为@Retryable注解，以便在抛出RuntimeException异常时进行重试。在@Recover注解标记的恢复方法中，可以通过方法的参数访问抛出异常的方法和方法参数。在上述示例中，我们检查第一个参数的类型以确定是哪个方法抛出了异常，从而提供相应的恢复逻辑。

需要注意的是，@Retryable方法和@Recover方法中的参数类型和数量必须相同，否则Spring框架将无法确定哪个方法抛出了异常。

2 重试之Guava-Retry

2.1 简介

Guava retryer工具与spring-retry类似，都是通过定义重试者角色来包装正常逻辑重试，但是Guava retryer有更优的策略定义，在支持重试次数和重试频度控制基础上，能够兼容支持多个异常或者自定义实体对象的重试源定义，让重试功能有更多的灵活性。
Guava Retryer也是线程安全的，入口调用逻辑采用的是Java.util.concurrent.Callable的call方法，示例代码如下：

2.2 pom.xml

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>

2.3 代码操作

更改一下测试的任务方法

package com.zgd.demo.thread.retry;

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.remoting.RemoteAccessException;

/**
 * @Author: zgd
 * @Description:
 */
@Slf4j
public 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,抛出自定义异常");
      }
    }

}

这里设定跟Spring-Retry不一样，我们可以根据返回的结果来判断是否重试，比如返回false我们就重试

package com.zgd.demo.thread.retry.guava;

import com.github.rholder.retry.*;
import com.zgd.demo.thread.retry.RetryDemoTask;
import org.junit.Test;
import org.springframework.remoting.RemoteAccessException;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;

/**
 * @Author: zgd
 * @Description:
 */
public class GuavaRetryTest {


  @Test
  public void fun01(){
    // 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();
    }
  }

}

2.4 运行结果

遇到了我们指定的需要重试的异常，进行重试，间隔是3秒

在这里插入图片描述

重试次数超过了最大重试次数

在这里插入图片描述

返回为true，直接结束重试

在这里插入图片描述

遇到了没有指定重试的异常，结束重试

在这里插入图片描述

返回false，重试

在这里插入图片描述

2.5 Guava配置策略

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

• 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.6 主要接口

StopStrategy，停止重试策略，提供三种

• StopAfterDelayStrategy
  设定一个最长允许的执行时间，比如设定最长执行10S，无论任务执行次数，只要重试的时候超出了最长时间，则任务终止，并返回重试异常RetryException
• NeverStopStrategy
  不停止，用于需要一直轮训知道返回期望结果的情况:
• StopAfterAttemptStrategy
  设定最大重试次数，如果超出最大重试次数则停止重试，并返回重试异常:

WaitStrategy，等待时长策略

• FixedWaitStrategy
  固定等待时长策略，
• RandomWaitStrategy
  随机等待时长策略 (可以提供一个最小和最大时长，等待时长为其区间随机值)
• IncrementingWaitstrategy
  递增等待时长策略 (提供一个初始值和步长，等待时间随重试次数增加而增加)
• ExponentialWaitstrategy
  指数等待时长策略;
• FibonacciWaitStrategy
Fibonacci等待时长策略，
• ExceptionWaitStrategy
  异常时长等待策略;
• CompositeWaitStrategy
  复合时长等待策略;

3 使用断路器Hystrix实现熔断机制

除了重试机制外，熔断机制也是一种常见的容错处理手段。Hystrix是一款流行的断路器实现库，可以与Spring Boot集成，用于实现熔断机制。

3.1 添加依赖

在pom.xml中添加Hystrix的依赖：

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

3.2 配置启用Hystrix

在Spring Boot的主类上添加@EnableHystrix注解：

@SpringBootApplication
@EnableHystrix
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

3.3 使用Hystrix实现熔断

3.3.1 代码示例

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@Service
public class ThirdPartyService {

    @HystrixCommand(fallbackMethod = "fallback")
    public String callThirdPartyApi() {
        // 调用第三方API的逻辑
        // ...
    }

    public String fallback() {
        // 熔断时的降级逻辑
        // ...
    }
}

在上述示例中，通过@HystrixCommand注解标记了callThirdPartyApi方法，指定了熔断时执行的降级方法fallback

文章参考：
https://mp.weixin.qq.com/s/nUD5kT2BcEEbmfeyG7rnDQ
https://mp.weixin.qq.com/s/pEPHzbPdmCsNeFeF2LwlXg

4 Fast-Retry

4.1 前言

假设系统里有100万个用户，然后要轮询重试的获取每个用户的身份信息, 如果还在使用SpringRetry和GuavaRetry 之类的这种单任务的同步重试框架，那可能到猴年马月也处理不完， 即使加再多的机器和线程也是杯水车薪， 而Fast-Retry正是为这种场景而生

4.1.1 简介

fast-retry是一个高性能的多任务重试框架，支持百万级任务的异步重试、以及支持编程式和注解声明式等多种使用方式、 也支持自定义结果重试逻辑。
Github 项目地址：https://github.com/burukeYou/fast-retry
与主流的Spring-Retry, Guava-Retry等单任务同步重试框架不同，Fast-Retry是一个支持异步重试框架，支持异步任务的重试、超时等待、回调。Spring-Retry, Guava-Retry均无法支持大批量任务的重试，即使加入线程池也无法解决，因为实际每个重试任务都是单独的同步逻辑，然后会会占用过多线程资源导致大量任务在等待处理，随着任务数的增加，系统吞吐量大大降低，性能指数级降低，而Fast-Retry在异步重试下的性能是前者的指数倍。

即使抛开性能不谈， SpringRetry使用繁琐，不支持根据结果的进行重试，GuavaRetry虽然支持，但是又没有提供注解声明式的使用。

4.1.2 fast-retry相比其它重试框架快在哪里

与其说快在哪，不如说同步型重试框架慢在哪。因为同步重试是阻塞的同步的，比如有 100 个重试任务，每个重试任务要重试 1 分钟，线程池有 10 个线程池，最多只能同时处理10 个重试任务。
也就是说起码要 10 分钟后才去执行剩下的 90 个任务。最后 100 个任务轮询完都要 100 分钟了。实际没必要等它轮询完一个任务才去执行下一个任务，它开始轮询一个任务后就可以开始去执行下一个任务了。
具体来说，Fast-Retry 的快主要体现在以下几个方面：

• 异步执行：Fast-Retry 通常采用异步方式执行重试逻辑，这意味着它可以在等待重试间隔时不阻塞主线程，从而提高应用程序的整体响应性和吞吐量。
• 非阻塞 I/O：在处理需要 I/O 操作（如网络请求、文件读写等）的重试时，Fast-Retry 可以利用非阻塞 I/O 机制，这样在等待 I/O 操作完成时不会占用宝贵的线程资源。
• 优化的重试策略：Fast-Retry 允许用户自定义重试策略，包括重试次数、重试间隔、退避算法等。通过智能的退避算法（如指数退避），它可以在保持高效率的同时减少对资源的不必要消耗。
• 资源利用：Fast-Retry 框架可能会优化资源的使用，例如通过复用连接或线程来减少创建和销毁资源的开销。
• 错误处理：Fast-Retry 能够快速识别和处理重试中的错误，减少错误处理的时间开销。
• 集成和扩展性：Fast-Retry 框架往往设计得易于集成和扩展，这意味着它可以快速地被添加到现有的系统中，并且可以根据需要进行定制。
• 避免不必要的重试：Fast-Retry 能够根据错误类型或其他条件判断是否需要重试，避免在明显无望的情况下进行无效的重试尝试。
• 性能监控：Fast-Retry 可能包含性能监控功能，这有助于及时发现性能瓶颈并进行优化。

注意，Fast-Retry 的具体实现可能会根据不同的编程语言和框架有所不同。

4.2 使用例子

4.2.1 pom.xml

<dependency>
    <groupId>io.github.burukeyou</groupId>
    <artifactId>fast-retry-all</artifactId>
    <version>0.2.0</version>
</dependency>

有以下三种方式去构建我们的重试任务

4.2.2 使用重试队列

RetryTask就是可以配置我们重试任务的一些逻辑，比如怎么重试，怎么获取重试结果，隔多久后重试，在什么情况下重试。它可以帮助我们更加自由的去构建重试任务的逻辑。但如果只是简单使用，强烈建议使用FastRetryBuilder 或者 @FastRetry注解
RetryQueue就是一个执行和调度我们重试任务的核心角色，其在使用上与线程池的API方法基本一致

ExecutorService executorService = Executors.newFixedThreadPool(8);
RetryQueue queue = new FastRetryQueue(executorService);
RetryTask<String> task = new RetryTask<String>() {
    int result = 0 ;

    // 下一次重试的间隔
    @Override
    public long waitRetryTime() {
        return 2000;
    }

    // 执行重试，每次重试回调此方法
    @Override
    public boolean retry() {
        return ++result < 5;
    }

     // 获取重试结果
    @Override
    public String getResult() {
        return  result + "";
    }
};
CompletableFuture<String> future = queue.submit(task);
log.info("任务结束 结果:{}",future.get());

4.2.3 使用FastRetryBuilder

底层还是使用的RetryQueue去处理， 只是帮我们简化了构建RetryTask的逻辑

RetryResultPolicy<String> resultPolicy = result -> result.equals("444");
FastRetryer<String> retryer = FastRetryBuilder.<String>builder()
        .attemptMaxTimes(3)
        .waitRetryTime(3, TimeUnit.SECONDS)
        .retryIfException(true)
        .retryIfExceptionOfType(TimeoutException.class)
        .exceptionRecover(true)
        .resultPolicy(resultPolicy)
        .build();

CompletableFuture<String> future = retryer.submit(() -> {
    log.info("重试");
    //throw new Exception("test");
    //int i = 1/0;
    if (0 < 10){
        throw new TimeoutException("test");
    }
    return "444";
});

String o = future.get();
log.info("结果{}", o);

4.2.4 使用@FastRetry注解

底层还是使用的RetryQueue去处理， 只是帮我们简化了构建RetryTask的逻辑，并且与Spring进行整合能对Spring的bean标记了FastRetry注解的方法进行代理， 提供了重试任务注解声明式的使用方式

• 依赖Spring环境，所以需要在Spring配置类加上@EnableFastRetry注解启用配置 ， 这个@FastRetry注解的使用才会生效
• 如果将结果类型使用CompletableFuture包装，自动进行异步轮询返回，否则同步阻塞等待重试结果(推荐)

下面定义等价于 RetryQueue.execute方法

// 如果发生异常，每隔两秒重试一次
@FastRetry(retryWait = @RetryWait(delay = 2))
public String retryTask(){
    return "success";
}

下面定义等价于 RetryQueue.submit方法,支持异步轮询

@FastRetry(retryWait = @RetryWait(delay = 2))
public CompletableFuture<String> retryTask(){
    return CompletableFuture.completedFuture("success");
}

4.2.5 自定义重试注解

如果不喜欢或者需要更加通用化的贴近业务的重试注解，提供一些默认的参数和处理逻辑，可以自行定义一个重试注解并标记上@FastRetry并指定factory，然后实现AnnotationRetryTaskFactory接口实现自己的构建重试任务的逻辑即可。@FastRetry默认实现就是：FastRetryAnnotationRetryTaskFactory

无论是使用以上哪种方式去构建重试任务，都建议使用异步重试的方法，即返回结果是CompletableFuture的方法， 然后使用CompletableFuture的whenComplete方法去等待异步重试任务的执行结果。

4.3 实际操作

假如有一个天气服务的重试任务，需要重试N次才可能获取到某城市的天气情况。分别使用Fast-Retry注解和Spring-Retry注解去并发获取1000个城市的天气情况，看下系统耗时。同样的逻辑，Spring-Retry需要1256秒左右，Fast-Retry只需要10秒左右

// 天气服务
@Component
public class WeatherService {
    
    // Fast-Retry  重试获取天气城市天气情况
    @FastRetry(
            maxAttempts = 100,
            retryWait = @RetryWait(delay = 2,timeUnit = TimeUnit.SECONDS))
    public CompletableFuture<WeatherResult> getFutureWeatherForCompare(String cityName){
        log.info("WeatherService进行重试  次数:{} 城市: {}",++index,cityName);
        WeatherResult weather = WeatherServer.getWeather(cityName);
        if (weather == null){
            //继续重试
            throw new RuntimeException("模拟异常进行重试");
        }

        return FastRetryBuilder.of(weather);
    }

   // Spring-Retry  重试获取天气城市天气情况
    @Retryable(maxAttempts = 100,backoff = @Backoff(delay = 2000))
    public WeatherResult getSpringWeatherForCompare(String cityName){
        log.info("WeatherService进行重试  次数:{} 城市: {}",++index,cityName);
        WeatherResult weather = WeatherServer.getWeather(cityName);
        if (weather == null){
            //继续重试
            throw new RuntimeException("模拟异常进行重试");
        }
        return weather;
    }

}

使用Spring-Retry去执行1000个重试任务

/**
 * spring-retry注解-测试
 * @throws Exception
 */
@Test
public void testFastRetryManyTaskForSpring() throws Exception {
    List<CompletableFuture<WeatherResult>> futures = new ArrayList<>();
    ExecutorService pool = Executors.newFixedThreadPool(8);

    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    int taskSize = 1000;
    for (int i = 0; i < taskSize; i++) {
        WeatherService taskWeatherService = context.getBean(WeatherService.class);
        CompletableFuture<WeatherResult> testFuture = new CompletableFuture<>();
        futures.add(testFuture);

        String cityName = "北京" + i;
        pool.execute(() -> {
            WeatherResult weather = taskWeatherService.getSpringWeatherForCompare(cityName);
            testFuture.complete(weather);
        });
    }

    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

    System.out.println("所有任务完成");
    for (CompletableFuture<WeatherResult> future : futures) {
        WeatherResult weatherResult = future.get();
        log.info("城市轮询结束  result:{}",weatherResult.data);
    }

    stopWatch.stop();
    log.info("Spring-Retry测试总耗时  任务数:{} 耗时:{}",taskSize,stopWatch.getTotalTimeSeconds());
}

使用Fast-Retry去执行1000个重试任务

/**
 * 测试FastRetry注解测试
 * @throws Exception
 */
@Test
public  void testFastRetryManyTask() throws Exception {

    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    int taskSize = 1000;

    List<CompletableFuture<WeatherResult>> futures = new ArrayList<>();
    for (int i = 0; i < taskSize; i++) {
        WeatherService taskWeatherService = context.getBean(WeatherService.class);
        String cityName = "北京" + i;
        CompletableFuture<WeatherResult> weather = taskWeatherService.getFutureWeatherForCompare(cityName);
        futures.add(weather);
    }
    CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
    System.out.println("所有任务完成");
    for (CompletableFuture<WeatherResult> future : futures) {
        WeatherResult weatherResult = future.get();
        log.info("城市轮询结束  result:{}",weatherResult.data);
    }
    stopWatch.stop();
    log.info("FastRetry测试总耗时  任务数:{} 耗时:{}",taskSize,stopWatch.getTotalTimeSeconds());
}