close

Articles Home » Programming Languages » How to Implement Circuit Breaker Pattern in Java with Resilience4j

How to Implement Circuit Breaker Pattern in Java with Resilience4j

Introduction

The Circuit Breaker pattern is a design pattern used in software development to prevent cascading failures in distributed systems. It helps to handle the failure of services gracefully and ensures that the system remains responsive by avoiding repeated failed calls. Resilience4j is a lightweight, easy-to-use fault tolerance library inspired by Netflix Hystrix but designed for Java 8 and functional programming. In this tutorial, we’ll explore how to implement the Circuit Breaker pattern in Java using Resilience4j.

1. Introduction to Circuit Breaker Pattern

The Circuit Breaker pattern helps to manage and prevent the failure of a service or network call. It works similarly to an electrical circuit breaker. When a service repeatedly fails, the circuit breaker trips and stops further calls to the failing service for a specified period, allowing it to recover.

States of a Circuit Breaker

A Circuit Breaker typically has three states:

  1. Closed: All requests are allowed to pass through. If the number of failures exceeds a threshold, the circuit breaker transitions to the Open state.
  2. Open: All requests are immediately failed for a specified period (timeout). After this period, the circuit breaker transitions to the Half-Open state.
  3. Half-Open: A limited number of requests are allowed to pass through to test if the underlying issue has been resolved. If successful, the circuit breaker transitions back to the Closed state; if not, it returns to the Open state.

2. Overview of Resilience4j

Resilience4j is a lightweight, flexible, and easy-to-use library designed to handle fault tolerance in Java applications. It provides various modules, including Circuit Breaker, Retry, Rate Limiter, Bulkhead, and Time Limiter. Resilience4j is designed with a functional programming approach, leveraging Java 8 features like lambdas and functional interfaces.

Key Features of Resilience4j

  • Lightweight and fast
  • Functional programming support
  • Asynchronous and reactive support
  • Easy integration with popular frameworks (Spring Boot, RxJava, etc.)
  • Detailed metrics and monitoring capabilities

3. Setting up the Project

Let’s start by setting up a simple Java project with Maven and adding the necessary dependencies for Resilience4j.

Maven Project Setup

Create a new Maven project and add the following dependencies to your pom.xml file:

<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>
    <artifactId>resilience4j-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- Resilience4j dependencies -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-all</artifactId>
            <version>1.7.1</version>
        </dependency>
        <!-- Jackson for JSON processing -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.3</version>
        </dependency>
        <!-- SLF4J for logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.32</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.32</version>
        </dependency>
    </dependencies>
</project>Code language: HTML, XML (xml)

4. Implementing Circuit Breaker with Resilience4j

Now, let’s implement a simple service with a Circuit Breaker using Resilience4j. We’ll create a service that makes a network call to a mock API.

Creating the Service Class

Create a new class RemoteService that simulates a network call:

package com.example.resilience4j;

import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Scanner;

public class RemoteService {

    public String fetchData() throws Exception {
        URL url = new URL("https://jsonplaceholder.typicode.com/posts/1");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestMethod("GET");
        conn.connect();

        int responseCode = conn.getResponseCode();
        if (responseCode != 200) {
            throw new RuntimeException("Failed : HTTP error code : " + responseCode);
        }

        Scanner scanner = new Scanner(url.openStream());
        StringBuilder response = new StringBuilder();
        while (scanner.hasNext()) {
            response.append(scanner.nextLine());
        }
        scanner.close();

        return response.toString();
    }
}Code language: Java (java)

Wrapping the Service Call with Circuit Breaker

Create a new class ServiceWithCircuitBreaker that wraps the RemoteService call with a Circuit Breaker:

package com.example.resilience4j;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.decorators.Decorators;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.util.function.Supplier;

public class ServiceWithCircuitBreaker {

    private static final Logger logger = LoggerFactory.getLogger(ServiceWithCircuitBreaker.class);
    private final RemoteService remoteService;
    private final CircuitBreaker circuitBreaker;

    public ServiceWithCircuitBreaker(RemoteService remoteService) {
        this.remoteService = remoteService;

        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
                .failureRateThreshold(50)
                .waitDurationInOpenState(Duration.ofMillis(1000))
                .slidingWindowSize(2)
                .build();

        CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
        this.circuitBreaker = registry.circuitBreaker("remoteService");
    }

    public String fetchData() {
        Supplier<String> decoratedSupplier = Decorators.ofSupplier(remoteService::fetchData)
                .withCircuitBreaker(circuitBreaker)
                .decorate();

        try {
            return decoratedSupplier.get();
        } catch (Exception e) {
            logger.error("Error during fetchData call", e);
            return "Fallback response";
        }
    }
}Code language: Java (java)

Testing the Circuit Breaker

Create a Main class to test the Circuit Breaker:

package com.example.resilience4j;

public class Main {

    public static void main(String[] args) {
        RemoteService remoteService = new RemoteService();
        ServiceWithCircuitBreaker serviceWithCircuitBreaker = new ServiceWithCircuitBreaker(remoteService);

        for (int i = 0; i < 10; i++) {
            String response = serviceWithCircuitBreaker.fetchData();
            System.out.println("Response: " + response);
        }
    }
}Code language: Java (java)

5. Advanced Configuration

Resilience4j provides extensive configuration options for the Circuit Breaker. Let’s explore some advanced configurations.

Circuit Breaker Configuration Parameters

  • failureRateThreshold: The failure rate threshold in percentage. When the failure rate is equal to or greater than this threshold, the Circuit Breaker transitions to the Open state.
  • waitDurationInOpenState: The time the Circuit Breaker stays in the Open state before transitioning to Half-Open.
  • slidingWindowType: The type of the sliding window which is used to record the outcome of calls. The window can either be count-based or time-based.
  • slidingWindowSize: The size of the sliding window. If the sliding window is count-based, it represents the number of calls. If it is time-based, it represents the duration in seconds.
  • permittedNumberOfCallsInHalfOpenState: The number of permitted calls when the Circuit Breaker is in the Half-Open state.
  • minimumNumberOfCalls: The minimum number of calls which are required before the Circuit Breaker can calculate the error rate.
  • automaticTransitionFromOpenToHalfOpenEnabled: If set to true, the Circuit Breaker will automatically transition from Open to Half-Open state after the wait duration.

Example of Advanced Configuration

CircuitBreakerConfig advancedConfig = CircuitBreakerConfig.custom()
        .failureRateThreshold(50)
        .waitDurationInOpenState(Duration.ofSeconds(1))
        .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
        .slidingWindowSize(10)
        .permittedNumberOfCallsInHalfOpenState(3)
        .minimumNumberOfCalls(5)
        .automaticTransitionFromOpenToHalfOpenEnabled(true)
        .build();Code language: Java (java)

6. Monitoring and Metrics

Resilience4j provides detailed metrics for monitoring the Circuit Breaker state and performance. These metrics can be integrated with monitoring tools like Prometheus and

Grafana.

Enabling Metrics

Add the resilience4j-micrometer dependency to your pom.xml:

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-micrometer</artifactId>
    <version>1.7.1</version>
</dependency>Code language: HTML, XML (xml)

Example of Metrics Integration

package com.example.resilience4j;

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
import io.github.resilience4j.micrometer.CircuitBreakerMetrics;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;

public class MetricsExample {

    public static void main(String[] args) {
        MeterRegistry meterRegistry = new SimpleMeterRegistry();

        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
                .failureRateThreshold(50)
                .waitDurationInOpenState(Duration.ofMillis(1000))
                .slidingWindowSize(2)
                .build();

        CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
        CircuitBreaker circuitBreaker = registry.circuitBreaker("remoteService");

        CircuitBreakerMetrics.ofCircuitBreakerRegistry(meterRegistry, registry);

        // Now the metrics are available for monitoring
    }
}Code language: Java (java)

7. Example Use Cases

Scenario 1: Remote API Calls

A common use case for the Circuit Breaker pattern is protecting remote API calls. If an external API is experiencing issues, the Circuit Breaker can prevent your application from being overwhelmed by failing requests.

public class RemoteApiService {

    private final CircuitBreaker circuitBreaker;

    public RemoteApiService() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
                .failureRateThreshold(50)
                .waitDurationInOpenState(Duration.ofSeconds(5))
                .slidingWindowSize(10)
                .build();

        CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
        this.circuitBreaker = registry.circuitBreaker("remoteApiService");
    }

    public String callApi() {
        Supplier<String> decoratedSupplier = Decorators.ofSupplier(this::fetchDataFromApi)
                .withCircuitBreaker(circuitBreaker)
                .decorate();

        try {
            return decoratedSupplier.get();
        } catch (Exception e) {
            return "Fallback response";
        }
    }

    private String fetchDataFromApi() {
        // Simulate API call
        return "API response";
    }
}Code language: Java (java)

Scenario 2: Database Operations

Another use case is protecting database operations. If the database is experiencing high latency or downtime, the Circuit Breaker can prevent your application from making repeated failed calls.

public class DatabaseService {

    private final CircuitBreaker circuitBreaker;

    public DatabaseService() {
        CircuitBreakerConfig config = CircuitBreakerConfig.custom()
                .failureRateThreshold(50)
                .waitDurationInOpenState(Duration.ofSeconds(2))
                .slidingWindowSize(5)
                .build();

        CircuitBreakerRegistry registry = CircuitBreakerRegistry.of(config);
        this.circuitBreaker = registry.circuitBreaker("databaseService");
    }

    public String fetchData() {
        Supplier<String> decoratedSupplier = Decorators.ofSupplier(this::queryDatabase)
                .withCircuitBreaker(circuitBreaker)
                .decorate();

        try {
            return decoratedSupplier.get();
        } catch (Exception e) {
            return "Fallback response";
        }
    }

    private String queryDatabase() {
        // Simulate database query
        return "Database result";
    }
}Code language: Java (java)

8. Best Practices

  • Set appropriate thresholds: Configure the failure rate threshold, wait duration, and other parameters according to your application’s requirements.
  • Monitor and tune: Continuously monitor the Circuit Breaker metrics and tune the configuration based on the observed behavior.
  • Fallback strategies: Implement appropriate fallback strategies to handle failures gracefully.
  • Use bulkheads: Combine the Circuit Breaker pattern with Bulkhead pattern to limit the number of concurrent calls to a resource.
  • Test thoroughly: Test the Circuit Breaker behavior under different failure scenarios to ensure it works as expected.

9. Conclusion

In this tutorial, we’ve explored how to implement the Circuit Breaker pattern in Java using Resilience4j. We’ve covered the basics of the Circuit Breaker pattern, set up a Java project with Resilience4j, and implemented a simple service with a Circuit Breaker. We’ve also looked at advanced configuration options, monitoring and metrics, example use cases, and best practices.

By following this tutorial, you can enhance the fault tolerance of your Java applications and ensure they remain responsive even when facing failures in external services or resources. Resilience4j provides a powerful and flexible way to implement the Circuit Breaker pattern, making it an essential tool for building resilient distributed systems.

Related posts: