RetryPolicy (Failsafe 1.1.0 API)

java.lang.Object
- net.jodah.failsafe.RetryPolicy

```
public class RetryPolicy
extends Object
```
A policy that defines when retries should be performed.
The retryOn methods describe when a retry should be performed for a particular failure. The retryWhen method describes when a retry should be performed for a particular result. If multiple retryOn or retryWhen conditions are specified, any matching condition can allow a retry. The abortOn, abortWhen and abortIf methods describe when retries should be aborted.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`RetryPolicy.DelayFunction<R,F extends Throwable>` A functional interface for computing delays between retries in conjunction with `withDelay(DelayFunction)`.

Constructor Summary

Constructors
Constructor and Description

RetryPolicy()
Creates a retry policy that always retries with no delay.

RetryPolicy(RetryPolicy rp)
Copy constructor.

Constructors
Constructor and Description
`RetryPolicy()` Creates a retry policy that always retries with no delay.
`RetryPolicy(RetryPolicy rp)` Copy constructor.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`<T> RetryPolicy`	`abortIf(BiPredicate<T,? extends Throwable> completionPredicate)` Specifies that retries should be aborted if the `completionPredicate` matches the completion result.
`<T> RetryPolicy`	`abortIf(Predicate<T> resultPredicate)` Specifies that retries should be aborted if the `resultPredicate` matches the result.
`RetryPolicy`	`abortOn(Class<? extends Throwable>... failures)` Specifies when retries should be aborted.
`RetryPolicy`	`abortOn(Class<? extends Throwable> failure)` Specifies when retries should be aborted.
`RetryPolicy`	`abortOn(List<Class<? extends Throwable>> failures)` Specifies when retries should be aborted.
`RetryPolicy`	`abortOn(Predicate<? extends Throwable> failurePredicate)` Specifies that retries should be aborted if the `failurePredicate` matches the failure.
`RetryPolicy`	`abortWhen(Object result)` Specifies that retries should be aborted if the execution result matches the `result`.
`boolean`	`allowsRetries()` Returns whether the policy allows retries according to the configured `maxRetries` and `maxDuration`.
`boolean`	`canAbortFor(Object result, Throwable failure)` Returns whether an execution result can be aborted given the configured abort conditions.
`boolean`	`canApplyDelayFn(Object result, Throwable failure)` Returns whether any configured delay function can be applied for an execution result.
`boolean`	`canRetryFor(Object result, Throwable failure)` Returns whether an execution result can be retried given the configured abort conditions.
`RetryPolicy`	`copy()` Returns a copy of this RetryPolicy.
`Duration`	`getDelay()` Returns the delay between retries.
`double`	`getDelayFactor()` Returns the delay factor for backoff retries.
`RetryPolicy.DelayFunction<?,? extends Throwable>`	`getDelayFn()` Returns the function that determines the next delay given a failed attempt with the given `Throwable`.
`Duration`	`getDelayMax()` Returns the max delay between retries.
`Duration`	`getDelayMin()` Returns the min delay between retries.
`Duration`	`getJitter()` Returns the jitter, else `null` if none has been configured.
`double`	`getJitterFactor()` Returns the jitter factor, else `0.0` if none has been configured.
`Duration`	`getMaxDelay()` Returns the max delay between backoff retries.
`Duration`	`getMaxDuration()` Returns the max duration to perform retries for.
`int`	`getMaxRetries()` Returns the max retries.
`<T> RetryPolicy`	`retryIf(BiPredicate<T,? extends Throwable> completionPredicate)` Specifies that a retry should occur if the `completionPredicate` matches the completion result and the retry policy is not exceeded.
`<T> RetryPolicy`	`retryIf(Predicate<T> resultPredicate)` Specifies that a retry should occur if the `resultPredicate` matches the result and the retry policy is not exceeded.
`RetryPolicy`	`retryOn(Class<? extends Throwable>... failures)` Specifies the failures to retry on.
`RetryPolicy`	`retryOn(Class<? extends Throwable> failure)` Specifies the failure to retry on.
`RetryPolicy`	`retryOn(List<Class<? extends Throwable>> failures)` Specifies the failures to retry on.
`RetryPolicy`	`retryOn(Predicate<? extends Throwable> failurePredicate)` Specifies that a retry should occur if the `failurePredicate` matches the failure and the retry policy is not exceeded.
`RetryPolicy`	`retryWhen(Object result)` Specifies that a retry should occur if the execution result equals the `result` and the retry policy is not exceeded.
`RetryPolicy`	`withBackoff(long delay, long maxDelay, TimeUnit timeUnit)` Sets the `delay` between retries, exponentially backing off to the `maxDelay` and multiplying successive delays by a factor of 2.
`RetryPolicy`	`withBackoff(long delay, long maxDelay, TimeUnit timeUnit, double delayFactor)` Sets the `delay` between retries, exponentially backing off to the `maxDelay` and multiplying successive delays by the `delayFactor`.
`RetryPolicy`	`withDelay(long delayMin, long delayMax, TimeUnit timeUnit)` Sets a random delay between the `delayMin` and `delayMax` (inclusive) to occur between retries.
`RetryPolicy`	`withDelay(long delay, TimeUnit timeUnit)` Sets the `delay` to occur between retries.
`RetryPolicy`	`withDelay(RetryPolicy.DelayFunction<?,? extends Throwable> delayFunction)` Sets the `delayFunction` that computes the next delay before retrying.
`<F extends Throwable> RetryPolicy`	`withDelayOn(RetryPolicy.DelayFunction<Object,F> delayFunction, Class<F> failure)` Sets the `delayFunction` that computes the next delay before retrying.
`<R> RetryPolicy`	`withDelayWhen(RetryPolicy.DelayFunction<R,? extends Throwable> delayFunction, R result)` Sets the `delayFunction` that computes the next delay before retrying.
`RetryPolicy`	`withJitter(double jitterFactor)` Sets the `jitterFactor` to randomly vary retry delays by.
`RetryPolicy`	`withJitter(long jitter, TimeUnit timeUnit)` Sets the `jitter` to randomly vary retry delays by.
`RetryPolicy`	`withMaxDuration(long maxDuration, TimeUnit timeUnit)` Sets the max duration to perform retries for, else the execution will be failed.
`RetryPolicy`	`withMaxRetries(int maxRetries)` Sets the max number of retries to perform.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - RetryPolicy
```
public RetryPolicy()
```
    Creates a retry policy that always retries with no delay.
  - RetryPolicy
```
public RetryPolicy(RetryPolicy rp)
```
    Copy constructor.
- Method Detail
  - abortIf
```
public <T> RetryPolicy abortIf(BiPredicate<T,? extends Throwable> completionPredicate)
```
    Specifies that retries should be aborted if the completionPredicate matches the completion result.
    
    Throws:
    
    NullPointerException - if completionPredicate is null
  - abortIf
```
public <T> RetryPolicy abortIf(Predicate<T> resultPredicate)
```
    Specifies that retries should be aborted if the resultPredicate matches the result.
    
    Throws:
    
    NullPointerException - if resultPredicate is null
  - abortOn
```
public RetryPolicy abortOn(Class<? extends Throwable> failure)
```
    Specifies when retries should be aborted. Any failure that is assignable from the failure will be result in retries being aborted.
    
    Throws:
    
    NullPointerException - if failure is null
  - abortOn
```
public RetryPolicy abortOn(Class<? extends Throwable>... failures)
```
    Specifies when retries should be aborted. Any failure that is assignable from the failures will be result in retries being aborted.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is empty
  - abortOn
```
public RetryPolicy abortOn(List<Class<? extends Throwable>> failures)
```
    Specifies when retries should be aborted. Any failure that is assignable from the failures will be result in retries being aborted.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is null or empty
  - abortOn
```
public RetryPolicy abortOn(Predicate<? extends Throwable> failurePredicate)
```
    Specifies that retries should be aborted if the failurePredicate matches the failure.
    
    Throws:
    
    NullPointerException - if failurePredicate is null
  - abortWhen
```
public RetryPolicy abortWhen(Object result)
```
    Specifies that retries should be aborted if the execution result matches the result.
  - allowsRetries
```
public boolean allowsRetries()
```
    Returns whether the policy allows retries according to the configured maxRetries and maxDuration.
    
    See Also:
    
    withMaxRetries(int), withMaxDuration(long, TimeUnit)
  - canAbortFor
```
public boolean canAbortFor(Object result,
                           Throwable failure)
```
    Returns whether an execution result can be aborted given the configured abort conditions.
    
    See Also:
    
    abortIf(BiPredicate), abortIf(Predicate), abortOn(Class...), abortOn(List), abortOn(Predicate), abortWhen(Object)
  - canRetryFor
```
public boolean canRetryFor(Object result,
                           Throwable failure)
```
    Returns whether an execution result can be retried given the configured abort conditions.
    
    See Also:
    
    retryIf(BiPredicate), retryIf(Predicate), retryOn(Class...), retryOn(List), retryOn(Predicate), retryWhen(Object)
  - canApplyDelayFn
```
public boolean canApplyDelayFn(Object result,
                               Throwable failure)
```
    Returns whether any configured delay function can be applied for an execution result.
    
    See Also:
    
    withDelay(DelayFunction), withDelayOn(DelayFunction, Class), withDelayWhen(DelayFunction, Object)
  - copy
```
public RetryPolicy copy()
```
    Returns a copy of this RetryPolicy.
  - getDelay
```
public Duration getDelay()
```
    Returns the delay between retries. Defaults to Duration.NONE.
    
    See Also:
    
    withDelay(long, TimeUnit), withBackoff(long, long, TimeUnit), withBackoff(long, long, TimeUnit, double)
  - getDelayMin
```
public Duration getDelayMin()
```
    Returns the min delay between retries.
    
    See Also:
    
    withDelay(long, long, TimeUnit)
  - getDelayMax
```
public Duration getDelayMax()
```
    Returns the max delay between retries.
    
    See Also:
    
    withDelay(long, long, TimeUnit)
  - getDelayFn
```
public RetryPolicy.DelayFunction<?,? extends Throwable> getDelayFn()
```
    Returns the function that determines the next delay given a failed attempt with the given Throwable.
    
    See Also:
    
    withDelay(DelayFunction), withDelayOn(DelayFunction, Class), withDelayWhen(DelayFunction, Object)
  - getDelayFactor
```
public double getDelayFactor()
```
    Returns the delay factor for backoff retries.
    
    See Also:
    
    withBackoff(long, long, TimeUnit, double)
  - getJitter
```
public Duration getJitter()
```
    Returns the jitter, else null if none has been configured.
    
    See Also:
    
    withJitter(long, TimeUnit)
  - getJitterFactor
```
public double getJitterFactor()
```
    Returns the jitter factor, else 0.0 if none has been configured.
    
    See Also:
    
    withJitter(double)
  - getMaxDelay
```
public Duration getMaxDelay()
```
    Returns the max delay between backoff retries.
    
    See Also:
    
    withBackoff(long, long, TimeUnit)
  - getMaxDuration
```
public Duration getMaxDuration()
```
    Returns the max duration to perform retries for.
    
    See Also:
    
    withMaxDuration(long, TimeUnit)
  - getMaxRetries
```
public int getMaxRetries()
```
    Returns the max retries. Defaults to 100, which retries forever.
    
    See Also:
    
    withMaxRetries(int)
  - retryIf
```
public <T> RetryPolicy retryIf(BiPredicate<T,? extends Throwable> completionPredicate)
```
    Specifies that a retry should occur if the completionPredicate matches the completion result and the retry policy is not exceeded.
    
    Throws:
    
    NullPointerException - if completionPredicate is null
  - retryIf
```
public <T> RetryPolicy retryIf(Predicate<T> resultPredicate)
```
    Specifies that a retry should occur if the resultPredicate matches the result and the retry policy is not exceeded.
    
    Throws:
    
    NullPointerException - if resultPredicate is null
  - retryOn
```
public RetryPolicy retryOn(Class<? extends Throwable> failure)
```
    Specifies the failure to retry on. Any failure that is assignable from the failure will be retried.
    
    Throws:
    
    NullPointerException - if failure is null
  - retryOn
```
public RetryPolicy retryOn(Class<? extends Throwable>... failures)
```
    Specifies the failures to retry on. Any failure that is assignable from the failures will be retried.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is empty
  - retryOn
```
public RetryPolicy retryOn(List<Class<? extends Throwable>> failures)
```
    Specifies the failures to retry on. Any failure that is assignable from the failures will be retried.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is null or empty
  - retryOn
```
public RetryPolicy retryOn(Predicate<? extends Throwable> failurePredicate)
```
    Specifies that a retry should occur if the failurePredicate matches the failure and the retry policy is not exceeded.
    
    Throws:
    
    NullPointerException - if failurePredicate is null
  - retryWhen
```
public RetryPolicy retryWhen(Object result)
```
    Specifies that a retry should occur if the execution result equals the result and the retry policy is not exceeded.
  - withBackoff
```
public RetryPolicy withBackoff(long delay,
                               long maxDelay,
                               TimeUnit timeUnit)
```
    Sets the delay between retries, exponentially backing off to the maxDelay and multiplying successive delays by a factor of 2.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if delay is <= 0 or delay is >= maxDelay
    
    IllegalStateException - if delay is >= the maxDuration, if delays have already been set, or if random delays have already been set
  - withBackoff
```
public RetryPolicy withBackoff(long delay,
                               long maxDelay,
                               TimeUnit timeUnit,
                               double delayFactor)
```
    Sets the delay between retries, exponentially backing off to the maxDelay and multiplying successive delays by the delayFactor.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if delay <= 0, delay is >= maxDelay, or the delayFactor is <= 1
    
    IllegalStateException - if delay is >= the maxDuration, if delays have already been set, or if random delays have already been set
  - withDelay
```
public RetryPolicy withDelay(long delay,
                             TimeUnit timeUnit)
```
    Sets the delay to occur between retries.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if delay <= 0
    
    IllegalStateException - if delay is >= the maxDuration, if random delays have already been set, or if backoff delays have already been set
  - withDelay
```
public RetryPolicy withDelay(long delayMin,
                             long delayMax,
                             TimeUnit timeUnit)
```
    Sets a random delay between the delayMin and delayMax (inclusive) to occur between retries.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if delayMin or delayMax are <= 0, or delayMin >= delayMax
    
    IllegalStateException - if delayMax is >= the maxDuration, if delays have already been set, if backoff delays have already been set
  - withDelay
```
public RetryPolicy withDelay(RetryPolicy.DelayFunction<?,? extends Throwable> delayFunction)
```
    Sets the delayFunction that computes the next delay before retrying.
    
    Parameters:
    
    delayFunction - the function to use to compute the delay before a next attempt
    
    Throws:
    
    NullPointerException - if delayFunction is null
    
    See Also:
    
    RetryPolicy.DelayFunction
  - withDelayOn
```
public <F extends Throwable> RetryPolicy withDelayOn(RetryPolicy.DelayFunction<Object,F> delayFunction,
                                                     Class<F> failure)
```
    Sets the delayFunction that computes the next delay before retrying. Delays will only occur for failures that are assignable from the failure.
    
    Type Parameters:
    
    F - failure type
    
    Parameters:
    
    delayFunction - the function to use to compute the delay before a next attempt
    
    failure - the execution failure that is expected in order to trigger the delay
    
    Throws:
    
    NullPointerException - if delayFunction or failure are null
    
    See Also:
    
    RetryPolicy.DelayFunction
  - withDelayWhen
```
public <R> RetryPolicy withDelayWhen(RetryPolicy.DelayFunction<R,? extends Throwable> delayFunction,
                                     R result)
```
    Sets the delayFunction that computes the next delay before retrying. Delays will only occur for results that equal the result.
    
    Type Parameters:
    
    R - result type
    
    Parameters:
    
    delayFunction - the function to use to compute the delay before a next attempt
    
    result - the execution result that is expected in order to trigger the delay
    
    Throws:
    
    NullPointerException - if delayFunction or result are null
    
    See Also:
    
    RetryPolicy.DelayFunction
  - withJitter
```
public RetryPolicy withJitter(double jitterFactor)
```
    Sets the jitterFactor to randomly vary retry delays by. For each retry delay, a random portion of the delay multiplied by the jitterFactor will be added or subtracted to the delay. For example: a retry delay of 100 milliseconds and a jitterFactor of .25 will result in a random retry delay between 75 and 125 milliseconds.
    Jitter should be combined with fixed, random or exponential backoff delays.
    
    Throws:
    
    IllegalArgumentException - if jitterFactor is < 0 or > 1
    
    IllegalStateException - if no delay has been configured or withJitter(long, TimeUnit) has already been called
  - withJitter
```
public RetryPolicy withJitter(long jitter,
                              TimeUnit timeUnit)
```
    Sets the jitter to randomly vary retry delays by. For each retry delay, a random portion of the jitter will be added or subtracted to the delay. For example: a jitter of 100 milliseconds will randomly add between -100 and 100 milliseconds to each retry delay.
    Jitter should be combined with fixed, random or exponential backoff delays.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if jitter is <= 0
    
    IllegalStateException - if no delay has been configured or withJitter(double) has already been called
  - withMaxDuration
```
public RetryPolicy withMaxDuration(long maxDuration,
                                   TimeUnit timeUnit)
```
    Sets the max duration to perform retries for, else the execution will be failed.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalStateException - if maxDuration is <= the delay
  - withMaxRetries
```
public RetryPolicy withMaxRetries(int maxRetries)
```
    Sets the max number of retries to perform. -1 indicates to retry forever.
    
    Throws:
    
    IllegalArgumentException - if maxRetries < -1

Class RetryPolicy

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

RetryPolicy

RetryPolicy

Method Detail

abortIf

abortIf

abortOn

abortOn

abortOn

abortOn

abortWhen

allowsRetries

canAbortFor

canRetryFor

canApplyDelayFn

copy

getDelay

getDelayMin

getDelayMax

getDelayFn

getDelayFactor

getJitter

getJitterFactor

getMaxDelay

getMaxDuration

getMaxRetries

retryIf

retryIf

retryOn

retryOn

retryOn

retryOn

retryWhen

withBackoff

withBackoff

withDelay

withDelay

withDelay

withDelayOn

withDelayWhen

withJitter

withJitter

withMaxDuration

withMaxRetries