En el contexto de Spring Boot, los “circuit breakers” (interruptores de circuito) son un patrón de diseño que ayuda a prevenir el colapso de un sistema cuando hay fallas en servicios externos o dependencias. La biblioteca Resilience4j es una de las más populares para implementar este patrón en aplicaciones Java Spring Boot.
Implementación de Circuit Breaker usando Resilience4j en Spring Boot
A continuación, te mostraré cómo configurar y utilizar Resilience4j en una aplicación Spring Boot para implementar circuit breakers.
Paso 1: Añadir Dependencias
Añade las dependencias necesarias para Resilience4j en tu archivo pom.xml.
<dependencies>
<!-- Dependencia principal de Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Dependencia de Resilience4j -->
<dependency>
<groupId>io.github.resilience4j</groupId>
<artifactId>resilience4j-spring-boot2</artifactId>
<version>1.7.1</version> <!-- Verifica la última versión disponible -->
</dependency>
<!-- Dependencias adicionales -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
</dependencies>Paso 2: Configurar Resilience4j en application.yml
Configura las propiedades del circuit breaker en tu archivo application.yml.
resilience4j:
circuitbreaker:
configs:
default:
registerHealthIndicator: true
slidingWindowSize: 10
permittedNumberOfCallsInHalfOpenState: 3
minimumNumberOfCalls: 10
waitDurationInOpenState: 10s
failureRateThreshold: 50
eventConsumerBufferSize: 10
instances:
myService:
baseConfig: default
slidingWindowSize: 10
permittedNumberOfCallsInHalfOpenState: 3
minimumNumberOfCalls: 5
waitDurationInOpenState: 10s
failureRateThreshold: 50Paso 3: Anotar el Servicio con Circuit Breaker
Anota tu servicio con @CircuitBreaker para proteger métodos específicos.
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
@Service
public class MyService {
private final RestTemplate restTemplate;
public MyService(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
@CircuitBreaker(name = "myService", fallbackMethod = "fallback")
public String callExternalService() {
// Simulación de una llamada a un servicio externo
return restTemplate.getForObject("http://external-service/api/resource", String.class);
}
public String fallback(Exception ex) {
return "Fallback response: " + ex.getMessage();
}
}Paso 4: Configurar RestTemplate Bean
Configura un RestTemplate bean en tu aplicación Spring Boot.
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;
@Configuration
public class AppConfig {
@Bean
public RestTemplate restTemplate() {
return new RestTemplate();
}
}Paso 5: Exponer Endpoints para Verificar el Circuit Breaker
Puedes exponer endpoints en tu controlador para verificar el funcionamiento del circuit breaker.
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/api")
public class MyController {
private final MyService myService;
public MyController(MyService myService) {
this.myService = myService;
}
@GetMapping("/test")
public String testCircuitBreaker() {
return myService.callExternalService();
}
}Explicación
1. Dependencias: Se añaden las dependencias de Spring Boot y Resilience4j necesarias en el archivo pom.xml.
2. Configuración de application.yml: Se configura el comportamiento del circuit breaker en el archivo de configuración de Spring Boot.
3. Anotación @CircuitBreaker: Se anota el método del servicio que se desea proteger con el circuit breaker.
4. Método de Fallback: Se define un método de fallback que se invocará cuando el circuit breaker esté abierto.
5. RestTemplate: Se configura un RestTemplate bean para simular una llamada a un servicio externo.
6. Controlador: Se expone un endpoint en el controlador para probar el funcionamiento del circuit breaker.
Con estos pasos, tendrás implementado un circuit breaker en tu aplicación Spring Boot usando Resilience4j, lo que te permitirá manejar mejor las fallas en servicios externos y mejorar la resiliencia de tu aplicación.
