com.github.rholder.retry

Class Retryer<V>

java.lang.Object

com.github.rholder.retry.Retryer<V>

Type Parameters:

V - the type of the call return value

public final class Retryer<V>
extends java.lang.Object

A retryer, which executes a call, and retries it until it succeeds, or a stop strategy decides to stop retrying. A wait strategy is used to sleep between attempts. The strategy to decide if the call succeeds or not is also configurable.

A retryer can also wrap the callable into a RetryerCallable, which can be submitted to an executor.

Retryer instances are better constructed with a RetryerBuilder. A retryer is thread-safe, provided the arguments passed to its constructor are thread-safe.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Retryer.RetryerCallable<X> A Callable which wraps another Callable in order to add retrying behavior from a given Retryer instance.

Constructor Summary

Constructors

Constructor and Description
Retryer(AttemptTimeLimiter<V> attemptTimeLimiter, StopStrategy stopStrategy, WaitStrategy waitStrategy, BlockStrategy blockStrategy, com.google.common.base.Predicate<Attempt<V>> rejectionPredicate) Constructor
Retryer(AttemptTimeLimiter<V> attemptTimeLimiter, StopStrategy stopStrategy, WaitStrategy waitStrategy, BlockStrategy blockStrategy, com.google.common.base.Predicate<Attempt<V>> rejectionPredicate, java.util.Collection<RetryListener> listeners) Constructor
Retryer(AttemptTimeLimiter<V> attemptTimeLimiter, StopStrategy stopStrategy, WaitStrategy waitStrategy, com.google.common.base.Predicate<Attempt<V>> rejectionPredicate) Constructor
Retryer(StopStrategy stopStrategy, WaitStrategy waitStrategy, com.google.common.base.Predicate<Attempt<V>> rejectionPredicate) Constructor

Method Summary

Methods

Modifier and Type	Method and Description
V	call(java.util.concurrent.Callable<V> callable) Executes the given callable.
Retryer.RetryerCallable<V>	wrap(java.util.concurrent.Callable<V> callable) Wraps the given Callable in a Retryer.RetryerCallable, which can be submitted to an executor.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Retryer

public Retryer(@Nonnull
       StopStrategy stopStrategy,
       @Nonnull
       WaitStrategy waitStrategy,
       @Nonnull
       com.google.common.base.Predicate<Attempt<V>> rejectionPredicate)

Constructor

Parameters:

stopStrategy - the strategy used to decide when the retryer must stop retrying

waitStrategy - the strategy used to decide how much time to sleep between attempts

rejectionPredicate - the predicate used to decide if the attempt must be rejected or not. If an attempt is rejected, the retryer will retry the call, unless the stop strategy indicates otherwise or the thread is interrupted.

Retryer

public Retryer(@Nonnull
       AttemptTimeLimiter<V> attemptTimeLimiter,
       @Nonnull
       StopStrategy stopStrategy,
       @Nonnull
       WaitStrategy waitStrategy,
       @Nonnull
       com.google.common.base.Predicate<Attempt<V>> rejectionPredicate)

Constructor

Parameters:

attemptTimeLimiter - to prevent from any single attempt from spinning infinitely

stopStrategy - the strategy used to decide when the retryer must stop retrying

waitStrategy - the strategy used to decide how much time to sleep between attempts

rejectionPredicate - the predicate used to decide if the attempt must be rejected or not. If an attempt is rejected, the retryer will retry the call, unless the stop strategy indicates otherwise or the thread is interrupted.

Retryer

public Retryer(@Nonnull
       AttemptTimeLimiter<V> attemptTimeLimiter,
       @Nonnull
       StopStrategy stopStrategy,
       @Nonnull
       WaitStrategy waitStrategy,
       @Nonnull
       BlockStrategy blockStrategy,
       @Nonnull
       com.google.common.base.Predicate<Attempt<V>> rejectionPredicate)

Constructor

Parameters:

attemptTimeLimiter - to prevent from any single attempt from spinning infinitely

stopStrategy - the strategy used to decide when the retryer must stop retrying

waitStrategy - the strategy used to decide how much time to sleep between attempts

blockStrategy - the strategy used to decide how to block between retry attempts; eg, Thread#sleep(), latches, etc.

rejectionPredicate - the predicate used to decide if the attempt must be rejected or not. If an attempt is rejected, the retryer will retry the call, unless the stop strategy indicates otherwise or the thread is interrupted.

Retryer

@Beta
public Retryer(@Nonnull
            AttemptTimeLimiter<V> attemptTimeLimiter,
            @Nonnull
            StopStrategy stopStrategy,
            @Nonnull
            WaitStrategy waitStrategy,
            @Nonnull
            BlockStrategy blockStrategy,
            @Nonnull
            com.google.common.base.Predicate<Attempt<V>> rejectionPredicate,
            @Nonnull
            java.util.Collection<RetryListener> listeners)

Constructor

Parameters:

attemptTimeLimiter - to prevent from any single attempt from spinning infinitely

stopStrategy - the strategy used to decide when the retryer must stop retrying

waitStrategy - the strategy used to decide how much time to sleep between attempts

blockStrategy - the strategy used to decide how to block between retry attempts; eg, Thread#sleep(), latches, etc.

rejectionPredicate - the predicate used to decide if the attempt must be rejected or not. If an attempt is rejected, the retryer will retry the call, unless the stop strategy indicates otherwise or the thread is interrupted.

listeners - collection of retry listeners

Method Detail

call

public V call(java.util.concurrent.Callable<V> callable)
       throws java.util.concurrent.ExecutionException,
              RetryException

Executes the given callable. If the rejection predicate accepts the attempt, the stop strategy is used to decide if a new attempt must be made. Then the wait strategy is used to decide how much time to sleep and a new attempt is made.

Parameters:

callable - the callable task to be executed

Returns:

the computed result of the given callable

Throws:

java.util.concurrent.ExecutionException - if the given callable throws an exception, and the rejection predicate considers the attempt as successful. The original exception is wrapped into an ExecutionException.

RetryException - if all the attempts failed before the stop strategy decided to abort, or the thread was interrupted. Note that if the thread is interrupted, this exception is thrown and the thread's interrupt status is set.

wrap

public Retryer.RetryerCallable<V> wrap(java.util.concurrent.Callable<V> callable)

Wraps the given Callable in a Retryer.RetryerCallable, which can be submitted to an executor. The returned Retryer.RetryerCallable uses this Retryer instance to call the given Callable.

Parameters:

callable - the callable to wrap

Returns:

a Retryer.RetryerCallable that behaves like the given Callable with retry behavior defined by this Retryer