RedeliveryPolicy (Camel :: Core 2.14.4 API)

java.lang.Object
- org.apache.camel.processor.RedeliveryPolicy

All Implemented Interfaces:

Serializable, Cloneable
```
public class RedeliveryPolicy
extends Object
implements Cloneable, Serializable
```
The policy used to decide how many times to redeliver and the time between the redeliveries before being sent to a Dead Letter Channel
The default values are:
- maximumRedeliveries = 0
- redeliveryDelay = 1000L (the initial delay)
- maximumRedeliveryDelay = 60 * 1000L
- asyncDelayedRedelivery = false
- backOffMultiplier = 2
- useExponentialBackOff = false
- collisionAvoidanceFactor = 0.15d
- useCollisionAvoidance = false
- retriesExhaustedLogLevel = LoggingLevel.ERROR
- retryAttemptedLogLevel = LoggingLevel.DEBUG
- logRetryAttempted = true
- logRetryStackTrace = false
- logStackTrace = true
- logHandled = false
- logExhausted = true
- logExhaustedMessageHistory = true
Setting the maximumRedeliveries to a negative value such as -1 will then always redeliver (unlimited). Setting the maximumRedeliveries to 0 will disable redelivery.
This policy can be configured either by one of the following two settings:
- using conventional options, using all the options defined above
- using delay pattern to declare intervals for delays
Note: If using delay patterns then the following options is not used (delay, backOffMultiplier, useExponentialBackOff, useCollisionAvoidance)
Using delay pattern:
The delay pattern syntax is: limit:delay;limit 2:delay 2;limit 3:delay 3;...;limit N:delay N.
How it works is best illustrate with an example with this pattern: delayPattern=5:1000;10:5000:20:20000
The delays will be for attempt in range 0..4 = 0 millis, 5..9 = 1000 millis, 10..19 = 5000 millis, >= 20 = 20000 millis.
If you want to set a starting delay, then use 0 as the first limit, eg: 0:1000;5:5000 will use 1 sec delay until attempt number 5 where it will use 5 seconds going forward.
Version:

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`protected boolean`	`allowRedeliveryWhileStopping`
`protected boolean`	`asyncDelayedRedelivery`
`protected double`	`backOffMultiplier`
`protected double`	`collisionAvoidanceFactor`
`protected String`	`delayPattern`
`protected boolean`	`logContinued`
`protected boolean`	`logExhausted`
`protected boolean`	`logExhaustedMessageHistory`
`protected boolean`	`logHandled`
`protected boolean`	`logRetryAttempted`
`protected boolean`	`logRetryStackTrace`
`protected boolean`	`logStackTrace`
`protected int`	`maximumRedeliveries`
`protected long`	`maximumRedeliveryDelay`
`protected static Random`	`randomNumberGenerator`
`protected long`	`redeliveryDelay`
`protected LoggingLevel`	`retriesExhaustedLogLevel`
`protected LoggingLevel`	`retryAttemptedLogLevel`
`protected boolean`	`useCollisionAvoidance`
`protected boolean`	`useExponentialBackOff`

Constructor Summary

Constructors
Constructor and Description

RedeliveryPolicy()

Constructors
Constructor and Description
`RedeliveryPolicy()`

Method Summary

Methods
Modifier and Type	Method and Description
`RedeliveryPolicy`	`allowRedeliveryWhileStopping(boolean redeliverWhileStopping)` Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.
`RedeliveryPolicy`	`asyncDelayedRedelivery()` Allow asynchronous delayed redelivery.
`RedeliveryPolicy`	`backOffMultiplier(double multiplier)` Enables exponential backoff and sets the multiplier used to increase the delay between redeliveries
`protected static long`	`calculateRedeliverDelayUsingPattern(String delayPattern, int redeliveryCounter)` Calculates the delay using the delay pattern
`long`	`calculateRedeliveryDelay(long previousDelay, int redeliveryCounter)` Calculates the new redelivery delay based on the last one
`RedeliveryPolicy`	`collisionAvoidancePercent(double collisionAvoidancePercent)` Enables collision avoidance and sets the percentage used
`RedeliveryPolicy`	`copy()`
`RedeliveryPolicy`	`delayPattern(String delayPattern)` Sets the delay pattern with delay intervals.
`RedeliveryPolicy`	`disableRedelivery()` Disables redelivery by setting maximum redeliveries to 0.
`double`	`getBackOffMultiplier()`
`double`	`getCollisionAvoidanceFactor()`
`long`	`getCollisionAvoidancePercent()`
`String`	`getDelayPattern()`
`int`	`getMaximumRedeliveries()`
`long`	`getMaximumRedeliveryDelay()`
`protected static Random`	`getRandomNumberGenerator()`
`long`	`getRedeliverDelay()` Deprecated. will be removed in the near future. Instead use `getRedeliveryDelay()`
`long`	`getRedeliveryDelay()`
`LoggingLevel`	`getRetriesExhaustedLogLevel()`
`LoggingLevel`	`getRetryAttemptedLogLevel()`
`boolean`	`isAllowRedeliveryWhileStopping()`
`boolean`	`isAsyncDelayedRedelivery()`
`boolean`	`isLogContinued()`
`boolean`	`isLogExhausted()`
`boolean`	`isLogExhaustedMessageHistory()`
`boolean`	`isLogHandled()`
`boolean`	`isLogRetryAttempted()`
`boolean`	`isLogRetryStackTrace()`
`boolean`	`isLogStackTrace()`
`boolean`	`isUseCollisionAvoidance()`
`boolean`	`isUseExponentialBackOff()`
`RedeliveryPolicy`	`logExhausted(boolean logExhausted)` Sets whether to log exhausted errors
`RedeliveryPolicy`	`logExhaustedMessageHistory(boolean logExhaustedMessageHistory)` Sets whether to log exhausted errors including message history
`RedeliveryPolicy`	`logHandled(boolean logHandled)` Sets whether to log errors even if its handled
`RedeliveryPolicy`	`logRetryAttempted(boolean logRetryAttempted)` Sets whether to log retry attempts
`RedeliveryPolicy`	`logRetryStackTrace(boolean logRetryStackTrace)` Sets whether to log stacktrace for failed redelivery attempts
`RedeliveryPolicy`	`logStackTrace(boolean logStackTrace)` Sets whether to log stacktrace for failed messages.
`RedeliveryPolicy`	`maximumRedeliveries(int maximumRedeliveries)` Sets the maximum number of times a message exchange will be redelivered
`RedeliveryPolicy`	`maximumRedeliveryDelay(long maximumRedeliveryDelay)` Sets the maximum redelivery delay if using exponential back off.
`RedeliveryPolicy`	`redeliverDelay(long delay)` Deprecated. will be removed in the near future. Instead use `redeliveryDelay(long)` instead
`RedeliveryPolicy`	`redeliveryDelay(long delay)` Sets the initial redelivery delay in milliseconds
`RedeliveryPolicy`	`retriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel)` Sets the logging level to use for log messages when retries have been exhausted.
`RedeliveryPolicy`	`retryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel)` Sets the logging level to use for log messages when retries are attempted.
`void`	`setAllowRedeliveryWhileStopping(boolean allowRedeliveryWhileStopping)` Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.
`void`	`setAsyncDelayedRedelivery(boolean asyncDelayedRedelivery)` Sets whether asynchronous delayed redelivery is allowed.
`void`	`setBackOffMultiplier(double backOffMultiplier)` Sets the multiplier used to increase the delay between redeliveries if `setUseExponentialBackOff(boolean)` is enabled
`void`	`setCollisionAvoidanceFactor(double collisionAvoidanceFactor)` Sets the factor used for collision avoidance if enabled via `setUseCollisionAvoidance(boolean)`
`void`	`setCollisionAvoidancePercent(double collisionAvoidancePercent)` Sets the percentage used for collision avoidance if enabled via `setUseCollisionAvoidance(boolean)`
`void`	`setDelayPattern(String delayPattern)` Sets an optional delay pattern to use instead of fixed delay.
`void`	`setLogContinued(boolean logContinued)` Sets whether errors should be logged even if its continued
`void`	`setLogExhausted(boolean logExhausted)` Sets whether exhausted exceptions should be logged or not
`void`	`setLogExhaustedMessageHistory(boolean logExhaustedMessageHistory)` Sets whether exhausted exceptions should be logged with message history included.
`void`	`setLogHandled(boolean logHandled)` Sets whether errors should be logged even if its handled
`void`	`setLogRetryAttempted(boolean logRetryAttempted)` Sets whether retry attempts should be logged or not
`void`	`setLogRetryStackTrace(boolean logRetryStackTrace)` Sets whether stack traces should be logged or not
`void`	`setLogStackTrace(boolean logStackTrace)` Sets whether stack traces should be logged or not
`void`	`setMaximumRedeliveries(int maximumRedeliveries)` Sets the maximum number of times a message exchange will be redelivered.
`void`	`setMaximumRedeliveryDelay(long maximumRedeliveryDelay)` Sets the maximum redelivery delay.
`void`	`setRedeliverDelay(long redeliveryDelay)` Deprecated. will be removed in the near future. Instead use `setRedeliveryDelay(long)`
`void`	`setRedeliveryDelay(long redeliverDelay)` Sets the initial redelivery delay in milliseconds
`void`	`setRetriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel)` Sets the logging level to use for log messages when retries have been exhausted.
`void`	`setRetryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel)` Sets the logging level to use for log messages when retries are attempted.
`void`	`setUseCollisionAvoidance(boolean useCollisionAvoidance)` Enables/disables collision avoidance which adds some randomization to the backoff timings to reduce contention probability
`void`	`setUseExponentialBackOff(boolean useExponentialBackOff)` Enables/disables exponential backoff using the `getBackOffMultiplier()` to increase the time between retries
`boolean`	`shouldRedeliver(Exchange exchange, int redeliveryCounter, Predicate retryWhile)` Returns true if the policy decides that the message exchange should be redelivered.
`void`	`sleep(long redeliveryDelay)` Sleeps for the given delay
`long`	`sleep(long redeliveryDelay, int redeliveryCounter)` Calculates the new redelivery delay based on the last one and then sleeps for the necessary amount of time.
`String`	`toString()`
`RedeliveryPolicy`	`useCollisionAvoidance()` Enables collision avoidance which adds some randomization to the backoff timings to reduce contention probability
`RedeliveryPolicy`	`useExponentialBackOff()` Enables exponential backoff using the `getBackOffMultiplier()` to increase the time between retries

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

- Field Detail
  - randomNumberGenerator
```
protected static Random randomNumberGenerator
```
  - redeliveryDelay
```
protected long redeliveryDelay
```
  - maximumRedeliveries
```
protected int maximumRedeliveries
```
  - maximumRedeliveryDelay
```
protected long maximumRedeliveryDelay
```
  - backOffMultiplier
```
protected double backOffMultiplier
```
  - useExponentialBackOff
```
protected boolean useExponentialBackOff
```
  - collisionAvoidanceFactor
```
protected double collisionAvoidanceFactor
```
  - useCollisionAvoidance
```
protected boolean useCollisionAvoidance
```
  - retriesExhaustedLogLevel
```
protected LoggingLevel retriesExhaustedLogLevel
```
  - retryAttemptedLogLevel
```
protected LoggingLevel retryAttemptedLogLevel
```
  - logStackTrace
```
protected boolean logStackTrace
```
  - logRetryStackTrace
```
protected boolean logRetryStackTrace
```
  - logHandled
```
protected boolean logHandled
```
  - logContinued
```
protected boolean logContinued
```
  - logExhausted
```
protected boolean logExhausted
```
  - logExhaustedMessageHistory
```
protected boolean logExhaustedMessageHistory
```
  - logRetryAttempted
```
protected boolean logRetryAttempted
```
  - delayPattern
```
protected String delayPattern
```
  - asyncDelayedRedelivery
```
protected boolean asyncDelayedRedelivery
```
  - allowRedeliveryWhileStopping
```
protected boolean allowRedeliveryWhileStopping
```
- Constructor Detail
  - RedeliveryPolicy
```
public RedeliveryPolicy()
```
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - copy
```
public RedeliveryPolicy copy()
```
  - shouldRedeliver
```
public boolean shouldRedeliver(Exchange exchange,
                      int redeliveryCounter,
                      Predicate retryWhile)
```
    Returns true if the policy decides that the message exchange should be redelivered.
    
    Parameters:
    exchange - the current exchange
    redeliveryCounter - the current retry counter
    retryWhile - an optional predicate to determine if we should redeliver or not
    
    Returns:
    true to redeliver, false to stop
  - sleep
```
public long sleep(long redeliveryDelay,
         int redeliveryCounter)
           throws InterruptedException
```
    Calculates the new redelivery delay based on the last one and then sleeps for the necessary amount of time.
    This implementation will block while sleeping.
    
    Parameters:
    redeliveryDelay - previous redelivery delay
    redeliveryCounter - number of previous redelivery attempts
    
    Returns:
    the calculate delay
    
    Throws:
    
    InterruptedException - is thrown if the sleep is interrupted likely because of shutdown
  - sleep
```
public void sleep(long redeliveryDelay)
           throws InterruptedException
```
    Sleeps for the given delay
    
    Parameters:
    redeliveryDelay - the delay
    
    Throws:
    
    InterruptedException - is thrown if the sleep is interrupted likely because of shutdown
  - calculateRedeliveryDelay
```
public long calculateRedeliveryDelay(long previousDelay,
                            int redeliveryCounter)
```
    Calculates the new redelivery delay based on the last one
    
    Parameters:
    previousDelay - previous redelivery delay
    redeliveryCounter - number of previous redelivery attempts
    
    Returns:
    the calculate delay
  - calculateRedeliverDelayUsingPattern
```
protected static long calculateRedeliverDelayUsingPattern(String delayPattern,
                                       int redeliveryCounter)
```
    Calculates the delay using the delay pattern
  - redeliverDelay
```
@Deprecated
public RedeliveryPolicy redeliverDelay(long delay)
```
    Deprecated. will be removed in the near future. Instead use redeliveryDelay(long) instead
    
    Sets the initial redelivery delay in milliseconds
  - redeliveryDelay
```
public RedeliveryPolicy redeliveryDelay(long delay)
```
    Sets the initial redelivery delay in milliseconds
  - maximumRedeliveries
```
public RedeliveryPolicy maximumRedeliveries(int maximumRedeliveries)
```
    Sets the maximum number of times a message exchange will be redelivered
  - useCollisionAvoidance
```
public RedeliveryPolicy useCollisionAvoidance()
```
    Enables collision avoidance which adds some randomization to the backoff timings to reduce contention probability
  - useExponentialBackOff
```
public RedeliveryPolicy useExponentialBackOff()
```
    Enables exponential backoff using the getBackOffMultiplier() to increase the time between retries
  - backOffMultiplier
```
public RedeliveryPolicy backOffMultiplier(double multiplier)
```
    Enables exponential backoff and sets the multiplier used to increase the delay between redeliveries
  - collisionAvoidancePercent
```
public RedeliveryPolicy collisionAvoidancePercent(double collisionAvoidancePercent)
```
    Enables collision avoidance and sets the percentage used
  - maximumRedeliveryDelay
```
public RedeliveryPolicy maximumRedeliveryDelay(long maximumRedeliveryDelay)
```
    Sets the maximum redelivery delay if using exponential back off. Use -1 if you wish to have no maximum
  - retriesExhaustedLogLevel
```
public RedeliveryPolicy retriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel)
```
    Sets the logging level to use for log messages when retries have been exhausted.
  - retryAttemptedLogLevel
```
public RedeliveryPolicy retryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel)
```
    Sets the logging level to use for log messages when retries are attempted.
  - logRetryAttempted
```
public RedeliveryPolicy logRetryAttempted(boolean logRetryAttempted)
```
    Sets whether to log retry attempts
  - logStackTrace
```
public RedeliveryPolicy logStackTrace(boolean logStackTrace)
```
    Sets whether to log stacktrace for failed messages.
  - logRetryStackTrace
```
public RedeliveryPolicy logRetryStackTrace(boolean logRetryStackTrace)
```
    Sets whether to log stacktrace for failed redelivery attempts
  - logHandled
```
public RedeliveryPolicy logHandled(boolean logHandled)
```
    Sets whether to log errors even if its handled
  - logExhausted
```
public RedeliveryPolicy logExhausted(boolean logExhausted)
```
    Sets whether to log exhausted errors
  - logExhaustedMessageHistory
```
public RedeliveryPolicy logExhaustedMessageHistory(boolean logExhaustedMessageHistory)
```
    Sets whether to log exhausted errors including message history
  - delayPattern
```
public RedeliveryPolicy delayPattern(String delayPattern)
```
    Sets the delay pattern with delay intervals.
  - disableRedelivery
```
public RedeliveryPolicy disableRedelivery()
```
    Disables redelivery by setting maximum redeliveries to 0.
  - asyncDelayedRedelivery
```
public RedeliveryPolicy asyncDelayedRedelivery()
```
    Allow asynchronous delayed redelivery.
    
    See Also:
    setAsyncDelayedRedelivery(boolean)
  - allowRedeliveryWhileStopping
```
public RedeliveryPolicy allowRedeliveryWhileStopping(boolean redeliverWhileStopping)
```
    Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.
    
    Parameters:
    redeliverWhileStopping - true to allow redelivery, false to reject redeliveries
  - getRedeliverDelay
```
@Deprecated
public long getRedeliverDelay()
```
    Deprecated. will be removed in the near future. Instead use getRedeliveryDelay()
  - setRedeliverDelay
```
@Deprecated
public void setRedeliverDelay(long redeliveryDelay)
```
    Deprecated. will be removed in the near future. Instead use setRedeliveryDelay(long)
  - getRedeliveryDelay
```
public long getRedeliveryDelay()
```
  - setRedeliveryDelay
```
public void setRedeliveryDelay(long redeliverDelay)
```
    Sets the initial redelivery delay in milliseconds
  - getBackOffMultiplier
```
public double getBackOffMultiplier()
```
  - setBackOffMultiplier
```
public void setBackOffMultiplier(double backOffMultiplier)
```
    Sets the multiplier used to increase the delay between redeliveries if setUseExponentialBackOff(boolean) is enabled
  - getCollisionAvoidancePercent
```
public long getCollisionAvoidancePercent()
```
  - setCollisionAvoidancePercent
```
public void setCollisionAvoidancePercent(double collisionAvoidancePercent)
```
    Sets the percentage used for collision avoidance if enabled via setUseCollisionAvoidance(boolean)
  - getCollisionAvoidanceFactor
```
public double getCollisionAvoidanceFactor()
```
  - setCollisionAvoidanceFactor
```
public void setCollisionAvoidanceFactor(double collisionAvoidanceFactor)
```
    Sets the factor used for collision avoidance if enabled via setUseCollisionAvoidance(boolean)
  - getMaximumRedeliveries
```
public int getMaximumRedeliveries()
```
  - setMaximumRedeliveries
```
public void setMaximumRedeliveries(int maximumRedeliveries)
```
    Sets the maximum number of times a message exchange will be redelivered. Setting a negative value will retry forever.
  - getMaximumRedeliveryDelay
```
public long getMaximumRedeliveryDelay()
```
  - setMaximumRedeliveryDelay
```
public void setMaximumRedeliveryDelay(long maximumRedeliveryDelay)
```
    Sets the maximum redelivery delay. Use -1 if you wish to have no maximum
  - isUseCollisionAvoidance
```
public boolean isUseCollisionAvoidance()
```
  - setUseCollisionAvoidance
```
public void setUseCollisionAvoidance(boolean useCollisionAvoidance)
```
    Enables/disables collision avoidance which adds some randomization to the backoff timings to reduce contention probability
  - isUseExponentialBackOff
```
public boolean isUseExponentialBackOff()
```
  - setUseExponentialBackOff
```
public void setUseExponentialBackOff(boolean useExponentialBackOff)
```
    Enables/disables exponential backoff using the getBackOffMultiplier() to increase the time between retries
  - getRandomNumberGenerator
```
protected static Random getRandomNumberGenerator()
```
  - setRetriesExhaustedLogLevel
```
public void setRetriesExhaustedLogLevel(LoggingLevel retriesExhaustedLogLevel)
```
    Sets the logging level to use for log messages when retries have been exhausted.
  - getRetriesExhaustedLogLevel
```
public LoggingLevel getRetriesExhaustedLogLevel()
```
  - setRetryAttemptedLogLevel
```
public void setRetryAttemptedLogLevel(LoggingLevel retryAttemptedLogLevel)
```
    Sets the logging level to use for log messages when retries are attempted.
  - getRetryAttemptedLogLevel
```
public LoggingLevel getRetryAttemptedLogLevel()
```
  - getDelayPattern
```
public String getDelayPattern()
```
  - setDelayPattern
```
public void setDelayPattern(String delayPattern)
```
    Sets an optional delay pattern to use instead of fixed delay.
  - isLogStackTrace
```
public boolean isLogStackTrace()
```
  - setLogStackTrace
```
public void setLogStackTrace(boolean logStackTrace)
```
    Sets whether stack traces should be logged or not
  - isLogRetryStackTrace
```
public boolean isLogRetryStackTrace()
```
  - setLogRetryStackTrace
```
public void setLogRetryStackTrace(boolean logRetryStackTrace)
```
    Sets whether stack traces should be logged or not
  - isLogHandled
```
public boolean isLogHandled()
```
  - setLogHandled
```
public void setLogHandled(boolean logHandled)
```
    Sets whether errors should be logged even if its handled
  - isLogContinued
```
public boolean isLogContinued()
```
  - setLogContinued
```
public void setLogContinued(boolean logContinued)
```
    Sets whether errors should be logged even if its continued
  - isLogRetryAttempted
```
public boolean isLogRetryAttempted()
```
  - setLogRetryAttempted
```
public void setLogRetryAttempted(boolean logRetryAttempted)
```
    Sets whether retry attempts should be logged or not
  - isLogExhausted
```
public boolean isLogExhausted()
```
  - setLogExhausted
```
public void setLogExhausted(boolean logExhausted)
```
    Sets whether exhausted exceptions should be logged or not
  - isLogExhaustedMessageHistory
```
public boolean isLogExhaustedMessageHistory()
```
  - setLogExhaustedMessageHistory
```
public void setLogExhaustedMessageHistory(boolean logExhaustedMessageHistory)
```
    Sets whether exhausted exceptions should be logged with message history included.
  - isAsyncDelayedRedelivery
```
public boolean isAsyncDelayedRedelivery()
```
  - setAsyncDelayedRedelivery
```
public void setAsyncDelayedRedelivery(boolean asyncDelayedRedelivery)
```
    Sets whether asynchronous delayed redelivery is allowed.
    This is disabled by default.
    When enabled it allows Camel to schedule a future task for delayed redelivery which prevents current thread from blocking while waiting.
    Exchange which is transacted will however always use synchronous delayed redelivery because the transaction must execute in the same thread context.
    
    Parameters:
    asyncDelayedRedelivery - whether asynchronous delayed redelivery is allowed
  - isAllowRedeliveryWhileStopping
```
public boolean isAllowRedeliveryWhileStopping()
```
  - setAllowRedeliveryWhileStopping
```
public void setAllowRedeliveryWhileStopping(boolean allowRedeliveryWhileStopping)
```
    Controls whether to allow redelivery while stopping/shutting down a route that uses error handling.
    
    Parameters:
    allowRedeliveryWhileStopping - true to allow redelivery, false to reject redeliveries

Class RedeliveryPolicy

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

randomNumberGenerator

redeliveryDelay

maximumRedeliveries

maximumRedeliveryDelay

backOffMultiplier

useExponentialBackOff

collisionAvoidanceFactor

useCollisionAvoidance

retriesExhaustedLogLevel

retryAttemptedLogLevel

logStackTrace

logRetryStackTrace

logHandled

logContinued

logExhausted

logExhaustedMessageHistory

logRetryAttempted

delayPattern

asyncDelayedRedelivery

allowRedeliveryWhileStopping

Constructor Detail

RedeliveryPolicy

Method Detail

toString

copy

shouldRedeliver

sleep

sleep

calculateRedeliveryDelay

calculateRedeliverDelayUsingPattern

redeliverDelay

redeliveryDelay

maximumRedeliveries

useCollisionAvoidance

useExponentialBackOff

backOffMultiplier

collisionAvoidancePercent

maximumRedeliveryDelay

retriesExhaustedLogLevel

retryAttemptedLogLevel

logRetryAttempted

logStackTrace

logRetryStackTrace

logHandled

logExhausted

logExhaustedMessageHistory

delayPattern

disableRedelivery

asyncDelayedRedelivery

allowRedeliveryWhileStopping

getRedeliverDelay

setRedeliverDelay

getRedeliveryDelay

setRedeliveryDelay

getBackOffMultiplier

setBackOffMultiplier

getCollisionAvoidancePercent

setCollisionAvoidancePercent

getCollisionAvoidanceFactor

setCollisionAvoidanceFactor

getMaximumRedeliveries

setMaximumRedeliveries

getMaximumRedeliveryDelay

setMaximumRedeliveryDelay

isUseCollisionAvoidance

setUseCollisionAvoidance

isUseExponentialBackOff

setUseExponentialBackOff

getRandomNumberGenerator

setRetriesExhaustedLogLevel

getRetriesExhaustedLogLevel

setRetryAttemptedLogLevel

getRetryAttemptedLogLevel

getDelayPattern