Introduction

Resilience4j is a lightweight, easy-to-use fault tolerance library inspired by
Netflix Hystrix, but designed for Java 8 and functional programming. Lightweight, because the library only uses Vavr, which does not have any other external library dependencies. Netflix Hystrix, in contrast, has a compile dependency to Archaius which has many more external library dependencies such as Guava and Apache Commons Configuration.

Resilience4j provides higher-order functions (decorators) to enhance any functional interface, lambda expression or method reference with a Circuit Breaker, Rate Limiter, Retry or Bulkhead. You can stack more than one decorator on any functional interface, lambda expression or method reference. The advantage is that you have the choice to select the decorators you need and nothing else.

With Resilience4j you don’t have to go all-in, you can pick what you need.

Sneak preview

The following example shows how to decorate a lambda expression with a CircuitBreaker and Retry in order to retry the call at most 3 times when an exception occurs.
You can configure the wait interval between retries and also configure a custom backoff algorithm.
The example uses Vavr’s Try monad to recover from an exception and invoke another lambda expression as a fallback, when all retries have failed.

// Create a CircuitBreaker with default configuration
CircuitBreaker circuitBreaker = CircuitBreaker
  .ofDefaults("backendService");

// Create a Retry with default configuration
// 3 retry attempts and a fixed time interval between retries of 500ms
Retry retry = Retry
  .ofDefaults("backendService");

// Create a Bulkhead with default configuration
Bulkhead bulkhead = Bulkhead
  .ofDefaults("backendService");

Supplier<String> supplier = () -> backendService
  .doSomething(param1, param2)

// Decorate your call to backendService.doSomething() 
// with a Bulkhead, CircuitBreaker and Retry
// **note: you will need the resilience4j-all dependency for this
Supplier<String> decoratedSupplier = Decorators.ofSupplier(supplier)
  .withRetry(retry)
  .withCircuitBreaker(circuitBreaker)
  .withBulkhead(bulkhead)
  .decorate();

// Execute the decorated supplier and recover from any exception
String result = Try.ofSupplier(decoratedSupplier)
  .recover(throwable -> "Hello from Recovery").get();

// When you don't want to decorate your lambda expression,
// but just execute it and protect the call by a CircuitBreaker.
String result = circuitBreaker
  .executeSupplier(backendService::doSomething);

Modularization

With Resilience4j you don't have to go all-in, you can pick what you need.

Resilience provides several core modules and add-on modules:

All-inclusive

resilience4j-all

Core modules:

resilience4j-circuitbreaker: Circuit breaking
resilience4j-ratelimiter: Rate limiting
resilience4j-bulkhead: Bulkheading
resilience4j-retry: Automatic retrying (sync and async)
resilience4j-cache: Result caching
resilience4j-timelimiter: Timeout handling

Add-on modules

resilience4j-retrofit: Retrofit adapter
resilience4j-feign: Feign adapter
resilience4j-consumer: Circular Buffer Event consumer
resilience4j-kotlin: Kotlin coroutines support

Frameworks modules

resilience4j-spring-boot: Spring Boot Starter
resilience4j-spring-boot2: Spring Boot 2 Starter
resilience4j-ratpack: Ratpack Starter
resilience4j-vertx: Vertx Future decorator

Reactive modules

resilience4j-rxjava2: Custom RxJava2 operators
resilience4j-reactor: Custom Spring Reactor operators

Metrics modules

resilience4j-micrometer: Micrometer Metrics exporter
resilience4j-metrics: Dropwizard Metrics exporter
resilience4j-prometheus: Prometheus Metrics exporter