CircuitBreaker (Failsafe 1.0.1 API)

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

```
public class CircuitBreaker
extends Object
```
A circuit breaker that temporarily halts execution when configurable thresholds are exceeded.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class CircuitBreaker.State
The state of the circuit.

Nested Classes
Modifier and Type	Class and Description
`static class`	`CircuitBreaker.State` The state of the circuit.

Constructor Summary

Constructors
Constructor and Description

CircuitBreaker()
Creates a Circuit that opens after a single failure, closes after a single success, and has no delay by default.

Constructors
Constructor and Description
`CircuitBreaker()` Creates a Circuit that opens after a single failure, closes after a single success, and has no delay by default.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`allowsExecution()` Returns whether the circuit allows execution, possibly triggering a state transition.
`void`	`close()` Closes the circuit.
`<T> CircuitBreaker`	`failIf(BiPredicate<T,? extends Throwable> completionPredicate)` Specifies that a failure should be recorded if the `completionPredicate` matches the completion result.
`<T> CircuitBreaker`	`failIf(Predicate<T> resultPredicate)` Specifies that a failure should be recorded if the `resultPredicate` matches the result.
`CircuitBreaker`	`failOn(Class<? extends Throwable>... failures)` Specifies the types to fail on.
`CircuitBreaker`	`failOn(List<Class<? extends Throwable>> failures)` Specifies the types to fail on.
`CircuitBreaker`	`failOn(Predicate<? extends Throwable> failurePredicate)` Specifies that a failure should be recorded if the `failurePredicate` matches the failure.
`CircuitBreaker`	`failWhen(Object result)` Specifies that a failure should be recorded if the execution result matches the `result`.
`Duration`	`getDelay()` Returns the delay before allowing another execution on the circuit.
`Ratio`	`getFailureThreshold()` Gets the ratio of successive failures that must occur when in a closed state in order to open the circuit else `null` if none has been configured.
`CircuitBreaker.State`	`getState()` Gets the state of the circuit.
`Ratio`	`getSuccessThreshold()` Gets the ratio of successive successful executions that must occur when in a half-open state in order to close the circuit else `null` if none has been configured.
`Duration`	`getTimeout()` Returns timeout for executions else `null` if none has been configured.
`void`	`halfOpen()` Half-opens the circuit.
`boolean`	`isClosed()` Returns whether the circuit is closed.
`boolean`	`isFailure(Object result, Throwable failure)` Returns whether the circuit breaker considers the `result` or `throwable` a failure based on the configured conditions, or if `failure` is not null it is not checked by any configured condition.
`boolean`	`isHalfOpen()` Returns whether the circuit is half open.
`boolean`	`isOpen()` Returns whether the circuit is open.
`void`	`onClose(CheckedRunnable runnable)` Calls the `runnable` when the circuit is closed.
`void`	`onHalfOpen(CheckedRunnable runnable)` Calls the `runnable` when the circuit is half-opened.
`void`	`onOpen(CheckedRunnable runnable)` Calls the `runnable` when the circuit is opened.
`void`	`open()` Opens the circuit.
`void`	`recordFailure(Throwable failure)` Records an execution `failure` as a success or failure based on the failure configuration as determined by `isFailure(Object, Throwable)`.
`void`	`recordResult(Object result)` Records an execution `result` as a success or failure based on the failure configuration as determined by `isFailure(Object, Throwable)`.
`void`	`recordSuccess()` Records an execution success.
`String`	`toString()`
`CircuitBreaker`	`withDelay(long delay, TimeUnit timeUnit)` Sets the `delay` to wait in open state before transitioning to half-open.
`CircuitBreaker`	`withFailureThreshold(int failureThreshold)` Sets the number of successive failures that must occur when in a closed state in order to open the circuit.
`CircuitBreaker`	`withFailureThreshold(int failures, int executions)` Sets the ratio of successive failures that must occur when in a closed state in order to open the circuit.
`CircuitBreaker`	`withSuccessThreshold(int successThreshold)` Sets the number of successive successful executions that must occur when in a half-open state in order to close the circuit, else the circuit is re-opened when a failure occurs.
`CircuitBreaker`	`withSuccessThreshold(int successes, int executions)` Sets the ratio of successive successful executions that must occur when in a half-open state in order to close the circuit.
`CircuitBreaker`	`withTimeout(long timeout, TimeUnit timeUnit)` Sets the `timeout` for executions.

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

- Constructor Detail
  - CircuitBreaker
```
public CircuitBreaker()
```
    Creates a Circuit that opens after a single failure, closes after a single success, and has no delay by default.
- Method Detail
  - allowsExecution
```
public boolean allowsExecution()
```
    Returns whether the circuit allows execution, possibly triggering a state transition.
  - close
```
public void close()
```
    Closes the circuit.
  - failIf
```
public <T> CircuitBreaker failIf(BiPredicate<T,? extends Throwable> completionPredicate)
```
    Specifies that a failure should be recorded if the completionPredicate matches the completion result.
    
    Throws:
    
    NullPointerException - if completionPredicate is null
  - failIf
```
public <T> CircuitBreaker failIf(Predicate<T> resultPredicate)
```
    Specifies that a failure should be recorded if the resultPredicate matches the result.
    
    Throws:
    
    NullPointerException - if resultPredicate is null
  - failOn
```
public CircuitBreaker failOn(Class<? extends Throwable>... failures)
```
    Specifies the types to fail on. Applies to any type that is assignable from the failures.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is empty
  - failOn
```
public CircuitBreaker failOn(List<Class<? extends Throwable>> failures)
```
    Specifies the types to fail on. Applies to any type that is assignable from the failures.
    
    Throws:
    
    NullPointerException - if failures is null
    
    IllegalArgumentException - if failures is empty
  - failOn
```
public CircuitBreaker failOn(Predicate<? extends Throwable> failurePredicate)
```
    Specifies that a failure should be recorded if the failurePredicate matches the failure.
    
    Throws:
    
    NullPointerException - if failurePredicate is null
  - failWhen
```
public CircuitBreaker failWhen(Object result)
```
    Specifies that a failure should be recorded if the execution result matches the result.
  - getDelay
```
public Duration getDelay()
```
    Returns the delay before allowing another execution on the circuit. Defaults to Duration.NONE.
    
    See Also:
    
    withDelay(long, TimeUnit)
  - getFailureThreshold
```
public Ratio getFailureThreshold()
```
    Gets the ratio of successive failures that must occur when in a closed state in order to open the circuit else null if none has been configured.
    
    See Also:
    
    withFailureThreshold(int), withFailureThreshold(int, int)
  - getState
```
public CircuitBreaker.State getState()
```
    Gets the state of the circuit.
  - getSuccessThreshold
```
public Ratio getSuccessThreshold()
```
    Gets the ratio of successive successful executions that must occur when in a half-open state in order to close the circuit else null if none has been configured.
    
    See Also:
    
    withSuccessThreshold(int), withSuccessThreshold(int, int)
  - getTimeout
```
public Duration getTimeout()
```
    Returns timeout for executions else null if none has been configured.
    
    See Also:
    
    withTimeout(long, TimeUnit)
  - halfOpen
```
public void halfOpen()
```
    Half-opens the circuit.
  - isClosed
```
public boolean isClosed()
```
    Returns whether the circuit is closed.
  - isFailure
```
public boolean isFailure(Object result,
                         Throwable failure)
```
    Returns whether the circuit breaker considers the result or throwable a failure based on the configured conditions, or if failure is not null it is not checked by any configured condition.
    
    See Also:
    
    failIf(BiPredicate), failIf(Predicate), failOn(Class...), failOn(List), failOn(Predicate), failWhen(Object)
  - isHalfOpen
```
public boolean isHalfOpen()
```
    Returns whether the circuit is half open.
  - isOpen
```
public boolean isOpen()
```
    Returns whether the circuit is open.
  - onClose
```
public void onClose(CheckedRunnable runnable)
```
    Calls the runnable when the circuit is closed.
  - onHalfOpen
```
public void onHalfOpen(CheckedRunnable runnable)
```
    Calls the runnable when the circuit is half-opened.
  - onOpen
```
public void onOpen(CheckedRunnable runnable)
```
    Calls the runnable when the circuit is opened.
  - open
```
public void open()
```
    Opens the circuit.
  - recordFailure
```
public void recordFailure(Throwable failure)
```
    Records an execution failure as a success or failure based on the failure configuration as determined by isFailure(Object, Throwable).
    
    See Also:
    
    isFailure(Object, Throwable)
  - recordResult
```
public void recordResult(Object result)
```
    Records an execution result as a success or failure based on the failure configuration as determined by isFailure(Object, Throwable).
    
    See Also:
    
    isFailure(Object, Throwable)
  - recordSuccess
```
public void recordSuccess()
```
    Records an execution success.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - withDelay
```
public CircuitBreaker withDelay(long delay,
                                TimeUnit timeUnit)
```
    Sets the delay to wait in open state before transitioning to half-open.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if delay <= 0
  - withFailureThreshold
```
public CircuitBreaker withFailureThreshold(int failureThreshold)
```
    Sets the number of successive failures that must occur when in a closed state in order to open the circuit.
    
    Throws:
    
    IllegalArgumentException - if failureThresh < 1
  - withFailureThreshold
```
public CircuitBreaker withFailureThreshold(int failures,
                                           int executions)
```
    Sets the ratio of successive failures that must occur when in a closed state in order to open the circuit. For example: 5, 10 would open the circuit if 5 out of the last 10 executions result in a failure. The circuit will not be opened until at least executions executions have taken place.
    
    Parameters:
    
    failures - The number of failures that must occur in order to open the circuit
    
    executions - The number of executions to measure the failures against
    
    Throws:
    
    IllegalArgumentException - if failures < 1, executions < 1, or failures is < executions
  - withSuccessThreshold
```
public CircuitBreaker withSuccessThreshold(int successThreshold)
```
    Sets the number of successive successful executions that must occur when in a half-open state in order to close the circuit, else the circuit is re-opened when a failure occurs.
    
    Throws:
    
    IllegalArgumentException - if successThreshold < 1
  - withSuccessThreshold
```
public CircuitBreaker withSuccessThreshold(int successes,
                                           int executions)
```
    Sets the ratio of successive successful executions that must occur when in a half-open state in order to close the circuit. For example: 5, 10 would close the circuit if 5 out of the last 10 executions were successful. The circuit will not be closed until at least executions executions have taken place.
    
    Parameters:
    
    successes - The number of successful executions that must occur in order to open the circuit
    
    executions - The number of executions to measure the successes against
    
    Throws:
    
    IllegalArgumentException - if successes < 1, executions < 1, or successes is < executions
  - withTimeout
```
public CircuitBreaker withTimeout(long timeout,
                                  TimeUnit timeUnit)
```
    Sets the timeout for executions. Executions that exceed this timeout are not interrupted, but are recorded as failures once they naturally complete.
    
    Throws:
    
    NullPointerException - if timeUnit is null
    
    IllegalArgumentException - if timeout <= 0

Class CircuitBreaker

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

CircuitBreaker

Method Detail

allowsExecution

close

failIf

failIf

failOn

failOn

failOn

failWhen

getDelay

getFailureThreshold

getState

getSuccessThreshold

getTimeout

halfOpen

isClosed

isFailure

isHalfOpen

isOpen

onClose

onHalfOpen

onOpen

open

recordFailure

recordResult

recordSuccess

toString

withDelay

withFailureThreshold

withFailureThreshold

withSuccessThreshold

withSuccessThreshold

withTimeout