Spring Boot Circuit Breaker with Resilience4j: Java 21 Enterprise

The Circuit Breaker pattern acts as a safety mechanism in distributed systems, preventing cascading failures when external services become unresponsive. Inspired by electrical circuit breakers, it monitors call success rates and “trips” to an OPEN state when failures exceed thresholds, blocking further calls to protect the calling service. This solves critical microservices problems like the “thundering herd” effect (massive retries overwhelming failing services), resource exhaustion from endless failed attempts, and complete system outages from dependent service failures.

Why Circuit Breakers Matter in Microservices

In modern microservices architectures, services depend on dozens of external APIs, databases, and third-party services. When one fails, naive implementations keep retrying, consuming CPU, memory, and network bandwidth while providing no value. Circuit breakers provide four key benefits:

Fail Fast: Immediately reject calls during outages instead of waiting timeouts
Graceful Degradation: Fallback methods return cached/default data
Self-Healing: Automatically test recovery and resume normal operation
Observability: Rich metrics for monitoring and alerting

Real-world examples include e-commerce checkouts failing when payment gateways timeout, or analytics services crashing when data warehouses go down. Circuit breakers ensure core functionality survives.

What is Resilience4j and Why It Matters

Resilience4j is a lightweight, fault-tolerance library inspired by Netflix Hystrix but designed for modern JVM applications with better performance and functional programming support. Unlike Hystrix (now in maintenance mode), Resilience4j is actively maintained, supports Spring Boot 3 natively, and provides circuit breakers, retries, rate limiters, and bulkheads as composable modules. It solves the complexity of manually implementing resilience patterns by providing battle-tested, configurable components with rich metrics, event streaming, and seamless Spring integration via AOP annotations. Available since 2017, it’s become the de facto standard for Java microservices resilience.

Spring Boot Circuit Breaker Resilience4

Complete Maven Setup (pom.xml)

Java 21 with Spring Boot 3.3.5 requires specific Resilience4j dependencies. The resilience4j-spring-boot3 starter handles AOP integration, while Actuator exposes metrics endpoints.

<?xml version="1.0" encoding="UTF-8"?>
<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 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.5</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>circuit-breaker-demo</artifactId>
    <version>1.0.0</version>
    <name>circuit-breaker-demo</name>
    <description>Spring Boot 3 Circuit Breaker with Resilience4j</description>
    
    <properties>
        <java.version>21</java.version>
        <resilience4j.version>2.2.0</resilience4j.version>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Actuator for monitoring -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        
        <!-- Resilience4j Spring Boot 3 Starter -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-spring-boot3</artifactId>
        </dependency>
        
        <!-- Circuit Breaker Core -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-circuitbreaker</artifactId>
            <version>${resilience4j.version}</version>
        </dependency>
        
        <!-- Micrometer Prometheus (Optional monitoring) -->
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>
        
        <!-- Test dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

<?xml version="1.0" encoding="UTF-8"?>
<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 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.3.5</version>
        <relativePath/>
    </parent>
    
    <groupId>com.example</groupId>
    <artifactId>circuit-breaker-demo</artifactId>
    <version>1.0.0</version>
    <name>circuit-breaker-demo</name>
    <description>Spring Boot 3 Circuit Breaker with Resilience4j</description>
    
    <properties>
        <java.version>21</java.version>
        <resilience4j.version>2.2.0</resilience4j.version>
    </properties>
    
    <dependencies>
        <!-- Spring Boot Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        
        <!-- Actuator for monitoring -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        
        <!-- Resilience4j Spring Boot 3 Starter -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-spring-boot3</artifactId>
        </dependency>
        
        <!-- Circuit Breaker Core -->
        <dependency>
            <groupId>io.github.resilience4j</groupId>
            <artifactId>resilience4j-circuitbreaker</artifactId>
            <version>${resilience4j.version}</version>
        </dependency>
        
        <!-- Micrometer Prometheus (Optional monitoring) -->
        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
        </dependency>
        
        <!-- Test dependencies -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.testcontainers</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

XML

Advanced Application Configuration

Configure multiple circuit breaker instances with production-grade settings. Use both COUNT_BASED and TIME_BASED sliding windows.

server:
  port: 8080
  shutdown: graceful

# Logging
logging:
  level:
    com.example: DEBUG
    io.github.resilience4j: TRACE

# Resilience4j Circuit Breaker Configurations
resilience4j:
  circuitbreaker:
    configs:
      default:
        registerHealthIndicator: true
        eventConsumerBufferSize: 100
        automaticTransitionFromOpenToHalfOpenEnabled: true
        slidingWindowType: COUNT_BASED
    
    instances:
      paymentService:
        # Production payment gateway settings
        failureRateThreshold: 25
        minimumNumberOfCalls: 8
        permittedNumberOfCallsInHalfOpenState: 2
        waitDurationInOpenState: 30s
        slidingWindowSize: 20
        slowCallRateThreshold: 75
        slowCallDurationThreshold: 500ms
        recordExceptions:
          - java.util.concurrent.TimeoutException
          - io.github.resilience4j.circuitbreaker.CallNotPermittedException
        
      backendApi:
        # Internal API with higher tolerance
        failureRateThreshold: 50
        minimumNumberOfCalls: 5
        waitDurationInOpenState: 10s
        slidingWindowSize: 10
        slidingWindowType: TIME_BASED
        waitDurationInOpenState: 10s
        
      databaseService:
        # Database calls - very conservative
        failureRateThreshold: 10
        minimumNumberOfCalls: 3
        waitDurationInOpenState: 60s
        slidingWindowSize: 5

# Actuator endpoints exposure
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,circuitbreakers
  endpoint:
    health:
      show-details: always
      show-components: always
    circuitbreakers:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
  info:
    env:
      enabled: true

server:
  port: 8080
  shutdown: graceful

# Logging
logging:
  level:
    com.example: DEBUG
    io.github.resilience4j: TRACE

# Resilience4j Circuit Breaker Configurations
resilience4j:
  circuitbreaker:
    configs:
      default:
        registerHealthIndicator: true
        eventConsumerBufferSize: 100
        automaticTransitionFromOpenToHalfOpenEnabled: true
        slidingWindowType: COUNT_BASED
    
    instances:
      paymentService:
        # Production payment gateway settings
        failureRateThreshold: 25
        minimumNumberOfCalls: 8
        permittedNumberOfCallsInHalfOpenState: 2
        waitDurationInOpenState: 30s
        slidingWindowSize: 20
        slowCallRateThreshold: 75
        slowCallDurationThreshold: 500ms
        recordExceptions:
          - java.util.concurrent.TimeoutException
          - io.github.resilience4j.circuitbreaker.CallNotPermittedException
        
      backendApi:
        # Internal API with higher tolerance
        failureRateThreshold: 50
        minimumNumberOfCalls: 5
        waitDurationInOpenState: 10s
        slidingWindowSize: 10
        slidingWindowType: TIME_BASED
        waitDurationInOpenState: 10s
        
      databaseService:
        # Database calls - very conservative
        failureRateThreshold: 10
        minimumNumberOfCalls: 3
        waitDurationInOpenState: 60s
        slidingWindowSize: 5

# Actuator endpoints exposure
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus,circuitbreakers
  endpoint:
    health:
      show-details: always
      show-components: always
    circuitbreakers:
      enabled: true
  metrics:
    export:
      prometheus:
        enabled: true
  info:
    env:
      enabled: true

YAML

Realistic Backend Service Implementation

Simulate three external dependencies: payment gateway (25% failure), backend API (40% failure), and database (10% failure). Includes realistic latencies and timeout exceptions.

package com.example.service;

import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

@Service
public class ExternalServices {
    
    private final Random random = new Random(42); // Fixed seed for reproducible tests
    
    public String callPaymentGateway() {
        if (random.nextInt(100) < 25) { // 25% failure rate
            throw new RuntimeException("Payment gateway timeout at " + LocalDateTime.now());
        }
        simulateNetworkDelay(800, 1500);
        return "Payment processed: AUTH-" + random.nextInt(9999);
    }
    
    public String callBackendApi() {
        if (random.nextInt(100) < 40) { // 40% failure rate
            throw new RuntimeException("Backend API unavailable");
        }
        simulateNetworkDelay(200, 600);
        return "Data from backend: " + LocalDateTime.now();
    }
    
    public String queryDatabase() {
        if (random.nextInt(100) < 10) { // 10% failure rate
            throw new RuntimeException("Database connection lost");
        }
        simulateNetworkDelay(50, 200);
        return "User data retrieved successfully";
    }
    
    @TimeLimiter(name = "databaseService")
    public CompletableFuture<String> asyncDatabaseQuery() {
        return CompletableFuture.supplyAsync(() -> queryDatabase());
    }
    
    private void simulateNetworkDelay(int minMs, int maxMs) {
        try {
            Thread.sleep(minMs + random.nextInt(maxMs - minMs));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted during network simulation", e);
        }
    }
}

package com.example.service;

import io.github.resilience4j.timelimiter.annotation.TimeLimiter;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.Random;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

@Service
public class ExternalServices {
    
    private final Random random = new Random(42); // Fixed seed for reproducible tests
    
    public String callPaymentGateway() {
        if (random.nextInt(100) < 25) { // 25% failure rate
            throw new RuntimeException("Payment gateway timeout at " + LocalDateTime.now());
        }
        simulateNetworkDelay(800, 1500);
        return "Payment processed: AUTH-" + random.nextInt(9999);
    }
    
    public String callBackendApi() {
        if (random.nextInt(100) < 40) { // 40% failure rate
            throw new RuntimeException("Backend API unavailable");
        }
        simulateNetworkDelay(200, 600);
        return "Data from backend: " + LocalDateTime.now();
    }
    
    public String queryDatabase() {
        if (random.nextInt(100) < 10) { // 10% failure rate
            throw new RuntimeException("Database connection lost");
        }
        simulateNetworkDelay(50, 200);
        return "User data retrieved successfully";
    }
    
    @TimeLimiter(name = "databaseService")
    public CompletableFuture<String> asyncDatabaseQuery() {
        return CompletableFuture.supplyAsync(() -> queryDatabase());
    }
    
    private void simulateNetworkDelay(int minMs, int maxMs) {
        try {
            Thread.sleep(minMs + random.nextInt(maxMs - minMs));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Interrupted during network simulation", e);
        }
    }
}

Java

Feature-Rich Controller Implementation

Multiple endpoints demonstrate different circuit breaker configurations and fallback strategies.

package com.example.controller;

import com.example.service.ExternalServices;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.concurrent.TimeoutException;

@RestController
@RequestMapping("/api")
@RequiredArgsConstructor
@Slf4j
public class ResilientApiController {
    
    private final ExternalServices externalServices;
    
    @GetMapping("/payment/process")
    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public String processPayment(@RequestParam(defaultValue = "100") double amount) {
        log.info("Processing payment of ${}", amount);
        String result = externalServices.callPaymentGateway();
        return String.format("✅ %s | Amount: $%.2f", result, amount);
    }
    
    public String paymentFallback(double amount, Throwable t) {
        log.warn("Payment circuit breaker tripped: {}", t.getMessage());
        return String.format("⚠️ Payment service unavailable. Amount $%.2f queued for retry.", amount);
    }
    
    @GetMapping("/data/fetch")
    @CircuitBreaker(name = "backendApi", fallbackMethod = "dataFallback")
    public String fetchData(@RequestParam(defaultValue = "user123") String userId) {
        return "✅ " + externalServices.callBackendApi() + " | User: " + userId;
    }
    
    public String dataFallback(String userId, Throwable t) {
        // Cache-aware fallback
        return "📋 Using cached data for " + userId + " (Last updated: " + LocalDateTime.now().minusHours(1) + ")";
    }
    
    @GetMapping("/user/{id}")
    @CircuitBreaker(name = "databaseService", fallbackMethod = "userFallback")
    public String getUser(@PathVariable String id) {
        return "✅ " + externalServices.queryDatabase() + " | ID: " + id;
    }
    
    public String userFallback(String id, Exception e) {
        return "👤 Default user profile for ID: " + id;
    }
    
    // Stress test endpoint
    @GetMapping("/stress-test")
    public String stressTest(@RequestParam(defaultValue = "10") int calls) {
        StringBuilder result = new StringBuilder("Stress Test Results:\n");
        for (int i = 0; i < calls; i++) {
            try {
                result.append(processPayment(50 + i)).append("\n");
            } catch (Exception e) {
                result.append("❌ Call ").append(i + 1).append(": ").append(e.getMessage()).append("\n");
            }
        }
        return result.toString();
    }
}

package com.example.controller;

import com.example.service.ExternalServices;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import io.github.resilience4j.retry.annotation.Retry;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import java.time.LocalDateTime;
import java.util.concurrent.TimeoutException;

@RestController
@RequestMapping("/api")
@RequiredArgsConstructor
@Slf4j
public class ResilientApiController {
    
    private final ExternalServices externalServices;
    
    @GetMapping("/payment/process")
    @CircuitBreaker(name = "paymentService", fallbackMethod = "paymentFallback")
    public String processPayment(@RequestParam(defaultValue = "100") double amount) {
        log.info("Processing payment of ${}", amount);
        String result = externalServices.callPaymentGateway();
        return String.format("✅ %s | Amount: $%.2f", result, amount);
    }
    
    public String paymentFallback(double amount, Throwable t) {
        log.warn("Payment circuit breaker tripped: {}", t.getMessage());
        return String.format("⚠️ Payment service unavailable. Amount $%.2f queued for retry.", amount);
    }
    
    @GetMapping("/data/fetch")
    @CircuitBreaker(name = "backendApi", fallbackMethod = "dataFallback")
    public String fetchData(@RequestParam(defaultValue = "user123") String userId) {
        return "✅ " + externalServices.callBackendApi() + " | User: " + userId;
    }
    
    public String dataFallback(String userId, Throwable t) {
        // Cache-aware fallback
        return "📋 Using cached data for " + userId + " (Last updated: " + LocalDateTime.now().minusHours(1) + ")";
    }
    
    @GetMapping("/user/{id}")
    @CircuitBreaker(name = "databaseService", fallbackMethod = "userFallback")
    public String getUser(@PathVariable String id) {
        return "✅ " + externalServices.queryDatabase() + " | ID: " + id;
    }
    
    public String userFallback(String id, Exception e) {
        return "👤 Default user profile for ID: " + id;
    }
    
    // Stress test endpoint
    @GetMapping("/stress-test")
    public String stressTest(@RequestParam(defaultValue = "10") int calls) {
        StringBuilder result = new StringBuilder("Stress Test Results:\n");
        for (int i = 0; i < calls; i++) {
            try {
                result.append(processPayment(50 + i)).append("\n");
            } catch (Exception e) {
                result.append("❌ Call ").append(i + 1).append(": ").append(e.getMessage()).append("\n");
            }
        }
        return result.toString();
    }
}

Java

Production Monitoring Setup

Expose comprehensive metrics via Actuator and Prometheus endpoints.

# Add to application.yml
management:
  endpoints:
    web:
      exposure:
        include: "*"
  metrics:
    tags:
      application: circuit-breaker-demo

# Add to application.yml
management:
  endpoints:
    web:
      exposure:
        include: "*"
  metrics:
    tags:
      application: circuit-breaker-demo

YAML

Key monitoring endpoints:

GET /actuator/health – Circuit breaker health indicators
GET /actuator/circuitbreakers – Current state of all breakers
GET /actuator/prometheus – Prometheus metrics export
GET /actuator/metrics/resilience4j.circuitbreaker.calls – Call metrics

Real-World: Service Mesh API Platform at Major Australian Bank

While working on the service mesh-based API platform at one of Australia’s big banks, Circuit Breakers were essential for the API gateway layer handling millions of daily transactions. Each backend service call (core banking, fraud detection, KYC, account aggregation) had dedicated circuit breakers configured via application.yml with bank-specific SLAs—5% failure threshold for payment APIs, 15% for reporting services. Custom event listeners streamed breaker state changes to Kafka, triggering PagerDuty alerts and dynamic routing to backup regions. This hybrid approach ensured 99.99% API uptime during the bank’s busiest periods.

Real-World: AI Chatbot APIs at Australia’s Largest Insurance Company

In my current role building APIs powering the AI chatbot for one of Australia’s biggest insurance companies, Circuit Breakers are mission-critical for maintaining chatbot responsiveness during service disruptions. The chatbot orchestrates N number downstream calls per conversation—policy lookup, claims status, premium quotes, roadside assistance, natural disaster claims—many against core systems that can potentially struggle during peak events like bushfires or floods. Each domain has tailored breakers (policyService, claimsService etc) with conservative thresholds and intelligent fallbacks that deliver partial chatbot responses e.g. “I can’t access your full policy right now, but your roadside assistance is active” instead of dead silence. The circuit breakers are augmented with daily monitoring via Splunk dashboards which show breaker states correlating perfectly with customer satisfaction metrics.

Running and Testing Locally

1. Build and Start

mvn clean install
mvn spring-boot:run
# App starts at http://localhost:8080

mvn clean install
mvn spring-boot:run
# App starts at http://localhost:8080

Bash

2. Baseline Tests (CLOSED state)

curl "http://localhost:8080/api/payment/process?amount=99.99"
curl "http://localhost:8080/api/data/fetch?userId=test123"

curl "http://localhost:8080/api/payment/process?amount=99.99"
curl "http://localhost:8080/api/data/fetch?userId=test123"

Bash

3. Trigger Circuit Breaker (OPEN state)

# Hammer payment endpoint to exceed 25% failure threshold
for i in {1..25}; do curl -s "http://localhost:8080/api/payment/process?amount=$i" & done

# Hammer payment endpoint to exceed 25% failure threshold
for i in {1..25}; do curl -s "http://localhost:8080/api/payment/process?amount=$i" & done

Bash

4. Monitor States

# Check health (shows OPEN after failures)
curl http://localhost:8080/actuator/health | jq

# Check circuit breakers directly  
curl http://localhost:8080/actuator/circuitbreakers | jq

# Prometheus metrics
curl http://localhost:8080/actuator/prometheus | grep circuitbreaker

# Check health (shows OPEN after failures)
curl http://localhost:8080/actuator/health | jq

# Check circuit breakers directly  
curl http://localhost:8080/actuator/circuitbreakers | jq

# Prometheus metrics
curl http://localhost:8080/actuator/prometheus | grep circuitbreaker

Bash

5. Observe Self-Healing

Wait 30s (paymentService waitDurationInOpenState), then test:

curl "http://localhost:8080/api/payment/process?amount=200"

curl "http://localhost:8080/api/payment/process?amount=200"

Bash

Expected flow: CLOSED → OPEN (after 25% failures) → HALF-OPEN (after 30s) → CLOSED (on success).

Advanced Production Considerations

Custom Event Listeners

@Component
public class CircuitBreakerEventHandler {
    
    @EventListener
    public void handleCircuitBreakerStateChange(CircuitBreakerEvent event) {
        if (event instanceof CircuitBreakerOnStateTransitionEvent) {
            CircuitBreakerOnStateTransitionEvent stateEvent = (CircuitBreakerOnStateTransitionEvent) event;
            log.info("Circuit {} transitioned to {} at {}", 
                stateEvent.getCircuitBreakerName(), 
                stateEvent.getStateTransition().getToState(),
                LocalDateTime.now());
            // Send to Kafka, Slack alerts, etc.
        }
    }
}

@Component
public class CircuitBreakerEventHandler {
    
    @EventListener
    public void handleCircuitBreakerStateChange(CircuitBreakerEvent event) {
        if (event instanceof CircuitBreakerOnStateTransitionEvent) {
            CircuitBreakerOnStateTransitionEvent stateEvent = (CircuitBreakerOnStateTransitionEvent) event;
            log.info("Circuit {} transitioned to {} at {}", 
                stateEvent.getCircuitBreakerName(), 
                stateEvent.getStateTransition().getToState(),
                LocalDateTime.now());
            // Send to Kafka, Slack alerts, etc.
        }
    }
}

Java

Multiple Fallback Strategies

Cache fallback: Redis/memcached data
Default data: Business-safe defaults
Async fallback: Non-blocking degraded path
Queueing: Store requests for later processing

Full Source Code Structure

textcircuit-breaker-demo/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/com/example/
│   │   │   ├── CircuitBreakerDemoApplication.java
│   │   │   ├── controller/ResilientApiController.java
│   │   │   └── service/ExternalServices.java
│   │   └── resources/
│   │       └── application.yml
│   └── test/
│       └── java/com/example/CircuitBreakerDemoApplicationTests.java
└── README.md

Complete Main Application Class:

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

package com.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Java

Quick Start Script (run.sh):

#!/bin/bash
mvn clean install -DskipTests
mvn spring-boot:run &
sleep 10
echo "=== Stress Testing Payment Service ==="
for i in {1..30}; do 
    curl -s "http://localhost:8080/api/payment/process?amount=$i" | head -1
done
echo "=== Check Circuit Breaker Status ==="
curl http://localhost:8080/actuator/circuitbreakers

#!/bin/bash
mvn clean install -DskipTests
mvn spring-boot:run &
sleep 10
echo "=== Stress Testing Payment Service ==="
for i in {1..30}; do 
    curl -s "http://localhost:8080/api/payment/process?amount=$i" | head -1
done
echo "=== Check Circuit Breaker Status ==="
curl http://localhost:8080/actuator/circuitbreakers

Bash

Wrapping Up: Build Resilient Microservices That Never Fail You

There you have it—a battle-tested, enterprise-grade Circuit Breaker implementation ready for your most demanding Spring Boot microservices. From Maven setup to production monitoring, real-world banking service mesh deployments, and daily AI chatbot resilience at Australia’s largest insurance provider, this pattern isn’t just theory—it’s the invisible shield keeping customer-facing APIs humming 24/7, even when the world throws bushfires, EOFY rushes, or legacy mainframe meltdowns at you.

But resilience is just one piece of the microservices puzzle. Want to orchestrate complex banking transactions without distributed transaction nightmares? Check my deep-dive on Implementing Saga Pattern in Spring Boot Microservices & Banking—perfect for when your Circuit Breakers need a reliable choreography partner.

Craving that single entry point for all your APIs with intelligent routing and security? My Mastering the API Gateway Pattern: Comprehensive 2025 Guide shows you how to build Kong-powered gateways that scale to millions of TPS.

Diving into polyglot persistence? Don’t miss Microservices: Database per Service with Spring Boot & MongoDB for decoupling your services with domain-specific databases.

And for Python fans tackling high-performance CRUD, How to Build a CQRS-Based CRUD API with FastAPI and MongoDB delivers separation of reads/writes at blistering speeds.

The microservices game is won through patterns that work together. Bookmark this post, grab the full source code, deploy it to your cluster today, and subscribe for weekly deep-dives on cloud-native architecture, AI integration, and Australian enterprise case studies. Your next production outage just found its kryptonite—and your systems will thank you.

What’s your biggest microservices pain point? Drop it in the comments—I’ll tackle it in the next post! 🚀

Post Views: 80

Implementing Circuit Breaker Pattern in Spring Boot 3 with Resilience4j

Published by Bhuman Soni on December 27, 2025December 27, 2025

Why Circuit Breakers Matter in Microservices

What is Resilience4j and Why It Matters

Spring Boot Circuit Breaker Resilience4

Complete Maven Setup (pom.xml)

Advanced Application Configuration

Realistic Backend Service Implementation

Feature-Rich Controller Implementation

Production Monitoring Setup

Real-World: Service Mesh API Platform at Major Australian Bank

Real-World: AI Chatbot APIs at Australia’s Largest Insurance Company

Running and Testing Locally

1. Build and Start

2. Baseline Tests (CLOSED state)

3. Trigger Circuit Breaker (OPEN state)

4. Monitor States

5. Observe Self-Healing

Advanced Production Considerations

Custom Event Listeners

Multiple Fallback Strategies

Full Source Code Structure

Wrapping Up: Build Resilient Microservices That Never Fail You

Related

0 Comments

Leave a ReplyCancel reply

Implementing Saga Pattern in Spring Boot Microservices: Banking example with Kong Gateway

Mastering the API Gateway Pattern in Microservices: A Comprehensive 2025 Guide

Building a Spring boot microservice with MongoDB: Database per service pattern explained

Implementing Circuit Breaker Pattern in Spring Boot 3 with Resilience4j

Published by Bhuman Soni on December 27, 2025December 27, 2025

Why Circuit Breakers Matter in Microservices

What is Resilience4j and Why It Matters

Spring Boot Circuit Breaker Resilience4

Complete Maven Setup (pom.xml)

Advanced Application Configuration

Realistic Backend Service Implementation

Feature-Rich Controller Implementation

Production Monitoring Setup

Real-World: Service Mesh API Platform at Major Australian Bank

Real-World: AI Chatbot APIs at Australia’s Largest Insurance Company

Running and Testing Locally

1. Build and Start

2. Baseline Tests (CLOSED state)

3. Trigger Circuit Breaker (OPEN state)

4. Monitor States

5. Observe Self-Healing

Advanced Production Considerations

Custom Event Listeners

Multiple Fallback Strategies

Full Source Code Structure

Wrapping Up: Build Resilient Microservices That Never Fail You

Related

0 Comments

Leave a ReplyCancel reply

Related Posts

Implementing Saga Pattern in Spring Boot Microservices: Banking example with Kong Gateway

Mastering the API Gateway Pattern in Microservices: A Comprehensive 2025 Guide

Building a Spring boot microservice with MongoDB: Database per service pattern explained