How to simplify retry code block with java 8 features

Question

In my code I have a section which tries to connect to some external interface, if it fails, then it will retry it a fixed number of times. The code works, but is somewhat ugly. I am wondering whether this can be done in a more elegant way using some fancy Java8 features?

int count = 0;
final int maxRetries = 3;
while ( count < maxRetries )
{
   try
   {
     // Some Code
     // break out of loop on success
   }
   catch ( final ExecutionException e )
   {
      LOG.debug( "retrying..." );
      if ( ++count >= maxRetries )
      {
         LOG.debug( "do something else...");
         //do something else
      }
   }
}

Answer 1

What you can do is separate out the retry logic. You'll need some ancillary scaffolding:

interface ThrowingTask {
    void run() throws ExecutionException;
}

Now, you write:

boolean runWithRetries(int maxRetries, ThrowingTask t) { 
    int count = 0;
    while (count < maxRetries) {
        try {
            t.run();
            return true;
        }
        catch (ExecutionException e) {
            if (++count >= maxRetries)
                return false;
        }
    }
}

Now, you can run things with retries without having to conflate your task logic with your retry logic:

runWithRetries(MAX_RETRIES, () -> { /* do stuff */ });

You can tweak this as you like to accept lambdas which are called on retry, return the retry count, etc etc. But the game is to write methods like runWithRetries which capture the control flow but abstract over what behavior needs to be done -- so you only have to write your retry loop once, and then fill in the actual behavior you want wherever needed.

Answer 2

Using Failsafe (which I authored):

RetryPolicy retryPolicy = new RetryPolicy()
  .retryOn(ExecutionException.class)
  .withMaxRetries(3);

Failsafe.with(retryPolicy)
  .onRetry(r -> LOG.debug("retrying..."))
  .withFallback(e -> LOG.debug("do something else..."))
  .run(() -> someCode());

It's about as simple and expressive as you can get for your use case.

Answer 3

Well, more functional approach in my opinion will be to use Trymonad which unfortunately is not there for us in jdk 8 :(

Nevertheless you still can use better-monads library which provides it. Having that you can come up with some implementation like this:

public static <Out> Try<Out> tryTimes(int times, TrySupplier<Out> attempt) {
        Supplier<Try<Out>> tryAttempt = () -> Try.ofFailable(attempt::get);

        return IntStream.range(1, times)
                .mapToObj(i -> tryAttempt)
                .reduce(tryAttempt, (acc, current) -> () -> acc.get().recoverWith(error -> current.get()))
                .get();
    }

Long story short this function just chains calls of tryAttempt and in case of failed attempt tries to recoverWith the next call of tryAttempt. Client code is going to look like this:

tryTimes(10, () -> {
            // all the logic to do your possibly failing stuff
        }
);

As a result client code is going to get Try<T> which can be unpacked by direct call of .get() (in case of success returns the value, in case of failure throws underlying exception) or with other methods described in library documentation.

Hope it helps.

UPDATE:

This can be done also in functional way using the filter, findFirst and limit and without any external libraries:

interface ThrowingSupplier<Out> { Out supply() throws Exception; }

public static <Out> Optional<Out> tryTimes(int times, ThrowingSupplier<Out> attempt) {
    Supplier<Optional<Out>> catchingSupplier = () -> {
        try {
            return Optional.ofNullable(attempt.supply());
        } catch (Exception e) {
            return Optional.empty();
        }
    };
    return Stream.iterate(catchingSupplier, i -> i)
            .limit(times)
            .map(Supplier::get)
            .filter(Optional::isPresent)
            .findFirst()
            .flatMap(Function.identity());
}

The client code remains the same. Also, please note that it is not going to evaluate expression times times, but will stop on the first successful attempt.

Answer 4

Similar to some of the suggested approaches, you could create a class that separates the retry functionality from the rest of you code. The class below that does just that and also allows you to take an input and return some result:

public class Retrier<T, R> {
    private static final int DEFAULT_RETRY_COUNT = 3;
    private int retryCount;
    private Function<T, R> retriable;
    private T input;

    public Retrier(T input, Function<T, R> retriable) {
        this(input, retriable, DEFAULT_RETRY_COUNT);
    }

    public Retrier(T input, Function<T, R> retriable, int retryCount) {
        this.retryCount = retryCount;
        this.retriable = retriable;
        this.input = input;
    }

    public R execute() {
        int count = 0;
        while(true) {
            try {
                return retriable.apply(input);
            }
            catch (Exception e) {
                if (++count >= retryCount) {
                    throw e;
                }
            }
        }
    }
}

And then you can use it like this e.g.

String result = new Retrier<String, String>("input", input -> {/* process the input and return the result*/}).execute();

And wherever your code will throw an exception it will be retried.

Answer 5

You can try this static method

/**
 * Author: Mak Sophea
 * Date: 07/17/2020
 */
public class RetryUtils {
    private static final Logger log = LoggerFactory.getLogger(RetryUtils.class);

    public static interface CallToRetry {
        void process() throws Exception;
    }

    public static boolean withRetry(int maxTimes, long intervalWait, CallToRetry call) throws Exception {
        if (maxTimes <= 0) {
            throw new IllegalArgumentException("Must run at least one time");
        }
        if (intervalWait <= 0) {
            throw new IllegalArgumentException("Initial wait must be at least 1");
        }
        Exception thrown = null;
        for (int i = 0; i < maxTimes; i++) {
            try {
                call.process();
                return true;
            } catch (Exception e) {
                thrown = e;
                log.info("Encountered failure on {} due to {}, attempt retry {} of {}", call.getClass().getName() , e.getMessage(), (i + 1), maxTimes, e);
            }
            try {
                Thread.sleep(intervalWait);
            } catch (InterruptedException wakeAndAbort) {
                break;
            }
        }
        throw thrown;
    }
}

You can call it by RetryUtils.withRetry(MAX_RETRY, 3000, () -> { // put the implementation here });