Clean • Professional
In a distributed microservices architecture, failures are normal and unavoidable.
Services communicate over networks, and networks can fail:
👉 Resilience4j protects microservices from cascading failures and keeps the system stable, responsive, and reliable.
Resilience4j is a lightweight fault-tolerance and resilience library for Java and Spring Boot microservices.
It provides ready-to-use resilience patterns to:
Designed specifically for microservices and cloud-native applications
Modern replacement for Hystrix (deprecated)
Service A → Service B (slow/down)
↓
Threads keep waiting
↓
Thread exhaustion
↓
Service A crashes
↓
System-wide failure
Problems:
Service A
↓
Resilience Layer
↓
Service B
Benefits:
Resilience4j provides five major fault-tolerance patterns, each solving a specific real-world problem:
Repeatedly calling a slow or failing service wastes resources and causes cascading failures.
A CircuitBreaker temporarily stops calling a failing service.
It works like an electrical circuit breaker — when failure exceeds a limit, the circuit opens.
CircuitBreaker States
CLOSED → OPEN → HALF-OPEN
Service A
↓
CircuitBreaker
↓
Service B (Failing)
If failure threshold exceeded → Circuit opens
Example:
@RestController
public class OrderController {
@Autowired
private PaymentService paymentService;
@GetMapping("/pay/{orderId}")
@CircuitBreaker(name = "paymentService", fallbackMethod = "fallbackPayment")
public String makePayment(@PathVariable String orderId) {
return paymentService.processPayment(orderId);
}
public String fallbackPayment(String orderId, Throwable t) {
return "Payment Service unavailable for order " + orderId + ". Try again later!";
}
}YAML Configuration (application.yml):
resilience4j:
circuitbreaker:
instances:
paymentService:
registerHealthIndicator: true
slidingWindowSize: 5
failureRateThreshold: 50
waitDurationInOpenState: 5sTemporary issues such as:
Retry automatically re-attempts a failed request before giving up.
Request
↓
Failure
↓
Retry (1…N times)
↓
Success or Fallback
Example:
@RestController
public class InventoryController {
@Autowired
private InventoryService inventoryService;
@GetMapping("/check/{itemId}")
@Retry(name = "inventoryService", fallbackMethod = "fallbackInventory")
public String checkInventory(@PathVariable String itemId) {
return inventoryService.getStock(itemId);
}
public String fallbackInventory(String itemId, Throwable t) {
return "Inventory Service is busy for item " + itemId + ". Please try again.";
}
}YAML Configuration (application.yml):
resilience4j:
retry:
instances:
inventoryService:
maxAttempts: 3
waitDuration: 2sToo many requests can:
RateLimiter restricts how many requests are allowed in a given time window.
Client Requests
↓
RateLimiter
↓
Service
Excess requests → Rejected or delayed
Example:
@GetMapping("/public-data")
@RateLimiter(name = "publicApi", fallbackMethod = "rateLimitFallback")
public String getData() {
return "Public API Data";
}
public String rateLimitFallback(Throwable t) {
return "Too many requests! Try again later.";
}YAML Configuration:
resilience4j:
ratelimiter:
instances:
publicApi:
limitForPeriod: 5
limitRefreshPeriod: 1sOne slow dependency can block all threads and crash the service.
Bulkhead isolates resources so failure in one area does not affect others.
Inspired by ship compartments.
Service A
├── Thread Pool (Service B)
└── Thread Pool (Service C)
Failure in B → C still works
Example:
@Bulkhead(name = "paymentService", type = Bulkhead.Type.SEMAPHORE)
public String processPayment(Order order) {
// Payment processing logic
}Slow responses consume threads and reduce throughput.
TimeLimiter sets a maximum execution time for a request.
If the timeout is exceeded → request fails fast.
Request
↓
TimeLimiter (Timeout)
↓
Success or Timeout Exception
Example:
@TimeLimiter(name = "supplierService", fallbackMethod = "fallbackSupplier")
public CompletableFuture<String> fetchSupplierData(String itemId) {
return CompletableFuture.supplyAsync(() -> supplierApi.getStock(itemId));
}
public CompletableFuture<String> fallbackSupplier(String itemId, Throwable t) {
return CompletableFuture.completedFuture("Supplier Service timeout for " + itemId);
}Most production systems use multiple patterns together.
Common Flow
Client
↓
API Gateway (RateLimiter)
↓
Retry
↓
CircuitBreaker
↓
Bulkhead
↓
TimeLimiter
↓
Remote Service
Resilience4j integrates seamlessly with Spring Boot using:
Supports:
In an e-commerce application, multiple microservices work together to complete a single user request. If one service fails, it should not bring down the entire system.
Resilience4j ensures fault isolation, graceful degradation, and system stability.
Order Processing – CircuitBreaker + Retry
When a customer places an order, the Order Service must call the Payment Service.
Payment systems can fail due to:
Order Service
↓
CircuitBreaker + Retry
↓
Payment Service
API Gateway – Rate Limiting
During sales events (Flash Sale, Black Friday), traffic spikes suddenly.
Uncontrolled traffic can:
Client
↓
RateLimiter
↓
Microservices
Inventory Service – Bulkhead Isolation
Inventory Service depends on:
If one dependency becomes slow, the entire service should not fail.
Inventory Service
├── Bulkhead (Database)
└── Bulkhead (External API)
Both Hystrix and Resilience4j are libraries designed to make microservices fault-tolerant, but today Resilience4j is the clear and recommended choice.
| Feature | Hystrix | Resilience4j |
|---|---|---|
| Project Status | Deprecated | Actively maintained |
| Architecture | Heavy, thread-based | Lightweight, modular |
| Java Support | Limited (pre–Java 8 design) | Full Java 8+ support |
| Programming Style | Imperative | Functional & declarative |
| Spring Boot Integration | Limited & legacy | Native and seamless |
| Reactive Support | Limited | Full reactive support |
| Modularity | Monolithic | Use only what you need |
| Future Readiness | No longer evolving | Cloud-native & modern |
Resilience4j is a must-have for real-world microservices.
When combined with:
👉 It creates a stable, scalable, and production-ready microservices architecture.