CallNotPermittedException: CircuitBreaker 'stoc' is OPEN and does not permit further calls
Circuit breaker-ul Resilience4j a văzut prea multe apeluri eșuate către serviciu și s-a deschis: blochează apelurile pentru o perioadă și aruncă CallNotPermittedException. Este comportamentul dorit. Ce lipsește de obicei e o metodă fallback care să răspundă cât timp circuitul e deschis.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
CallNotPermittedException: CircuitBreaker 'stoc' is OPEN and does not permit further calls nu e un bug, ci protecția funcționând. Resilience4j numără rezultatele ultimelor apeluri (sliding-window-size). Când procentul de eșecuri trece de failure-rate-threshold (implicit 50%), după cel puțin minimum-number-of-calls apeluri, circuitul trece în starea OPEN. Timp de wait-duration-in-open-state, apelurile nici nu mai pleacă: eșuează imediat cu această excepție, ca serviciul căzut să nu fie bombardat și firele tale să nu aștepte timeout-uri.
Problema apare când nu ai fallbackMethod: utilizatorul vede 500 cu acest mesaj. Fallback-ul are aceeași semnătură ca metoda protejată, plus un ultim parametru Throwable (sau un tip mai specific), și întoarce o valoare de rezervă.
După perioada de așteptare, circuitul trece în HALF_OPEN, lasă câteva apeluri de probă și se închide la loc dacă reușesc.
De ce apare: cauzele frecvente
1Lipsește fallback-ul
@CircuitBreaker(name = "stoc")
public Stoc stoc(String cod) { ... }@CircuitBreaker(name = "stoc", fallbackMethod = "stocRezerva")
public Stoc stoc(String cod) { ... }
public Stoc stocRezerva(String cod, Throwable t) {
return new Stoc(cod, -1);
}Fallback-ul răspunde atât la erorile apelului, cât și când circuitul e deschis.
2Fallback cu semnătură greșită
public Stoc stocRezerva(Throwable t) { ... }public Stoc stocRezerva(String cod, Throwable t) { ... }Fallback-ul primește aceiași parametri ca metoda, plus excepția la final.
3Prag prea sensibil
resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=1resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=10Cu prea puține apeluri, un singur eșec întâmplător deschide circuitul.
Repară eroarea, direct în pagină
Serviciul de stoc e oprit. După două eșecuri, circuit breaker-ul stoc se deschide, iar a treia cerere dă 500 cu CircuitBreaker 'stoc' is OPEN. Adaugă o metodă stocRezerva(String cod, Throwable t) care întoarce new Stoc(cod, -1) și leag-o prin fallbackMethod.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.*;
import org.springframework.web.server.ResponseStatusException;
import java.util.*;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
/* StocApp.properties
spring.application.name=stoc
server.port=8081
*/
/* MagazinApp.properties
server.port=8080
server.error.include-message=always
resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=2
resilience4j.circuitbreaker.instances.stoc.sliding-window-size=2
resilience4j.circuitbreaker.instances.stoc.wait-duration-in-open-state=10s
*/
record Stoc(String cod, int bucati) { }
@SpringBootApplication
class StocApp {
public static void main(String[] args) {
SpringApplication.run(StocApp.class, args);
}
@RestController
static class StocController {
private final Map<String, Integer> stoc = Map.of("A1", 5, "B2", 0);
@GetMapping("/stoc/{cod}")
Stoc stoc(@PathVariable String cod) {
Integer n = stoc.get(cod);
if (n == null) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Cod necunoscut: " + cod);
}
return new Stoc(cod, n);
}
}
}
@SpringBootApplication
class MagazinApp {
public static void main(String[] args) {
SpringApplication.run(MagazinApp.class, args);
}
@Service
static class StocClient {
private final RestClient http = RestClient.builder().baseUrl("http://localhost:8081").build();
@CircuitBreaker(name = "stoc")
public Stoc stoc(String cod) {
return http.get().uri("/stoc/{cod}", cod).retrieve().body(Stoc.class);
}
}
@RestController
static class ProdusController {
private final StocClient stoc;
ProdusController(StocClient stoc) {
this.stoc = stoc;
}
@GetMapping("/produse/{cod}/stoc")
Stoc stoc(@PathVariable String cod) {
return stoc.stoc(cod);
}
}
}Tomcat started on port 8081 (http)
Started StocApp
Tomcat started on port 8080 (http)
Started MagazinApp
GET /produse/A1/stoc → 200
{"cod":"A1","bucati":-1}
GET /produse/A1/stoc → 200
{"cod":"A1","bucati":-1}
GET /produse/A1/stoc → 200
{"cod":"A1","bucati":-1}Indiciu
fallbackMethod = "stocRezerva" în @CircuitBreaker; metoda are parametrii lui stoc, plus Throwable la final.
Reparația
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.*;
import org.springframework.web.server.ResponseStatusException;
import java.util.*;
import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
/* StocApp.properties
spring.application.name=stoc
server.port=8081
*/
/* MagazinApp.properties
server.port=8080
server.error.include-message=always
resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=2
resilience4j.circuitbreaker.instances.stoc.sliding-window-size=2
resilience4j.circuitbreaker.instances.stoc.wait-duration-in-open-state=10s
*/
record Stoc(String cod, int bucati) { }
@SpringBootApplication
class StocApp {
public static void main(String[] args) {
SpringApplication.run(StocApp.class, args);
}
@RestController
static class StocController {
private final Map<String, Integer> stoc = Map.of("A1", 5, "B2", 0);
@GetMapping("/stoc/{cod}")
Stoc stoc(@PathVariable String cod) {
Integer n = stoc.get(cod);
if (n == null) {
throw new ResponseStatusException(HttpStatus.NOT_FOUND, "Cod necunoscut: " + cod);
}
return new Stoc(cod, n);
}
}
}
@SpringBootApplication
class MagazinApp {
public static void main(String[] args) {
SpringApplication.run(MagazinApp.class, args);
}
@Service
static class StocClient {
private final RestClient http = RestClient.builder().baseUrl("http://localhost:8081").build();
@CircuitBreaker(name = "stoc", fallbackMethod = "stocRezerva")
public Stoc stoc(String cod) {
return http.get().uri("/stoc/{cod}", cod).retrieve().body(Stoc.class);
}
public Stoc stocRezerva(String cod, Throwable t) {
return new Stoc(cod, -1);
}
}
@RestController
static class ProdusController {
private final StocClient stoc;
ProdusController(StocClient stoc) {
this.stoc = stoc;
}
@GetMapping("/produse/{cod}/stoc")
Stoc stoc(@PathVariable String cod) {
return stoc.stoc(cod);
}
}
}De ce merge
Circuitul se deschidea corect după două eșecuri, dar fără fallback fiecare cerere dădea 500, întâi cu eroarea de conexiune, apoi cu CallNotPermittedException. Acum stocRezerva răspunde în ambele situații cu bucati = -1. Cât timp circuitul e deschis, răspunsul vine imediat, fără să mai încerce conexiunea.
Alte forme ale mesajului
io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'stoc' is OPEN and does not permit further callsCircuitBreaker 'stoc' is HALF_OPEN and does not permit further calls
Cum o eviți pe viitor
- Pune
fallbackMethodpe fiecare metodă protejată de circuit breaker. - Configurează pragurile după traficul real (fereastră, prag de eșec, timp de așteptare).
- Expune starea circuitelor prin Actuator (
/actuator/circuitbreakers) și monitorizeaz-o. - Combină cu timeout-uri, ca apelurile lente să fie numărate ca eșecuri.
Întrebări frecvente
De ce nu reîncerc pur și simplu?
Reîncercările supraîncarcă un serviciu deja căzut. Circuit breaker-ul îi dă timp să-și revină și răspunde rapid între timp.
Fallback-ul se apelează și la alte erori?
Da: pentru orice excepție a metodei protejate, nu doar pentru circuitul deschis. Poți avea fallback-uri separate pentru tipuri diferite de excepții.
Erori înrudite
I/O error on GET request for "http://localhost:8081/stoc/A1": Read timed out Conexiunea la serviciul apelat s-a deschis, dar răspunsul n-a venit în timpul de citire configurat (read timeout). Serviciul e lent sau blocat. Pune un timeout rezonabil și tratează depășirea lui: răspunde 503, folosește o valoare de rezervă sau un circuit breaker. HttpServerErrorException$InternalServerError: 500 Internal Server Error: "{"status":500,"error":"Internal Server Error","path":"/stoc/A1"}" Serviciul apelat a răspuns cu o eroare 5xx, iar RestClient/RestTemplate aruncă HttpServerErrorException. Problema e în celălalt serviciu, dar neprinsă îți strică și răspunsul tău (500). Prinde excepția, răspunde cu 503 sau cu o valoare de rezervă, și investighează jurnalul serviciului apelat. I/O error on GET request for "http://localhost:8082/stoc/A1": Connection refused Clientul HTTP (RestClient, RestTemplate, Feign) nu s-a putut conecta la serviciul apelat: la adresa și portul din URL nu ascultă nimic. Serviciul e oprit, portul sau gazda sunt greșite, ori în Docker folosești localhost în loc de numele containerului. Verifică URL-ul și că serviciul rulează. Învață Spring Boot de la zero, cu exerciții la fiecare lecție
Curs Spring Boot și REST API: lecții scurte, fiecare cu un exercițiu verificat automat, direct în browser. Primele 18 lecții sunt gratuite.
