RetryPolicy (Failsafe 2.3.4 API)

java.lang.Object
- net.jodah.failsafe.PolicyListeners<S,R>
- - net.jodah.failsafe.FailurePolicy<S,R>
  - - net.jodah.failsafe.DelayablePolicy<RetryPolicy<R>,R>
    - - net.jodah.failsafe.RetryPolicy<R>

Type Parameters:

R - result type

All Implemented Interfaces:

Policy<R>
```
public class RetryPolicy<R>
extends DelayablePolicy<RetryPolicy<R>,R>
```
A policy that defines when retries should be performed.
The handle methods describe when a retry should be performed for a particular failure. The handleResult methods describe when a retry should be performed for a particular result. If multiple handle or handleResult conditions are specified, any matching condition can allow a retry. The abortOn, abortWhen and abortIf methods describe when retries should be aborted.
Note: RetryPolicy extends DelayablePolicy and FailurePolicy which offer additional configuration.

Constructor Summary

Constructors
Constructor and Description

RetryPolicy()
Creates a retry policy that allows 3 execution attempts max with no delay.

Constructors
Constructor and Description
`RetryPolicy()` Creates a retry policy that allows 3 execution attempts max with no delay.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`RetryPolicy<R>`	`abortIf(BiPredicate<R,? extends Throwable> completionPredicate)` Specifies that retries should be aborted if the `completionPredicate` matches the completion result.
`RetryPolicy<R>`	`abortIf(Predicate<R> resultPredicate)` Specifies that retries should be aborted if the `resultPredicate` matches the result.
`RetryPolicy<R>`	`abortOn(Class<? extends Throwable>... failures)` Specifies when retries should be aborted.
`RetryPolicy<R>`	`abortOn(Class<? extends Throwable> failure)` Specifies when retries should be aborted.
`RetryPolicy<R>`	`abortOn(List<Class<? extends Throwable>> failures)` Specifies when retries should be aborted.
`RetryPolicy<R>`	`abortOn(Predicate<? extends Throwable> failurePredicate)` Specifies that retries should be aborted if the `failurePredicate` matches the failure.
`RetryPolicy<R>`	`abortWhen(R 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`.
`RetryPolicy<R>`	`copy()` Returns a copy of this RetryPolicy.
`Duration`	`getDelay()` Returns the delay between retries.
`double`	`getDelayFactor()` Returns the delay factor for backoff retries.
`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.
`int`	`getMaxAttempts()` Returns the max number of execution attempts to perform.
`Duration`	`getMaxDelay()` Returns the max delay between backoff retries.
`Duration`	`getMaxDuration()` Returns the max duration to perform retries for.
`int`	`getMaxRetries()` Returns the max number of retries to perform when an execution attempt fails.
`boolean`	`isAbortable(R result, Throwable failure)` Returns whether an execution result can be aborted given the configured abort conditions.
`RetryPolicy<R>`	`onAbort(CheckedConsumer<? extends ExecutionCompletedEvent<R>> listener)` Registers the `listener` to be called when an execution is aborted.
`RetryPolicy<R>`	`onFailedAttempt(CheckedConsumer<? extends ExecutionAttemptedEvent<R>> listener)` Registers the `listener` to be called when an execution attempt fails.
`RetryPolicy<R>`	`onRetriesExceeded(CheckedConsumer<? extends ExecutionCompletedEvent<R>> listener)` Registers the `listener` to be called when an execution fails and the `max retry attempts` or `max duration` are exceeded.
`RetryPolicy<R>`	`onRetry(CheckedConsumer<? extends ExecutionAttemptedEvent<R>> listener)` Registers the `listener` to be called before an execution is retried.
`PolicyExecutor`	`toExecutor(AbstractExecution execution)` Returns an `PolicyExecutor` capable of performing an execution in the context of a Policy and handling results according to the Policy.
`RetryPolicy<R>`	`withBackoff(long delay, long maxDelay, ChronoUnit chronoUnit)` Sets the `delay` between retries, exponentially backing off to the `maxDelay` and multiplying successive delays by a factor of 2.
`RetryPolicy<R>`	`withBackoff(long delay, long maxDelay, ChronoUnit chronoUnit, double delayFactor)` Sets the `delay` between retries, exponentially backing off to the `maxDelay` and multiplying successive delays by the `delayFactor`.
`RetryPolicy<R>`	`withDelay(Duration delay)` Sets the `delay` to occur between retries.
`RetryPolicy<R>`	`withDelay(long delayMin, long delayMax, ChronoUnit chronoUnit)` Sets a random delay between the `delayMin` and `delayMax` (inclusive) to occur between retries.
`RetryPolicy<R>`	`withJitter(double jitterFactor)` Sets the `jitterFactor` to randomly vary retry delays by.
`RetryPolicy<R>`	`withJitter(Duration jitter)` Sets the `jitter` to randomly vary retry delays by.
`RetryPolicy<R>`	`withMaxAttempts(int maxAttempts)` Sets the max number of execution attempts to perform.
`RetryPolicy<R>`	`withMaxDuration(Duration maxDuration)` Sets the max duration to perform retries for, else the execution will be failed.
`RetryPolicy<R>`	`withMaxRetries(int maxRetries)` Sets the max number of retries to perform when an execution attempt fails.

Methods inherited from class net.jodah.failsafe.DelayablePolicy
computeDelay, getDelayFn, withDelay, withDelayOn, withDelayWhen

Methods inherited from class net.jodah.failsafe.FailurePolicy
handle, handle, handle, handleIf, handleIf, handleResult, handleResultIf, isFailure

Methods inherited from class net.jodah.failsafe.PolicyListeners
onFailure, onSuccess

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

- Constructor Detail
  - RetryPolicy
```
public RetryPolicy()
```
    Creates a retry policy that allows 3 execution attempts max with no delay.
- Method Detail
  - abortIf
```
public RetryPolicy<R> abortIf(BiPredicate<R,? extends Throwable> completionPredicate)
```
    Specifies that retries should be aborted if the completionPredicate matches the completion result.
    
    Throws:
    
    NullPointerException - if completionPredicate is null
  - abortIf
```
public RetryPolicy<R> abortIf(Predicate<R> resultPredicate)
```
    Specifies that retries should be aborted if the resultPredicate matches the result. Predicate is not invoked when the operation fails.
    
    Throws:
    
    NullPointerException - if resultPredicate is null
  - abortOn
```
public RetryPolicy<R> 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
```
@SafeVarargs
public final RetryPolicy<R> 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<R> 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<R> 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<R> abortWhen(R 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(Duration)
  - isAbortable
```
public boolean isAbortable(R result,
                           Throwable failure)
```
    Returns whether an execution result can be aborted given the configured abort conditions.
    
    See Also:
    
    abortOn(Class...), abortOn(List), abortOn(Predicate), abortIf(BiPredicate), abortIf(Predicate), #abortWhen(R)
  - onAbort
```
public RetryPolicy<R> onAbort(CheckedConsumer<? extends ExecutionCompletedEvent<R>> listener)
```
    Registers the listener to be called when an execution is aborted.
    Note: Any exceptions that are thrown from within the listener are ignored.
  - onFailedAttempt
```
public RetryPolicy<R> onFailedAttempt(CheckedConsumer<? extends ExecutionAttemptedEvent<R>> listener)
```
    Registers the listener to be called when an execution attempt fails.
    Note: Any exceptions that are thrown from within the listener are ignored.
  - onRetriesExceeded
```
public RetryPolicy<R> onRetriesExceeded(CheckedConsumer<? extends ExecutionCompletedEvent<R>> listener)
```
    Registers the listener to be called when an execution fails and the max retry attempts or max duration are exceeded.
    Note: Any exceptions that are thrown from within the listener are ignored.
  - onRetry
```
public RetryPolicy<R> onRetry(CheckedConsumer<? extends ExecutionAttemptedEvent<R>> listener)
```
    Registers the listener to be called before an execution is retried.
    Note: Any exceptions that are thrown from within the listener are ignored.
  - copy
```
public RetryPolicy<R> copy()
```
    Returns a copy of this RetryPolicy.
  - getDelay
```
public Duration getDelay()
```
    Returns the delay between retries. Defaults to Duration.ZERO.
    
    See Also:
    
    withDelay(Duration), withBackoff(long, long, ChronoUnit), withBackoff(long, long, ChronoUnit, double)
  - getDelayMin
```
public Duration getDelayMin()
```
    Returns the min delay between retries.
    
    See Also:
    
    withDelay(long, long, ChronoUnit)
  - getDelayMax
```
public Duration getDelayMax()
```
    Returns the max delay between retries.
    
    See Also:
    
    withDelay(long, long, ChronoUnit)
  - getDelayFactor
```
public double getDelayFactor()
```
    Returns the delay factor for backoff retries.
    
    See Also:
    
    withBackoff(long, long, ChronoUnit, double)
  - getJitter
```
public Duration getJitter()
```
    Returns the jitter, else null if none has been configured.
    
    See Also:
    
    withJitter(Duration)
  - getJitterFactor
```
public double getJitterFactor()
```
    Returns the jitter factor, else 0.0 if none has been configured.
    
    See Also:
    
    withJitter(double)
  - getMaxAttempts
```
public int getMaxAttempts()
```
    Returns the max number of execution attempts to perform. A value of -1 represents no limit. Defaults to 3.
    
    See Also:
    
    withMaxAttempts(int), getMaxRetries()
  - getMaxDelay
```
public Duration getMaxDelay()
```
    Returns the max delay between backoff retries.
    
    See Also:
    
    withBackoff(long, long, ChronoUnit)
  - getMaxDuration
```
public Duration getMaxDuration()
```
    Returns the max duration to perform retries for.
    
    See Also:
    
    withMaxDuration(Duration)
  - getMaxRetries
```
public int getMaxRetries()
```
    Returns the max number of retries to perform when an execution attempt fails. A value of -1 represents no limit. Defaults to 2.
    
    See Also:
    
    withMaxRetries(int), getMaxAttempts()
  - withBackoff
```
public RetryPolicy<R> withBackoff(long delay,
                                  long maxDelay,
                                  ChronoUnit chronoUnit)
```
    Sets the delay between retries, exponentially backing off to the maxDelay and multiplying successive delays by a factor of 2.
    
    Throws:
    
    NullPointerException - if chronoUnit 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<R> withBackoff(long delay,
                                  long maxDelay,
                                  ChronoUnit chronoUnit,
                                  double delayFactor)
```
    Sets the delay between retries, exponentially backing off to the maxDelay and multiplying successive delays by the delayFactor.
    
    Throws:
    
    NullPointerException - if chronoUnit 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<R> withDelay(Duration delay)
```
    Sets the delay to occur between retries.
    
    Throws:
    
    NullPointerException - if chronoUnit 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<R> withDelay(long delayMin,
                                long delayMax,
                                ChronoUnit chronoUnit)
```
    Sets a random delay between the delayMin and delayMax (inclusive) to occur between retries.
    
    Throws:
    
    NullPointerException - if chronoUnit 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
  - withJitter
```
public RetryPolicy<R> 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 withJitter(Duration) has already been called
  - withJitter
```
public RetryPolicy<R> withJitter(Duration jitter)
```
    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 jitter is null
    
    IllegalArgumentException - if jitter is <= 0
    
    IllegalStateException - if withJitter(double) has already been called or the jitter is greater than the min configured delay
  - withMaxAttempts
```
public RetryPolicy<R> withMaxAttempts(int maxAttempts)
```
    Sets the max number of execution attempts to perform. -1 indicates no limit. This method has the same effect as setting 1 more than withMaxRetries(int). For example, 2 retries equal 3 attempts.
    
    Throws:
    
    IllegalArgumentException - if maxAttempts is 0 or less than -1
    
    See Also:
    
    withMaxRetries(int)
  - withMaxDuration
```
public RetryPolicy<R> withMaxDuration(Duration maxDuration)
```
    Sets the max duration to perform retries for, else the execution will be failed.
    
    Throws:
    
    NullPointerException - if maxDuration is null
    
    IllegalStateException - if maxDuration is <= the delay
  - withMaxRetries
```
public RetryPolicy<R> withMaxRetries(int maxRetries)
```
    Sets the max number of retries to perform when an execution attempt fails. -1 indicates no limit. This method has the same effect as setting 1 less than withMaxAttempts(int). For example, 2 retries equal 3 attempts.
    
    Throws:
    
    IllegalArgumentException - if maxRetries < -1
    
    See Also:
    
    withMaxAttempts(int)
  - toExecutor
```
public PolicyExecutor toExecutor(AbstractExecution execution)
```
    Description copied from interface: Policy
    
    Returns an PolicyExecutor capable of performing an execution in the context of a Policy and handling results according to the Policy.

Class RetryPolicy<R>

Constructor Summary

Method Summary

Methods inherited from class net.jodah.failsafe.DelayablePolicy

Methods inherited from class net.jodah.failsafe.FailurePolicy

Methods inherited from class net.jodah.failsafe.PolicyListeners

Methods inherited from class java.lang.Object

Constructor Detail

RetryPolicy

Method Detail

abortIf

abortIf

abortOn

abortOn

abortOn

abortOn

abortWhen

allowsRetries

isAbortable

onAbort

onFailedAttempt

onRetriesExceeded

onRetry

copy

getDelay

getDelayMin

getDelayMax

getDelayFactor

getJitter

getJitterFactor

getMaxAttempts

getMaxDelay

getMaxDuration

getMaxRetries

withBackoff

withBackoff

withDelay

withDelay

withJitter

withJitter

withMaxAttempts

withMaxDuration

withMaxRetries

toExecutor