...
Eroare Spring Boot · Apeluri între servicii și Spring Cloud

CallNotPermittedException: CircuitBreaker 'stoc' is OPEN and does not permit further calls

Pe scurt

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

Greșit
JAVA
@CircuitBreaker(name = "stoc")
public Stoc stoc(String cod) { ... }
Corect
JAVA
@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ă

Greșit
JAVA
public Stoc stocRezerva(Throwable t) { ... }
Corect
JAVA
public Stoc stocRezerva(String cod, Throwable t) { ... }

Fallback-ul primește aceiași parametri ca metoda, plus excepția la final.

3Prag prea sensibil

Greșit
JAVA
resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=1
Corect
JAVA
resilience4j.circuitbreaker.instances.stoc.minimum-number-of-calls=10

Cu prea puține apeluri, un singur eșec întâmplător deschide circuitul.

Repară tu

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.

Codul care dă eroarea
JAVA
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);
        }
    }
}
După reparație, programul afișează
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.

Alte forme ale mesajului

  • io.github.resilience4j.circuitbreaker.CallNotPermittedException: CircuitBreaker 'stoc' is OPEN and does not permit further calls
  • CircuitBreaker 'stoc' is HALF_OPEN and does not permit further calls

Cum o eviți pe viitor

  • Pune fallbackMethod pe 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

← Toate erorile Spring Boot

Tudor Andrei Dumitrescu
Cine a explicat eroarea

Tudor Andrei Dumitrescu

Senior Software Developer · fondatorul Academiei Programatorilor

LinkedIn
  1. 2019 Junior JavaCognizant Softvision
  2. 2021 Mid JavaCognizant Softvision
  3. 2022 Team LeaderEndava
  4. 2023 Senior Software DeveloperUniCredit
  5. Acum Senior Software DeveloperHCLTech
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu
Certificat de formator autorizatMinisterul Muncii și Ministerul Educației · 2022
Certificat de absolvire Instructor / Preparator formare, Tudor Andrei Dumitrescu

Certificat de formator autorizat · Ministerul Muncii și Ministerul Educației · 2022

Din 2020 construiește Academia Programatorilor, iar din 2026 și JoburiIT.ro. Fiecare eroare de aici a fost reprodusă în editorul nostru: codul greșit chiar dă mesajul din titlu, iar reparația chiar funcționează.

Î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.