spring Retryable注解实现重试详解

// 版本号继承spring-boot依赖管理的pom
<dependency>
 <groupId>org.springframework.retry</groupId>
 <artifactId>spring-retry</artifactId>
</dependency>
<dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
</dependency>

@Configuration
@ImportResource(locations = { "classpath*:spring/app-context-*" })
@EnableRetry
public class AppContext {
}

@Retryable(value = RuntimeException.class, maxAttempts = 3,backoff = @Backoff(delay = 10L, multiplier = 1))
public boolean myRetryableMethod(){
  ...
}

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Retryable {

 /**
 * 为重试方法应用重试拦截器的bean名称。与其他属性互斥
 */
 String interceptor() default "";

 /**
 * 可以重试的异常类型。与includes属性同义。默认值为空（并且如果exclude也是空的话，
   * 所有的异常都会重试）
 */
 Class<? extends Throwable>[] value() default {};

 /**
 * 同上
 */
 Class<? extends Throwable>[] include() default {};

 /**
 * 与include含义相反
 */
 Class<? extends Throwable>[] exclude() default {};

 /**
 * 统计报告的唯一标签。如果没有提供，调用者可以选择忽略它，或者提供一个默认值。
 *
 * @return the label for the statistics
 */
 String label() default "";

 /**
 * 标识重试有状态的：即异常重新抛出，但是重试策略使用相同的策略应用于后续的具有相同参数的
   * 调用。如果为false那么可重试的异常不会重新抛出。
 */
 boolean stateful() default false;

 /**
   * 尝试的最大次数（包含第一次失败），默认为3
 */
 int maxAttempts() default 3;

 /**
 * 返回一个求尝试最大次数值的表达式（包含第一次失败），默认为3
   * 重写 {@link #maxAttempts()}。
 * @since 1.2
 */
 String maxAttemptsExpression() default "";

 /**
 * 为正重试的动作指定backoff属性。默认没有backoff，但是在两次尝试之间暂定一下是一个很好的想法
 * （即使代价是阻塞线程）
 */
 Backoff backoff() default @Backoff();

 /**
 * 在{@code SimpleRetryPolicy.canRetry()}返回true之后指定一个计算表达式 - 可用来有条件的取消重试。
 * 仅在调用抛出一个异常后。求值的root对象为上一次的异常 {@code Throwable}。
 * 可以引用上下文中的其他beans。
 * 例如:
 * {@code "message.contains('you can retry this')"}.
 * and
 * {@code "@someBean.shouldRetry(#root)"}.
 * @since 1.2
 */
 String exceptionExpression() default "";
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Import(RetryConfiguration.class)
@Documented
public @interface Backoff {

 /**
 * 与 {@link #delay()} 属性同义
 *
 * 返回延迟多少毫秒后重试（默认为1000毫秒）
 */
 long value() default 1000;

 /**
 * 一个标准的再重试周期。在指数函数情况下用作初始值，在始终如一的情况下（固定周期值情况）
 * 用作最小值。
 * @return the initial or canonical backoff period in milliseconds (default 1000)？？？
 */
 long delay() default 0;

 /**
 * 重试之间最大等待（毫秒）时间。如果小于 {@link #delay()} 则忽略。
 * @return the maximum delay between retries (default 0 = ignored)
 */
 long maxDelay() default 0;

 /**
 * 如果是正数，则用于生成下次再重试等待时间的乘数。
 * 返回一个乘数用于计算下次再重试延迟（默认为0忽略）
 */
 double multiplier() default 0;

 /**
 * 标准再重试周期求值表达式。在指数情况下用作初始值，始终如一的情况下用作最小值。
 * 重写 {@link #delay()}.
 * @since 1.2
 */
 String delayExpression() default "";

 /**
 * 在重试之间最大等待（毫秒）数的求值表达式。
 * 如果小于 {@link #delay()} 则忽略。
 * 重写 {@link #maxDelay()}
 * 默认为0，忽略
 * @since 1.2
 */
 String maxDelayExpression() default "";

 /**
 * 表达式求值作为生成下次再重试延迟的乘数
 * 重写 {@link #multiplier()}。
 * @since 1.2
 */
 String multiplierExpression() default "";

 /**
 * 在指数情况下 ({@link #multiplier()} > 0) 设置该值为true将使再重试延迟随机化，
 * 使最大延迟为先前延迟的乘数倍数，并使这两个延迟值之间分布均匀。
 * 默认为false
 */
 boolean random() default false;
}

@Component
public class MyTask {

  @Retryable
  public void doExecute(){
    System.out.println("## current Date:" + new Date());
    throw new RuntimeException("my test");
  }
}

RetryTemplate.builder()
   .maxAttempts(10)
   .exponentialBackoff(100, 2, 10000)
   .retryOn(IOException.class)
   .traversingCauses()
   .build();

RetryTemplate.builder()
   .fixedBackoff(10)
   .withinMillis(3000)
   .build();

RetryTemplate.builder()
   .infiniteRetry()
   .retryOn(IOException.class)
   .uniformRandomBackoff(1000, 3000)
   .build();

@Component
public class MyTask {

  private Long lastTime = null;

  @Retryable( backoff = @Backoff( delay = 1000, multiplier = 2, random = true), maxAttempts = 10)
  public void doExecute(){
    if (lastTime == null) {
      lastTime = System.currentTimeMillis();
    }
    System.out.println("## actual delay:" + (System.currentTimeMillis() - lastTime) );
    RuntimeException runtimeException = new RuntimeException("my test");
    throw runtimeException;
  }
}

@Component
public class MyTask {

  private Long lastTime = null;

  public boolean canRetry(RuntimeException runtimeException) {
    System.out.println("canRetry:"+runtimeException.hashCode());
    return true;
  }

  @Retryable(exceptionExpression = "#{@myTask.canRetry(#root)}", backoff = @Backoff(delay = 1000, multiplier = 2, random = true))
  public void doExecute() {
    if (lastTime == null) {
      lastTime = System.currentTimeMillis();
    }
    System.out.println("## actual delay:" + (System.currentTimeMillis() - lastTime));
    RuntimeException runtimeException = new RuntimeException("my test");
    System.out.println("doExecute:"+runtimeException.hashCode());
    throw runtimeException;
  }
}