Circuit Breaker implementation in spring boot code

Category : Microservices | Sub Category : Microservices | By Prasad Bonam Last updated: 2023-12-02 14:57:56 Viewed : 214

In a Spring Boot application, you can implement circuit breaker patterns to improve the resilience of your system by preventing cascading failures. One popular library for implementing circuit breakers in Java applications is Netflixs Hystrix. However, as of my last knowledge update in January 2022, Netflix has officially entered maintenance mode, and its recommended to use alternatives like Resilience4j or Spring Cloud Circuit Breaker.

Here, I will show you an example of implementing a circuit breaker using Resilience4j in a Spring Boot application. First, make sure to include the necessary dependencies in your pom.xml file:

xmlCopy code
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
    <version>1.7.0</version> <!-- Check for the latest version on Maven Central -->
</dependency>

Now, lets create a simple service that may fail, and then implement a circuit breaker around it:

javaCopy code
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @CircuitBreaker(name = "myService", fallbackMethod = "fallbackMethod")
    public String performSomeOperation() {
        // Simulate a service call that may fail
        if (Math.random() < 0.7) {
            throw new RuntimeException("Service failure");
        }
        return "Operation successful";
    }

    public String fallbackMethod(Throwable t) {
        return "Fallback response: " + t.getMessage();
    }
}

In this example, MyService has a method performSomeOperation() that may throw an exception. We use the @CircuitBreaker annotation to apply a circuit breaker to this method. If the failure rate exceeds a certain threshold, the circuit breaker will open, and calls to the performSomeOperation() method will be redirected to the fallback method (fallbackMethod() in this case).

Now, lets use this service in a controller:

javaCopy code
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @Autowired
    private MyService myService;

    @GetMapping("/invoke")
    public String invokeService() {
        return myService.performSomeOperation();
    }
}

When you run your Spring Boot application and access the /invoke endpoint, it will call the performSomeOperation() method. If failures occur, the circuit breaker will open, and subsequent calls will be directed to the fallback method.

Remember to configure Resilience4j properties in your application.properties or application.yml file if you want to customize circuit breaker settings. Refer to the Resilience4j documentation for more details: https://resilience4j.readme.io/docs/circuitbreaker

In Spring Boot, you can implement circuit breakers using the Spring Cloud Circuit Breaker module. This module provides a way to add circuit breakers to your application, making it more resilient to failures in external services.

Here, I will guide you through the implementation of a circuit breaker using Spring Cloud Circuit Breaker with the Resilience4j library.

1. Add Dependencies: Include the necessary dependencies in your pom.xml file:

xmlCopy code
<dependencies>
    <!-- Other dependencies -->

    <!-- Spring Cloud Circuit Breaker with Resilience4j -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-circuitbreaker-resilience4j</artifactId>
    </dependency>
</dependencies>

2. Configure Circuit Breaker: Create a configuration class for the circuit breaker. You can customize the configuration parameters based on your requirements.

javaCopy code
import io.github.resilience4j.circuitbreaker.CircuitBreakerConfig;
import io.github.resilience4j.timelimiter.TimeLimiterConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.cloud.circuitbreaker.resilience4j.Resilience4JCircuitBreakerFactory;

@Configuration
public class CircuitBreakerConfiguration {

    @Bean
    public Resilience4JCircuitBreakerFactory resilience4JCircuitBreakerFactory() {
        Resilience4JCircuitBreakerFactory factory = new Resilience4JCircuitBreakerFactory();

        factory.configureDefault(id -> new CircuitBreakerConfig.Builder()
                .slidingWindowSize(10)
                .permittedNumberOfCallsInHalfOpenState(5)
                .failureRateThreshold(50)
                .waitDurationInOpenState(java.time.Duration.ofSeconds(5))
                .slidingWindowType(CircuitBreakerConfig.SlidingWindowType.COUNT_BASED)
                .build());

        return factory;
    }
}

In this example, the configuration sets parameters like sliding window size, permitted number of calls in half-open state, failure rate threshold, wait duration in open state, and sliding window type.

3. Use Circuit Breaker in Service: Now, you can use the circuit breaker in your service.

javaCopy code
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.circuitbreaker.resilience4j.Resilience4JCircuitBreakerFactory;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    @Autowired
    private Resilience4JCircuitBreakerFactory circuitBreakerFactory;

    public String getData() {
        return circuitBreakerFactory.create("myCircuitBreaker").run(() -> {
            // Code that may fail
            return externalService.getData();
        }, throwable -> {
            // Handle the failure
            return "Fallback Data";
        });
    }
}

In this example, the getData method is wrapped with the circuit breaker. If the external service fails, the fallback method will be invoked, providing a resilient behavior.

Note: Make sure to replace externalService.getData() with the actual code that might fail.

This is a basic example, and you can further customize the circuit breaker configuration and fallback methods based on your applications requirements.