Retrying on failure with Resilience4J and Aspects

 1// src/main/java/dev/mflash/guides/retry/annotation/RetryOnFailure.java
 2
 3@Retention(RetentionPolicy.RUNTIME)
 4@Target(ElementType.METHOD)
 5public @interface RetryOnFailure {
 6
 7  int attempts() default 3;
 8
 9  BackoffStrategy strategy() default BackoffStrategy.EXPONENTIAL_RANDOM;
10
11  long interval() default IntervalFunction.DEFAULT_INITIAL_INTERVAL;
12
13  ChronoUnit unit() default ChronoUnit.MILLIS;
14
15  double randomizationFactor() default IntervalFunction.DEFAULT_RANDOMIZATION_FACTOR;
16
17  double multiplier() default IntervalFunction.DEFAULT_MULTIPLIER;
18
19  Class<? extends Throwable>[] retryExceptions() default { Throwable.class };
20
21  Class<? extends Throwable>[] ignoreExceptions() default { };
22}

 1// src/main/java/dev/mflash/guides/retry/annotation/BackoffStrategy.java
 2
 3public enum BackoffStrategy {
 4  RANDOM, 
 5  LINEAR, 
 6  LINEAR_RANDOM, 
 7  GEOMETRIC, 
 8  GEOMETRIC_RANDOM, 
 9  EXPONENTIAL, 
10  EXPONENTIAL_RANDOM
11}

 1// src/main/java/dev/mflash/guides/retry/aspect/RetryOnFailureIntervalFunctions.java
 2
 3public class RetryOnFailureIntervalFunctions {
 4
 5  private static IntervalFunction ofLinear(long interval) {
 6    Function<Long, Long> linearBackoffFn = previous -> previous + interval;
 7    return IntervalFunction.of(interval, linearBackoffFn);
 8  }
 9
10  private static IntervalFunction ofLinearRandom(long interval, double randomizationFactor) {
11    return attempt -> (long) randomize(ofLinear(interval).apply(attempt), randomizationFactor);
12  }
13
14  private static IntervalFunction ofGeometric(long interval, double multiplier) {
15    Function<Long, Long> geometricBackoffFn = previous -> Math.round(previous * multiplier);
16    return IntervalFunction.of(interval, geometricBackoffFn);
17  }
18
19  private static IntervalFunction ofGeometricRandom(long interval, double multiplier, double randomizationFactor) {
20    return attempt -> (long) randomize(ofGeometric(interval, multiplier).apply(attempt), randomizationFactor);
21  }
22
23  static double randomize(double current, double randomizationFactor) {
24    final double delta = randomizationFactor * current;
25    final double min = current - delta;
26    final double max = current + delta;
27
28    return (min + (Math.random() * (max - min + 1)));
29  }
30}

 1// src/main/java/dev/mflash/guides/retry/aspect/RetryOnFailureIntervalFunctions.java
 2
 3public class RetryOnFailureIntervalFunctions {
 4
 5  public static IntervalFunction of(RetryOnFailure retry) {
 6
 7    BackoffStrategy strategy = retry.strategy();
 8    long interval = retry.interval();
 9    double randomizationFactor = retry.randomizationFactor();
10    double multiplier = retry.multiplier();
11
12    return switch (strategy) {
13      case RANDOM -> ofRandom(interval, randomizationFactor);
14      case LINEAR -> ofLinear(interval);
15      case LINEAR_RANDOM -> ofLinearRandom(interval, randomizationFactor);
16      case GEOMETRIC -> ofGeometric(interval, multiplier);
17      case GEOMETRIC_RANDOM -> ofGeometricRandom(interval, multiplier, randomizationFactor);
18      case EXPONENTIAL -> ofExponential(interval);
19      default -> ofExponentialRandom(interval, multiplier, randomizationFactor);
20    };
21  }
22
23  private static IntervalFunction ofRandom(long interval, double randomizationFactor) {
24    return IntervalFunction.ofRandomized(interval, randomizationFactor);
25  }
26
27  private static IntervalFunction ofLinear(long interval) {
28    Function<Long, Long> linearBackoffFn = previous -> previous + interval;
29    return IntervalFunction.of(interval, linearBackoffFn);
30  }
31
32  private static IntervalFunction ofLinearRandom(long interval, double randomizationFactor) {
33    return attempt -> (long) randomize(ofLinear(interval).apply(attempt), randomizationFactor);
34  }
35
36  private static IntervalFunction ofGeometric(long interval, double multiplier) {
37    Function<Long, Long> geometricBackoffFn = previous -> Math.round(previous * multiplier);
38    return IntervalFunction.of(interval, geometricBackoffFn);
39  }
40
41  private static IntervalFunction ofGeometricRandom(long interval, double multiplier, double randomizationFactor) {
42    return attempt -> (long) randomize(ofGeometric(interval, multiplier).apply(attempt), randomizationFactor);
43  }
44
45  private static IntervalFunction ofExponential(long interval) {
46    return IntervalFunction.ofExponentialBackoff(interval);
47  }
48
49  private static IntervalFunction ofExponentialRandom(long interval, double multiplier, double randomizationFactor) {
50    return IntervalFunction.ofExponentialRandomBackoff(interval, multiplier, randomizationFactor);
51  }
52
53  static double randomize(double current, double randomizationFactor) {
54    final double delta = randomizationFactor * current;
55    final double min = current - delta;
56    final double max = current + delta;
57
58    return (min + (Math.random() * (max - min + 1)));
59  }
60}

 1// src/main/java/dev/mflash/guides/retry/aspect/RetryOnFailureAspect.java
 2
 3@Aspect
 4@Component
 5public class RetryOnFailureAspect {
 6
 7  @Around("@annotation(dev.mflash.guides.retry.annotation.RetryOnFailure)")
 8  public Object retry(ProceedingJoinPoint point) throws Throwable {
 9    var methodSignature = (MethodSignature) point.getSignature();
10    Method method = methodSignature.getMethod();
11    var target = Modifier.isStatic(method.getModifiers()) ? method.getDeclaringClass() : point.getTarget();
12    var methodName = method.getName();
13
14    Logger logger = LoggerFactory.getLogger(target.getClass());
15    var annotation = method.getAnnotation(RetryOnFailure.class);
16    int attempts = annotation.attempts();
17    long interval = annotation.interval();
18    ChronoUnit unit = annotation.unit();
19    Class<? extends Throwable>[] retryExceptions = annotation.retryExceptions();
20    Class<? extends Throwable>[] ignoreExceptions = annotation.ignoreExceptions();
21
22    var intervalFunction = RetryOnFailureIntervalFunctions.of(annotation);
23    var retryConfiguration = RetryConfig.custom()
24        .maxAttempts(attempts)
25        .waitDuration(Duration.of(interval, unit))
26        .intervalFunction(intervalFunction)
27        .retryExceptions(retryExceptions)
28        .ignoreExceptions(ignoreExceptions)
29        .build();
30    var retryRegistry = RetryRegistry.of(retryConfiguration);
31    var retry = retryRegistry.retry(methodName, retryConfiguration);
32    var publisher = retry.getEventPublisher();
33    publisher.onRetry(event -> logger.warn(event.toString()));
34
35    Supplier<Object> responseSupplier = Retry.decorateSupplier(retry, getProceed(point));
36
37    return responseSupplier.get();
38  }
39
40  private static Supplier<Object> getProceed(ProceedingJoinPoint point) {
41    return () -> {
42      try {
43        return point.proceed();
44      } catch (Throwable t) {
45        throw new RuntimeException(t);
46      }
47    };
48  }
49}

 1// src/main/java/dev/mflash/guides/retry/RandomlyFailingController.java
 2
 3@RestController
 4@RequestMapping("/random")
 5public class RandomlyFailingController {
 6
 7  private final RandomlyFailingService service;
 8
 9  public RandomlyFailingController(RandomlyFailingService service) {
10    this.service = service;
11  }
12
13  @GetMapping
14  public double getRandom() {
15    return service.random();
16  }
17}

 1// src/main/java/dev/mflash/guides/retry/RandomlyFailingService.java
 2
 3@Service
 4public class RandomlyFailingService {
 5
 6  @RetryOnFailure
 7  public double random() {
 8    double random = Math.random();
 9
10    if (random <= 0.5) {
11      throw new ArithmeticException("Value <= 0.5");
12    }
13
14    return random;
15  }
16}

 1// src/test/java/dev/mflash/guides/retry/aspect/AspectAppender.java
 2
 3public class AspectAppender extends AppenderBase<ILoggingEvent> {
 4
 5  List<ILoggingEvent> events = new ArrayList<>();
 6
 7  protected @Override void append(ILoggingEvent event) {
 8    events.add(event);
 9  }
10}

 1// src/test/java/dev/mflash/guides/retry/aspect/RetryOnFailureTestService.java
 2
 3@Service
 4public class RetryOnFailureTestService {
 5
 6  @RetryOnFailure
 7  public double attempt(double value) {
 8    if (value <= 0) {
 9      throw new ArithmeticException("Value <= 0");
10    }
11
12    return value;
13  }
14}

 1// src/test/java/dev/mflash/guides/retry/aspect/RetryOnFailureAspectTest.java
 2
 3@ExtendWith(SoftAssertionsExtension.class)
 4class RetryOnFailureAspectTest {
 5
 6  private RetryOnFailureTestService service;
 7  private AspectAppender appender;
 8
 9  @BeforeEach
10  void setUp() {
11    var retryAspect = new RetryOnFailureAspect();
12    var aspectJProxyFactory = new AspectJProxyFactory(new RetryOnFailureTestService());
13    aspectJProxyFactory.addAspect(retryAspect);
14    var aopProxy = new DefaultAopProxyFactory().createAopProxy(aspectJProxyFactory);
15
16    service = (RetryOnFailureTestService) aopProxy.getProxy();
17    appender = new AspectAppender();
18    appender.start();
19
20    var logger = (Logger) LoggerFactory.getLogger(RetryOnFailureTestService.class);
21    logger.addAppender(appender);
22  }
23
24  @AfterEach
25  void tearDown() {
26    appender.stop();
27  }
28
29  @Test
30  @DisplayName("Advice should fire with retries on failure")
31  void adviceShouldFireWithRetriesOnFailure(SoftAssertions softly) {
32    var thrown = catchThrowable(() -> service.attempt(0));
33
34    softly.assertThat(appender.events).hasSize(2);
35    softly.assertThat(thrown).isInstanceOf(RuntimeException.class);
36    softly.assertThat(appender.events.stream().anyMatch(
37        event -> event.getMessage().contains("Retry 'attempt', waiting") && event.getMessage()
38            .contains("Last attempt failed with exception"))).isTrue();
39  }
40
41  @Test
42  @DisplayName("Advice should not fire on success")
43  void adviceShouldNotFireOnSuccess() {
44    service.attempt(1);
45    service.attempt(2);
46
47    assertThat(appender.events).isEmpty();
48  }
49}