Circuit Breakers and Retries with Resilience4j

<dependency>
  <groupId>io.github.resilience4j</groupId>
  <artifactId>resilience4j-spring-boot4</artifactId>
  <version>2.4.0</version>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aspectj</artifactId>
</dependency>

//RemoteCatalog.java
package com.javabrahman.cloud.resilience;

import org.springframework.stereotype.Component;

@Component
public class RemoteCatalog {

  private int priceFailuresLeft;
  private boolean inventoryUp = true;

  public void failNextPriceCalls(int count) { priceFailuresLeft = count; }
  public void setInventoryUp(boolean up) { inventoryUp = up; }

  public int fetchPrice(String isbn) {
    if (isbn.equals("000")) {
      throw new BookNotFoundException("no book with ISBN " + isbn);
    }
    if (priceFailuresLeft > 0) {
      priceFailuresLeft--;
      System.out.println("      catalog service called - fails");
      throw new RemoteCallException("catalog service did not answer");
    }
    System.out.println("      catalog service called - answers 450");
    return 450;
  }

  public int fetchStock(String isbn) {
    if (!inventoryUp) {
      System.out.println("      inventory service called - fails");
      throw new RemoteCallException("inventory service did not answer");
    }
    System.out.println("      inventory service called - answers 12");
    return 12;
  }

  public String fetchReviews(String isbn) {
    try {
      Thread.sleep(3000);   // a service that has become very slow
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
    return "4.7 stars";
  }
}

//RemoteCallException.java
package com.javabrahman.cloud.resilience;

public class RemoteCallException extends RuntimeException {
  public RemoteCallException(String message) { super(message); }
}

//BookNotFoundException.java
package com.javabrahman.cloud.resilience;

public class BookNotFoundException extends RuntimeException {
  public BookNotFoundException(String message) { super(message); }
}

//BookService.java
package com.javabrahman.cloud.resilience;

import io.github.resilience4j.circuitbreaker.CallNotPermittedException;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeoutException;
import org.springframework.stereotype.Service;

@Service
public class BookService {

  private final RemoteCatalog remote;

  BookService(RemoteCatalog remote) {
    this.remote = remote;
  }

  @Retry(name = "price", fallbackMethod = "lastKnownPrice")
  public int price(String isbn) {
    return remote.fetchPrice(isbn);
  }

  private int lastKnownPrice(String isbn, RemoteCallException e) {
    System.out.println("      fallback: the last known price");
    return 440;
  }

  @CircuitBreaker(name = "inventory", fallbackMethod = "stockUnknown")
  public int stock(String isbn) {
    return remote.fetchStock(isbn);
  }

  private int stockUnknown(String isbn, RemoteCallException e) {
    return -1;   // the call was made and failed
  }

  private int stockUnknown(String isbn, CallNotPermittedException e) {
    System.out.println("      circuit is open - inventory service NOT called");
    return -1;   // the call was not made at all
  }

  @TimeLimiter(name = "reviews", fallbackMethod = "noReviews")
  public CompletableFuture<String> reviews(String isbn) {
    return CompletableFuture.supplyAsync(() -> remote.fetchReviews(isbn));
  }

  private CompletableFuture<String> noReviews(String isbn, TimeoutException e) {
    return CompletableFuture.completedFuture("reviews are not available right now");
  }
}

# retry "price": 3 attempts in all, waiting 200 ms and then 400 ms
resilience4j.retry.instances.price.max-attempts=3
resilience4j.retry.instances.price.wait-duration=200ms
resilience4j.retry.instances.price.enable-exponential-backoff=true
resilience4j.retry.instances.price.exponential-backoff-multiplier=2
resilience4j.retry.instances.price.ignore-exceptions=com.javabrahman.cloud.resilience.BookNotFoundException

# circuit breaker "inventory": open when half of the last 4 calls failed, try again after 2 seconds
resilience4j.circuitbreaker.instances.inventory.sliding-window-type=COUNT_BASED
resilience4j.circuitbreaker.instances.inventory.sliding-window-size=4
resilience4j.circuitbreaker.instances.inventory.minimum-number-of-calls=4
resilience4j.circuitbreaker.instances.inventory.failure-rate-threshold=50
resilience4j.circuitbreaker.instances.inventory.wait-duration-in-open-state=2s
resilience4j.circuitbreaker.instances.inventory.permitted-number-of-calls-in-half-open-state=2

# time limiter "reviews": give up after half a second
resilience4j.timelimiter.instances.reviews.timeout-duration=500ms

//ResilienceApp.java
package com.javabrahman.cloud.resilience;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class ResilienceApp {

  @Bean
  CommandLineRunner demo(BookService books, RemoteCatalog remote, CircuitBreakerRegistry breakers) {
    return args -> {
      System.out.println("1. Retry - the catalog service fails twice, then works");
      remote.failNextPriceCalls(2);
      long start = System.currentTimeMillis();
      System.out.println("   price = " + books.price("978-1") + ", after " + (System.currentTimeMillis() - start) + " ms");

      System.out.println("2. Retry - the catalog service keeps failing");
      remote.failNextPriceCalls(10);
      System.out.println("   price = " + books.price("978-1"));

      System.out.println("3. Retry - an error that retrying cannot fix");
      try {
        books.price("000");
      } catch (BookNotFoundException e) {
        System.out.println("   BookNotFoundException: " + e.getMessage());
      }

      CircuitBreaker breaker = breakers.circuitBreaker("inventory");
      breaker.getEventPublisher().onStateTransition(event ->
          System.out.println("   >>> " + event.getStateTransition()));

      System.out.println("4. Circuit breaker - the inventory service goes down");
      remote.setInventoryUp(false);
      for (int call = 1; call <= 6; call++) {
        System.out.println("   call " + call + ": stock = " + books.stock("978-1") + "   [" + breaker.getState() + "]");
      }

      CircuitBreaker.Metrics metrics = breaker.getMetrics();
      System.out.println("   failure rate " + metrics.getFailureRate() + "%, calls rejected while open: "
          + metrics.getNumberOfNotPermittedCalls());

      System.out.println("5. Circuit breaker - two seconds later, the inventory service is back");
      Thread.sleep(2100);
      remote.setInventoryUp(true);
      for (int call = 7; call <= 9; call++) {
        System.out.println("   call " + call + ": stock = " + books.stock("978-1") + "   [" + breaker.getState() + "]");
      }


      System.out.println("6. Time limiter - the review service takes 3 seconds");
      start = System.currentTimeMillis();
      String reviews = books.reviews("978-1").get();
      System.out.println("   " + reviews + ", after " + (System.currentTimeMillis() - start) + " ms");
      System.exit(0);
    };
  }

  public static void main(String[] args) {
    SpringApplication.run(ResilienceApp.class, args);
  }
}

resilience4j.bulkhead.instances.reviews.max-concurrent-calls=10
resilience4j.bulkhead.instances.reviews.max-wait-duration=0

resilience4j.ratelimiter.instances.partner.limit-for-period=50
resilience4j.ratelimiter.instances.partner.limit-refresh-period=1s
resilience4j.ratelimiter.instances.partner.timeout-duration=0