WaitStrategies (commons-tool 1.4.12 API)

java.lang.Object
- cn.aotcloud.retry.WaitStrategies

```
public final class WaitStrategies
extends Object
```
Factory class for instances of WaitStrategy.

作者:

JB

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <T extends Throwable> WaitStrategy`	`exceptionWait(Class<T> exceptionClass, com.google.common.base.Function<T,Long> function)` Returns a strategy which sleeps for an amount of time based on the Exception that occurred.
`static WaitStrategy`	`exponentialWait()` Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to Long.MAX_VALUE.
`static WaitStrategy`	`exponentialWait(long multiplier, long maximumTime, TimeUnit maximumTimeUnit)` Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.
`static WaitStrategy`	`exponentialWait(long maximumTime, TimeUnit maximumTimeUnit)` Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.
`static WaitStrategy`	`fibonacciWait()` Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to `Long.MAX_VALUE`.
`static WaitStrategy`	`fibonacciWait(long multiplier, long maximumTime, TimeUnit maximumTimeUnit)` Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the `maximumTime`.
`static WaitStrategy`	`fibonacciWait(long maximumTime, TimeUnit maximumTimeUnit)` Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the `maximumTime`.
`static WaitStrategy`	`fixedWait(long sleepTime, TimeUnit timeUnit)` Returns a wait strategy that sleeps a fixed amount of time before retrying.
`static WaitStrategy`	`incrementingWait(long initialSleepTime, TimeUnit initialSleepTimeUnit, long increment, TimeUnit incrementTimeUnit)` Returns a strategy that sleeps a fixed amount of time after the first failed attempt and in incrementing amounts of time after each additional failed attempt.
`static WaitStrategy`	`join(WaitStrategy... waitStrategies)` Joins one or more wait strategies to derive a composite wait strategy.
`static WaitStrategy`	`noWait()` Returns a wait strategy that doesn't sleep at all before retrying.
`static WaitStrategy`	`randomWait(long maximumTime, TimeUnit timeUnit)` Returns a strategy that sleeps a random amount of time before retrying.
`static WaitStrategy`	`randomWait(long minimumTime, TimeUnit minimumTimeUnit, long maximumTime, TimeUnit maximumTimeUnit)` Returns a strategy that sleeps a random amount of time before retrying.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 方法详细资料
  - noWait
```
public static WaitStrategy noWait()
```
    Returns a wait strategy that doesn't sleep at all before retrying. Use this at your own risk.
    
    返回:
    
    a wait strategy that doesn't wait between retries
  - fixedWait
```
public static WaitStrategy fixedWait(long sleepTime,
                                     @Nonnull
                                     TimeUnit timeUnit)
                              throws IllegalStateException
```
    Returns a wait strategy that sleeps a fixed amount of time before retrying.
    
    参数:
    
    sleepTime - the time to sleep
    
    timeUnit - the unit of the time to sleep
    
    返回:
    
    a wait strategy that sleeps a fixed amount of time
    
    抛出:
    
    IllegalStateException - if the sleep time is < 0
  - randomWait
```
public static WaitStrategy randomWait(long maximumTime,
                                      @Nonnull
                                      TimeUnit timeUnit)
```
    Returns a strategy that sleeps a random amount of time before retrying.
    
    参数:
    
    maximumTime - the maximum time to sleep
    
    timeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy with a random wait time
    
    抛出:
    
    IllegalStateException - if the maximum sleep time is <= 0.
  - randomWait
```
public static WaitStrategy randomWait(long minimumTime,
                                      @Nonnull
                                      TimeUnit minimumTimeUnit,
                                      long maximumTime,
                                      @Nonnull
                                      TimeUnit maximumTimeUnit)
```
    Returns a strategy that sleeps a random amount of time before retrying.
    
    参数:
    
    minimumTime - the minimum time to sleep
    
    minimumTimeUnit - the unit of the minimum time
    
    maximumTime - the maximum time to sleep
    
    maximumTimeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy with a random wait time
    
    抛出:
    
    IllegalStateException - if the minimum sleep time is < 0, or if the maximum sleep time is less than (or equals to) the minimum.
  - incrementingWait
```
public static WaitStrategy incrementingWait(long initialSleepTime,
                                            @Nonnull
                                            TimeUnit initialSleepTimeUnit,
                                            long increment,
                                            @Nonnull
                                            TimeUnit incrementTimeUnit)
```
    Returns a strategy that sleeps a fixed amount of time after the first failed attempt and in incrementing amounts of time after each additional failed attempt.
    
    参数:
    
    initialSleepTime - the time to sleep before retrying the first time
    
    initialSleepTimeUnit - the unit of the initial sleep time
    
    increment - the increment added to the previous sleep time after each failed attempt
    
    incrementTimeUnit - the unit of the increment
    
    返回:
    
    a wait strategy that incrementally sleeps an additional fixed time after each failed attempt
  - exponentialWait
```
public static WaitStrategy exponentialWait()
```
    Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to Long.MAX_VALUE.
    
    返回:
    
    a wait strategy that increments with each failed attempt using exponential backoff
  - exponentialWait
```
public static WaitStrategy exponentialWait(long maximumTime,
                                           @Nonnull
                                           TimeUnit maximumTimeUnit)
```
    Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.
    
    参数:
    
    maximumTime - the maximum time to sleep
    
    maximumTimeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy that increments with each failed attempt using exponential backoff
  - exponentialWait
```
public static WaitStrategy exponentialWait(long multiplier,
                                           long maximumTime,
                                           @Nonnull
                                           TimeUnit maximumTimeUnit)
```
    Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime. The wait time between the retries can be controlled by the multiplier. nextWaitTime = exponentialIncrement * multiplier.
    
    参数:
    
    multiplier - multiply the wait time calculated by this
    
    maximumTime - the maximum time to sleep
    
    maximumTimeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy that increments with each failed attempt using exponential backoff
  - fibonacciWait
```
public static WaitStrategy fibonacciWait()
```
    Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to Long.MAX_VALUE.
    
    返回:
    
    a wait strategy that increments with each failed attempt using a Fibonacci sequence
  - fibonacciWait
```
public static WaitStrategy fibonacciWait(long maximumTime,
                                         @Nonnull
                                         TimeUnit maximumTimeUnit)
```
    Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime.
    
    参数:
    
    maximumTime - the maximum time to sleep
    
    maximumTimeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy that increments with each failed attempt using a Fibonacci sequence
  - fibonacciWait
```
public static WaitStrategy fibonacciWait(long multiplier,
                                         long maximumTime,
                                         @Nonnull
                                         TimeUnit maximumTimeUnit)
```
    Returns a strategy which sleeps for an increasing amount of time after the first failed attempt, and in Fibonacci increments after each failed attempt up to the maximumTime. The wait time between the retries can be controlled by the multiplier. nextWaitTime = fibonacciIncrement * multiplier.
    
    参数:
    
    multiplier - multiply the wait time calculated by this
    
    maximumTime - the maximum time to sleep
    
    maximumTimeUnit - the unit of the maximum time
    
    返回:
    
    a wait strategy that increments with each failed attempt using a Fibonacci sequence
  - exceptionWait
```
public static <T extends Throwable> WaitStrategy exceptionWait(@Nonnull
                                                               Class<T> exceptionClass,
                                                               @Nonnull
                                                               com.google.common.base.Function<T,Long> function)
```
    Returns a strategy which sleeps for an amount of time based on the Exception that occurred. The function determines how the sleep time should be calculated for the given exceptionClass. If the exception does not match, a wait time of 0 is returned.
    
    参数:
    
    function - function to calculate sleep time
    
    exceptionClass - class to calculate sleep time from
    
    返回:
    
    a wait strategy calculated from the failed attempt
  - join
```
public static WaitStrategy join(WaitStrategy... waitStrategies)
```
    Joins one or more wait strategies to derive a composite wait strategy. The new joined strategy will have a wait time which is total of all wait times computed one after another in order.
    
    参数:
    
    waitStrategies - Wait strategies that need to be applied one after another for computing the sleep time.
    
    返回:
    
    A composite wait strategy

类 WaitStrategies

方法概要

从类继承的方法 java.lang.Object

方法详细资料

noWait

fixedWait

randomWait

randomWait

incrementingWait

exponentialWait

exponentialWait

exponentialWait

fibonacciWait

fibonacciWait

fibonacciWait

exceptionWait

join