What is Circuit Breaker Design Pattern in Microservices? Spring Cloud Netflix Hystrix Example in Java?

Learn how to use Netflix Hystrix to create a circuit breaker in Java Microservices and prevent cascading failures.

In today’s world of Microservices architecture, ensuring the resilience and fault tolerance of your system is critical. One way to achieve this is through the Circuit Breaker design pattern, one of the 10 essential Microservice design pattern, which allows you to detect and recover from failures in external services.

In the past, I have shared Microservices design principles and best practices as well as explained SAGA, CQRS, Load Balancer, and API Gateway pattern in detail and in this article, I will explain what is Circuit breaker design pattern and what problem does it solve.

We’ll take a closer look at the Circuit Breaker pattern and explore how to implement it in Java using Spring Cloud Netflix Hystrix. By the end of this article, you’ll have a better understanding of how to improve the resilience of your microservices architecture using the Circuit Breaker pattern.

The Circuit Breaker pattern is a design pattern used in distributed systems to prevent cascading failures when one or more services fail. The Circuit Breaker pattern works by providing a fallback mechanism when a service fails, rather than continuing to send requests that are likely to fail.

As shown in below diagram, where you can see that when Service B is not available it falls to Fallback, which could be another instance of same service, or another service, or return a fallback response that can be returned to the client immediately

By the way, if you are new to Microservice architecture or just want to revise key Microservice concepts and looking for resources then here are few online courses you can join:

1. Master Microservices with Spring Boot and Spring Cloud [Udemy]
2. Building Scalable Java Microservices with Spring Boot [Coursera]
3. Developing Microservices with Spring Boot [Educative]
4. Master Microservices with Java, Spring, Docker, Kubernetes [Udemy]

This list includes both video and text-based courses as well as project based courses for hands-on learning, you can join one or a couple of them to revise Microservices concepts. If you need more choices, you can see the below articles:

And, if you need more choices, you can also checkout following resources:

How Does Circuit Breaker Pattern work?

The Circuit Breaker pattern operates similarly to an electrical circuit breaker. When a service fails, the Circuit Breaker trips and prevents any further requests from being sent to that service.

Instead, the Circuit Breaker provides a fallback response that can be returned to the client immediately.

This helps prevent the failure from propagating to other services and causing a cascading failure.

In addition to providing a fallback mechanism, the Circuit Breaker pattern also includes functionality to monitor the status of the service. This involves periodically sending test requests to the service to determine its status.

If the service has recovered, the Circuit Breaker can be reset, and requests can resume.

How to implement Circuit Breaker Pattern in Java?

There are many ways to implement circuit break patter in Java. For example, You can use various libraries such as Netflix Hystrix, Resilience4j, or Istio to implement circuit breaker pattern in Java.

These libraries provide configurable Circuit Breaker implementations that can be easily integrated into a microservices architecture.

Here’s an example of how to implement the Circuit Breaker pattern in Java using Spring Cloud and Netflix Hystrix:

First, you need to add the Hystrix dependency to your pom.xml:

<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-netflix-hystrix</artifactId>
</dependency>

Next, you can create a REST endpoint that calls a remote service using Hystrix:

@RestController
public class OrderController {

    @Autowired
    private OrderService OrderService;

    @GetMapping("/order-endpoint")
    public String OrderEndpoint() {
        return OrderService.remoteService();
    }

    @Component
    class OrderService {
    
        @HystrixCommand(fallbackMethod = "fallback")
        public String remoteService() {
            // Call the remote service here
            return "Success";
        }

        public String fallback() {
            return "Fallback";
        }
    }
}

In this example, OrderService calls a remote service using Hystrix's @HystrixCommand annotation. If the remote service fails, the fallback method is called instead. This is the fallback mechanism provided by the Circuit Breaker pattern.

You can configure the behavior of the Circuit Breaker using properties in the application.yml file:

hystrix:
  command:
    default:
      circuitBreaker:
        requestVolumeThreshold: 10
        errorThresholdPercentage: 50
        sleepWindowInMilliseconds: 5000

In this example, the Circuit Breaker is configured to trip if 50% or more of the requests fail, and it will remain open for 5 seconds before trying again.

That’s a basic example of how to implement the Circuit Breaker pattern in Java using Spring Cloud and Netflix Hystrix.

What are Pros and Cons of Circuit Breaker pattern?

Here are some of the pros and cons of using the Circuit Breaker pattern:

Pros:

1. Prevents cascading failures The Circuit Breaker pattern helps prevent a failure in one service from causing a cascade of failures throughout the system.
2. Improves system resilience By providing a fallback mechanism and monitoring the status of services, the Circuit Breaker pattern improves the resilience of the system.
3. Reduces load on failing services When a service fails, the Circuit Breaker pattern stops sending requests to that service, reducing the load on the service and allowing it to recover more quickly.
4. Provides fault tolerance The Circuit Breaker pattern provides a mechanism for handling faults, making the system more fault-tolerant.

Cons:

1. Adds complexity Nothing comes at free of cost. Implementing the Circuit Breaker pattern can add complexity to the system, requiring additional code and configuration.
2. May increase latency Another drawback of introducing circuit breaker pattern is increased latency. The fallback mechanism provided by the Circuit Breaker pattern may introduce additional latency into the system, especially if the fallback response is slow.
3. Requires monitoring To be effective, the Circuit Breaker pattern requires monitoring the status of services, which can be time-consuming and resource-intensive.
4. May mask underlying issues If the fallback response provided by the Circuit Breaker pattern is too generic, it may mask underlying issues with the service.

Overall, the Circuit Breaker pattern is a useful tool for improving the resilience of distributed systems, but it’s important to weigh the pros and cons before deciding whether to use it in a specific situation.

Java and Spring Interview Preparation Material

Before any Java and Spring Developer interview, I always use to read the below resources

Grokking the Java Interview

Grokking the Java Interview: click here

I have personally bought these books to speed up my preparation.

You can get your sample copy here, check the content of it and go for it

Grokking the Java Interview [Free Sample Copy]: click here

If you want to prepare for the Spring Boot interview you follow this consolidated eBook, it also contains microservice questions from spring boot interviews.

Grokking the Spring Boot Interview

You can get your copy here — Grokking the Spring Boot Interview

Conclusion

In summary, the Circuit Breaker pattern is a design pattern used to prevent cascading failures in distributed systems. It works by providing a fallback mechanism when a service fails and includes functionality to monitor the status of the service.

You can also use libraries such as Netflix Hystrix, Resilience4j, or Istio to implement circuit-breaker pattern in Java Microservices.

Microservice Learning Resources for Beginners

By the way, if you are new to Microservice architecture or just want to revise key Microservice concepts and looking for resources then here are few online courses you can join:

1. Master Microservices with Spring Boot and Spring Cloud [Udemy]
2. Building Scalable Java Microservices with Spring Boot [Coursera]
3. Developing Microservices with Spring Boot [Educative]
4. Master Microservices with Java, Spring, Docker, Kubernetes [Udemy]

This list includes both video and text-based courses as well as project based courses for hands-on learning, you can join one or a couple of them to revise Microservices concepts. If you need more choices, you can see the below articles:

And, if you need more choices, you can also checkout following resources:

Other Stories you may like