Circuit breaker with Resilience4j in Spring Boot - Mini Project: Build & Apply

Circuit breaker with Resilience4j

📖 Scenario: You are building a Spring Boot microservice that calls an external payment API. The payment API occasionally goes down, and you want to prevent cascading failures by adding a circuit breaker using Resilience4j.

🎯 Goal: Add Resilience4j circuit breaker to a Spring Boot service method with a fallback that returns a safe default response when the payment API is unavailable.

📋 What You'll Learn

Add the Resilience4j Spring Boot starter dependency

Configure circuit breaker properties in application.yml

Create a service method annotated with @CircuitBreaker

Implement a fallback method that returns a default response

💡 Why This Matters

🌍 Real World

Circuit breakers are essential in microservice architectures where services depend on external APIs that can fail. They prevent cascading failures and keep applications responsive.

💼 Career

Understanding resilience patterns like circuit breakers is critical for backend developers building production microservices in Spring Boot.

1

Add Resilience4j dependency

Add the Resilience4j Spring Boot starter dependency to your pom.xml file inside the <dependencies> section.

Spring Boot

    
        org.springframework.boot
        spring-boot-starter-web
    
    
    

Need a hint?

The group ID is io.github.resilience4j and the artifact ID is resilience4j-spring-boot3.

2

Configure circuit breaker in application.yml

Add circuit breaker configuration in application.yml. Set the sliding window size to 10 calls, failure rate threshold to 50 percent, and wait duration in open state to 30 seconds.

Spring Boot

# application.yml
resilience4j:
  circuitbreaker:
    instances:
      paymentService:
        # Configure sliding window size, failure threshold, and wait duration
        # Your code here

Need a hint?

Use slidingWindowSize, failureRateThreshold, and waitDurationInOpenState under the named instance.

3

Create service method with @CircuitBreaker

Create a PaymentService class with a method processPayment annotated with @CircuitBreaker. Set the circuit breaker name to paymentService and the fallback method to paymentFallback. The method should use RestTemplate to call the payment API.

Spring Boot

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class PaymentService {

    private final RestTemplate restTemplate;

    public PaymentService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    // Add @CircuitBreaker annotation with name and fallbackMethod
    // Call payment API using restTemplate
    // Your code here
}

Need a hint?

Use @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback") above your method.

4

Implement fallback method

Add a fallback method called paymentFallback in the same class. It must have the same parameters as processPayment plus a Throwable parameter. Return a default response string indicating the payment is queued for retry.

Spring Boot

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

@Service
public class PaymentService {

    private final RestTemplate restTemplate;

    public PaymentService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public String processPayment(String orderId) {
        return restTemplate.getForObject(
            "http://payment-service/api/pay/" + orderId, String.class);
    }

    // Create paymentFallback with same params + Throwable
    // Return a default response
    // Your code here
}

Need a hint?

The fallback method must match the return type and parameters of the original method, with an additional Throwable parameter at the end.