Design pattern for "retrying" logic that failed?

Question

I'm writing some reconnect logic to periodically attempt to establish a connection to a remote endpoint which went down. Essentially, the code looks like this:

public void establishConnection() {     try {         this.connection = newConnection();     } catch (IOException e) {         // connection failed, try again.         try { Thread.sleep(1000); } catch (InterruptedException e) {};          establishConnection();     } } 

I've solved this general problem with code similar to the above on many occasions, but I feel largely unsatisfied with the result. Is there a design pattern designed for dealing with this issue?

Answer 1

Shameless plug: I have implemented some classes to allow retrying operations. The library is not made available yet, but you may fork it on github. And a fork exists.

It allows building a Retryer with various flexible strategies. For example:

Retryer retryer =      RetryerBuilder.newBuilder()                   .withWaitStrategy(WaitStrategies.fixedWait(1, TimeUnit.SECOND))                   .withStopStrategy(StopStrategies.stopAfterAttempt(3))                   .retryIfExceptionOfType(IOException.class)                   .build(); 

And you can then execute a callable (or several ones) with the Retryer:

retryer.call(new Callable<Void>() {     public Void call() throws IOException {         connection = newConnection();         return null;     } } 

Answer 2

You could try the Idempotent Retry Pattern.