The dependencies of some of the beans in the application context form a cycle
Două sau mai multe bean-uri depind unul de altul în cerc (A cere B, B cere A), iar Spring Boot (de la 2.6) refuză dependențele circulare. Rupe cercul: mută logica comună într-o a treia clasă sau elimină dependența inutilă.
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Spring desenează cercul în mesaj:
┌─────┐
| comandaService defined in file [ComandaService.class]
↑ ↓
| clientService defined in file [ClientService.class]
└─────┘Săgețile se citesc de sus în jos: comandaService are nevoie de clientService, care are nevoie înapoi de comandaService. Cu injectare prin constructor, niciunul nu poate fi creat primul, deci Spring se oprește.
De la Spring Boot 2.6, chiar și ciclurile care tehnic s-ar putea rezolva (prin câmpuri @Autowired) sunt interzise implicit, iar Action spune Relying upon circular references is discouraged and they are prohibited by default. Un ciclu este aproape mereu un semn de design: două clase își împart o responsabilitate. Soluția bună este să extragi partea comună într-o clasă nouă, de care depind amândouă.
De ce apare: cauzele frecvente
1Două servicii se apelează reciproc
@Service class ComandaService {
ComandaService(ClientService c) { }
}
@Service class ClientService {
ClientService(ComandaService c) { }
}@Service class Reduceri { }
@Service class ComandaService {
ComandaService(Reduceri r) { }
}
@Service class ClientService {
ClientService(Reduceri r) { }
}Logica de care aveau nevoie amândouă stă acum în Reduceri. Dependențele merg într-o singură direcție, deci nu mai există cerc.
2Ciclu prin trei clase
A(B b) { }
B(C c) { }
C(A a) { }A(B b) { }
B(C c) { }
C() { } // C nu mai cere ACercul poate fi mai lung. Urmărește săgețile din desen și elimină legătura care nu își are locul.
Repară eroarea, direct în pagină
ComandaService și ClientService se cer reciproc în constructor, iar aplicația afișează The dependencies of some of the beans in the application context form a cycle. Mută calculul reducerii într-un serviciu nou ReducereService, folosit de ambele, ca GET /comenzi/total?suma=200 și GET /clienti/reducere să funcționeze.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.http.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Service
class ComandaService {
private final ClientService clienti;
ComandaService(ClientService clienti) {
this.clienti = clienti;
}
int total(int suma) {
return suma - suma * clienti.procentReducere() / 100;
}
int procentReducere() {
return 10;
}
}
@Service
class ClientService {
private final ComandaService comenzi;
ClientService(ComandaService comenzi) {
this.comenzi = comenzi;
}
int procentReducere() {
return comenzi.procentReducere();
}
}
@RestController
class MagazinController {
private final ComandaService comenzi;
private final ClientService clienti;
MagazinController(ComandaService comenzi, ClientService clienti) {
this.comenzi = comenzi;
this.clienti = clienti;
}
@GetMapping("/comenzi/total")
String total(@RequestParam int suma) {
return "Total: " + comenzi.total(suma);
}
@GetMapping("/clienti/reducere")
String reducere() {
return "Reducere: " + clienti.procentReducere() + "%";
}
}Tomcat started on port 8080 (http) Started Application GET /comenzi/total?suma=200 → 200 Total: 180 GET /clienti/reducere → 200 Reducere: 10%
Indiciu
Niciunul dintre cele două servicii nu trebuie să-l mai ceară pe celălalt; amândouă cer ReducereService.
Reparația
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
import org.springframework.stereotype.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.http.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Service
class ReducereService {
int procentReducere() {
return 10;
}
}
@Service
class ComandaService {
private final ReducereService reduceri;
ComandaService(ReducereService reduceri) {
this.reduceri = reduceri;
}
int total(int suma) {
return suma - suma * reduceri.procentReducere() / 100;
}
}
@Service
class ClientService {
private final ReducereService reduceri;
ClientService(ReducereService reduceri) {
this.reduceri = reduceri;
}
int procentReducere() {
return reduceri.procentReducere();
}
}
@RestController
class MagazinController {
private final ComandaService comenzi;
private final ClientService clienti;
MagazinController(ComandaService comenzi, ClientService clienti) {
this.comenzi = comenzi;
this.clienti = clienti;
}
@GetMapping("/comenzi/total")
String total(@RequestParam int suma) {
return "Total: " + comenzi.total(suma);
}
@GetMapping("/clienti/reducere")
String reducere() {
return "Reducere: " + clienti.procentReducere() + "%";
}
}De ce merge
Ciclul exista pentru că procentul de reducere stătea în ComandaService, deși îl folosea și ClientService. Mutat în ReducereService, el devine o dependență comună, iar săgețile merg într-o singură direcție: ambele servicii depind de ReducereService, care nu depinde de nimeni. Spring îl creează întâi, apoi celelalte două, apoi controller-ul. Rezultatul e și un cod mai clar: fiecare clasă are o singură responsabilitate.
Alte forme ale mesajului
Relying upon circular references is discouraged and they are prohibited by default.Error creating bean with name 'comandaService': Requested bean is currently in creation: Is there an unresolvable circular reference?
Cum o eviți pe viitor
- Gândește serviciile pe straturi: controllerele depind de servicii, serviciile de repository-uri, nu invers.
- Când două servicii au nevoie unul de celălalt, extrage partea comună într-o clasă separată.
- Pentru reacții de tipul „după ce se plasează comanda, actualizează clientul”, folosește evenimente (
ApplicationEventPublisher) în loc de apeluri directe. - Evită
spring.main.allow-circular-references=true: ascunde problema, nu o rezolvă.
Întrebări frecvente
Pot rezolva cu @Lazy?
@Lazy pe un parametru injectează un proxy și amână crearea, deci ciclul nu mai oprește pornirea. Este un plasture: designul rămâne încurcat. Folosește-l doar temporar.
De ce mergea înainte de Spring Boot 2.6?
Versiunile vechi permiteau implicit ciclurile cu injectare în câmpuri. De la 2.6 sunt interzise implicit, ca să fie observate devreme.
Erori înrudite
BeanCurrentlyInCreationException: Error creating bean with name 'facturaService': Requested bean is currently in creation: Is there an unresolvable circular reference? Spring a ajuns din nou la un bean pe care încă îl crea, adică există un cerc de dependențe (de obicei prin constructori sau @Autowired). Găsește cercul și rupe-l, mutând logica comună într-o clasă separată. UnsatisfiedDependencyException: Error creating bean with name 'raportController': Unsatisfied dependency expressed through constructor parameter 0 Spring nu a putut crea bean-ul din mesaj pentru că una dintre dependențele lui (parametrul indicat) nu a putut fi rezolvată. Citește cauza din finalul stivei (No qualifying bean, alt bean care nu se creează) și repar-o acolo. Parameter 0 of constructor in ComandaService required a bean of type 'StocService' that could not be found. Constructorul unui bean cere un parametru (aici primul, indexul 0) pentru care Spring nu are niciun bean de tipul respectiv. Fă clasa dependenței bean (@Service, @Component sau o metodă @Bean) sau corectează tipul parametrului. Î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.
