Vista general Aprenda a hacer resilientes las llamadas de microservicio utilizando el patrón de interruptor de circuitos con y — demostraciones completas, comandos paso a paso, explicaciones clase por clase, resultados de muestras, casos de uso en el mundo real y consejos de producción. Resilience4j Spring Boot Why This Matters ¿Por qué esto importa En los sistemas distribuidos, un servicio descendente fallido puede cascarse y causar interrupciones generales del sistema. El patrón: Circuit Breaker 
 
 
 
 
 detecta una dependencia fallida, Deja de enviar solicitudes a ella (para evitar desperdiciar recursos), Devuelve una graciosa respuesta de retroceso, Periódicamente prueba la adicción y restaura el funcionamiento normal cuando está sano. Esto reduce los tiempos de inactividad, protege los grupos de thread, mantiene la experiencia del usuario razonable y previene tormentas de retry. Demo Summary (What You Have) Demo Summary (Lo que tienes) Una demo de Maven de dos servicios: 
 
 
 
  (port  ) — simple REST provider that intentionally fails intermittently. hello-service 8081 punto final GET /api/hello
 
 
 
 
  (port  ) — calls hello-service using RestTemplate and is protected by   with a fallback. client-service 8080 Resilience4j @CircuitBreaker punto final GET /api/get-message
 En ambos casos ( ) hello-service and client-service Entonces el test GET http://localhost:8080/api/get-message
 Arquitectura Diagrama Este es un flujo pequeño y enfocado adecuado para dibujar un diagrama Files & Code: Class-By-Class Explanation Archivos y Código: Clase por Clase Explicación hello-service HolaServiceApplication.java 
 
 
 
 Standard   bootstrap class. @SpringBootApplication HelloController.java

@RestController
public class HelloController {

    private static int counter = 0;

    @GetMapping("/api/hello")
    public String sayHello() {
        counter++;
        // simulate intermittent failure: fail on every 3rd request
        if (counter % 3 == 0) {
            throw new RuntimeException("Simulated failure from Hello-Service!");
        }
        return "Hello from Hello-Service! (count=" + counter + ")";
    }
}
 Este controlador intencionalmente lanza un RuntimeException en llamadas periódicas para simular fallas transitorias que verías en sistemas reales (desactivación de DB, datos malos, temporadas). Explanation: client-service Servicio de atención al clienteApplication.java 
 
 Clase principal de inicio de primavera estándar. No se requiere configuración especial. AppConfig.java
@Configuration
public class AppConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}
 Proporciona un único bean de RestTemplate. Asegúrese de que RestTemplate sea un bean de primavera para que los proxies de AOP/resiliencia puedan funcionar correctamente. Explanation: HelloClientService.java
@Service
public class HelloClientService {

    private final RestTemplate restTemplate;

    @Value("${hello.service.url}")
    private String helloServiceUrl;

    public HelloClientService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @CircuitBreaker(name = "helloService", fallbackMethod = "fallbackHello")
    public String getHelloMessage() {
        System.out.println("Calling hello service: " + helloServiceUrl);
        return restTemplate.getForObject(helloServiceUrl, String.class);
    }

    public String fallbackHello(Throwable t) {
        System.out.println("Fallback triggered: " + t);
        return "Hello Service is currently unavailable. Please try again later.";
    }
}
 Explanation (crucial bits) 
 
 
 
 
 
 @CircuitBreaker(name = "helloService", fallbackMethod = "fallbackHello") wraps the getHelloMessage() call in a circuit breaker. The name links to configuration properties. 
 
 
 
 fallbackHello(Throwable t) is called when the call fails according to the breaker rules. The fallback must:     o    Be in the same class

    o    Have the same return type

    o   Accept the original method parameters (none here) and a final Throwable parameter (or Exception/Throwable compatible with thrown exceptions)
 
 
 Important: The method must be public, and the class must be a Spring bean (@Service), so proxy-based AOP works. ClientController.java
@RestController
public class ClientController {

    private final HelloClientService helloClientService;

    public ClientController(HelloClientService helloClientService) {
        this.helloClientService = helloClientService;
    }

    @GetMapping("/api/get-message")
    public String getMessage() {
        return helloClientService.getHelloMessage();
    }
}
 Controlador simple delegando a Esto asegura que la llamada pasa a través del proxy donde se aplica el interruptor de circuito. Explanation: HelloClientService Configuration Used (client-service application.properties) Configuración usada (aplicación de servicio al cliente.properties) Configuración clave utilizada en la demo server.port=8080
spring.application.name=client-service

hello.service.url=http://localhost:8081/api/hello

resilience4j.circuitbreaker.instances.helloService.registerHealthIndicator=true
resilience4j.circuitbreaker.instances.helloService.slidingWindowSize=5
resilience4j.circuitbreaker.instances.helloService.minimumNumberOfCalls=2
resilience4j.circuitbreaker.instances.helloService.failureRateThreshold=50
resilience4j.circuitbreaker.instances.helloService.waitDurationInOpenState=10s

logging.level.io.github.resilience4j.circuitbreaker=DEBUG
 Meaning of important properties 
 
 
 
 
 
 SlidingWindowSize: Número de llamadas que monitora el interruptor para el porcentaje de fallos. mínimoNumberOfCalls: llamadas mínimas antes de que se evalúe la tasa de fracaso. errorRateThreshold: porcentaje de fallos (por ejemplo, 50) para abrir el circuito. waitDurationInOpenState: cuánto tiempo permanece abierto el circuito antes de moverse a medio abierto. registroHealthIndicator: expone el estado del interruptor a través del actuador. Paso a paso y resultados esperados Inicio Servicios 
 
 Comienza el servicio de salud Visit: http://localhost:8081/api/hello
 “Hello from Hello-Service!” (o lanza un error simulado) Returns 
 
 Inicio Servicio Cliente Visit: http://localhost:8080/api/get-message
 Test Scenarios & Outputs Escenarios y resultados de prueba Scenario A — Hello-Service Healthy Haga una solicitud GET http://localhost:8080/api/get-message
 Los clientes logran Calling hello service: http://localhost:8081/api/hello
2025-11-13T11:58:23.366+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-8] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' succeeded:
2025-11-13T11:58:23.366+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-8] i.g.r.c.i.CircuitBreakerStateMachine : Event SUCCESS published: 2025-11-13T11:58:23.366634+05:30[Asia/Calcutta]: CircuitBreaker 'helloService' recorded a successful call. Elapsed time: 15 ms
 Response Hello from Hello-Service! (count=4)
 Scenario B — Hello-Service Intermittent Failures Si llamas repetidamente y el servicio de salud se lanza En algunas peticiones: RuntimeException ● Llamadas exitosas: el cliente devuelve el mensaje de salud. Cuando una llamada a continuación devuelve HTTP 500/excepción:             o    Resilience4j records the failure.

            o    If failure rate exceeds threshold (e.g., 50% over sliding window), the Circuit becomes **OPEN**.

            o    While OPEN, calls are short-circuited; **fallbackHello**() is immediately executed — no network call. \n                       **Client response while fallback active**
 Client Response while active Response Hello Service is currently unavailable. Please try again later.
 Sample client log sequence Calling hello service: http://localhost:8081/api/hello
2025-11-13T12:00:55.842+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' recorded an exception as failure:
 Scenario C — Recovery Después   Duración de la espera (en los 10s) Duración de la espera 
 
 
 
 Circuito pasa a HALF_OPEN: se permiten algunas llamadas de prueba. Si las llamadas de prueba son exitosas, el interruptor se cierra y el tráfico normal se reanuda. Si las pruebas fallan, el interruptor vuelve a abrir. Real-World Use Cases Casos de uso del mundo real 
 
 
 
 
 Integración de pagos - Un servicio de checkout llamando una API de banco externo: si la API del banco se vuelve lenta / falla, el interruptor de circuito devuelve un mensaje amigable al usuario y previene tormentas de retiro. API de terceros limitados por la tasa - API con llamadas limitadas por segundo - cuando se alcanzan los límites, el circuito se abre para evitar golpear más las cuotas; fallback devuelve datos en caché. Cadenas de microservicios dentro de una empresa - Servicio A llama a B, que llama a C. Si C es inestable, los interruptores abiertos protegen a B y A, evitando una desaceleración en todo el sistema. Desviaciones de características y degradación graciosa: Cuando un servicio de características no críticas falla, devuelva un resultado más simple para mantener la funcionalidad principal disponible (por ejemplo, devuelve la lista de productos sin recomendaciones). Advantages & Business Value Ventajas y Valor Empresarial 
 
 
 
 
 
 
 Aislamiento de defectos: evita que una mala dependencia se desintegre. Respuesta de fracaso más rápida: fracaso rápido en lugar de esperar a los horarios. Degradación graciosa: ofrece respuestas de retroceso en lugar de interrupciones completas. Protección de recursos: evita el desperdicio de CPU, filamentos y red. Recuperación automática: vuelve automáticamente a la normalidad cuando la adicción es saludable. Observabilidad: los estados y las métricas del interruptor pueden ser expuestos a través del actuador y monitorizados. Sample logs you’ll see (realistic) Calling hello service: http://localhost:8081/api/hello
2025-11-13T12:00:55.842+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : CircuitBreaker 'helloService' recorded an exception as failure
2025-11-13T12:00:55.847+05:30 DEBUG 32692 --- [client-service] [nio-8080-exec-1] i.g.r.c.i.CircuitBreakerStateMachine : Event ERROR published: 2025-11-13T12:00:55.847908200+05:30[Asia/Calcutta]: CircuitBreaker 'helloService' recorded an error: 'org.springframework.web.client.HttpServerErrorException$InternalServerError: 500 : "{"timestamp":"2025-11-13T06:30:55.842+00:00","status":500,"error":"Internal Server Error","path":"/api/hello"}"'. Elapsed time: 8 ms
Fallback triggered: org.springframework.web.client.HttpServerErrorException$InternalServerError: 500 : "{"timestamp":"2025-11-13T06:30:55.842+00:00","status":500,"error":"Internal Server Error","path":"/api/hello"}"


Read My Stories

Este audio es producido en el idioma original de la historia!

Cómo construir APIs resilientes con Resilience4j Circuit Breaker en Spring Boot

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

Telegram: el puente de Crypto Island hacia el continente

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

Telegram: el puente de Crypto Island hacia el continente

Navegando por las aguas: desarrollo de aplicaciones RAG de nivel de producción con lagos de datos

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

Light-Mode

Classic

Newspaper

Minty

Dark-Mode

Neon Noir

Minty

HN StartUps