LazyInitializationException: failed to lazily initialize a collection of role: Categorie.produse: could not initialize proxy - no Session
Ai citit o relație LAZY (de obicei o colecție @OneToMany) după ce tranzacția s-a închis, de exemplu când Jackson serializează entitatea în controller. Încarcă datele de care ai nevoie în service, într-o metodă @Transactional(readOnly = true), și întoarce un DTO (sau folosește JOIN FETCH).
Explicat de Tudor Andrei Dumitrescu, Senior Software Developer, fondatorul Academiei ProgramatorilorActualizat la
Ce înseamnă
Colecțiile @OneToMany și @ManyToMany sunt LAZY implicit: Hibernate nu le citește odată cu entitatea, ci pune în loc un proxy care le încarcă la primul acces. Încărcarea are nevoie de sesiunea (EntityManager) din care a venit entitatea. Dacă accesezi colecția după ce tranzacția s-a încheiat, sesiunea e închisă, iar Hibernate aruncă LazyInitializationException: failed to lazily initialize a collection of role: Categorie.produse: could not initialize proxy - no Session.
Partea role: Categorie.produse îți spune exact ce relație. Cel mai des se întâmplă când controllerul întoarce entitatea, iar Jackson apelează getProduse() la serializare, după ce service-ul a terminat. Cu spring.jpa.open-in-view=true (implicit, cu un avertisment la pornire), sesiunea rămâne deschisă până la final și eroarea nu apare în controller, dar apare în alte locuri: în teste, în cozi de mesaje sau când dezactivezi opțiunea.
De ce apare: cauzele frecvente
1Întorci entitatea din controller
@GetMapping("/categorii/{id}")
Categorie una(@PathVariable long id) {
return repo.findById(id).orElseThrow();
}@Transactional(readOnly = true)
public CategorieDto una(long id) {
Categorie c = repo.findById(id).orElseThrow();
return new CategorieDto(c.getNume(),
c.getProduse().stream().map(Produs::getNume).toList());
}DTO-ul se construiește cât sesiunea e deschisă; după aceea nu mai e nevoie de Hibernate.
2Accesezi colecția în afara tranzacției
Categorie c = service.gaseste(id); // fără tranzacție aici
int n = c.getProduse().size();@Query("SELECT c FROM Categorie c JOIN FETCH c.produse WHERE c.id = :id")
Optional<Categorie> cuProduse(@Param("id") long id);JOIN FETCH încarcă relația în aceeași interogare, deci nu mai rămâne nimic leneș.
3Folosești getReferenceById
Produs p = repo.getReferenceById(1L);
return p.getNume(); // în afara tranzacțieiProdus p = repo.findById(1L).orElseThrow();
return p.getNume();getReferenceById întoarce doar un proxy; câmpurile se încarcă abia la acces, cu sesiune deschisă.
Repară eroarea, direct în pagină
Controllerul întoarce entitatea Categorie, iar în aplicația reală (cu open-in-view=false) serializarea colecției produse dă LazyInitializationException. Construiește răspunsul în CategorieService, într-o metodă @Transactional(readOnly = true), ca DTO-ul CategorieDto cu numele categoriei și numele produselor.
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.*;
import jakarta.persistence.*;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Entity
class Categorie {
@Id
@GeneratedValue
private Long id;
private String nume;
@OneToMany(mappedBy = "categorie")
private List<Produs> produse = new ArrayList<>();
protected Categorie() {
}
Categorie(String nume) {
this.nume = nume;
}
public Long getId() { return id; }
public String getNume() { return nume; }
public List<Produs> getProduse() { return produse; }
}
@Entity
class Produs {
@Id
@GeneratedValue
private Long id;
private String nume;
@ManyToOne
@JsonIgnore
private Categorie categorie;
protected Produs() {
}
Produs(String nume, Categorie categorie) {
this.nume = nume;
this.categorie = categorie;
}
public Long getId() { return id; }
public String getNume() { return nume; }
public Categorie getCategorie() { return categorie; }
}
record CategorieDto(String nume, List<String> produse) { }
interface CategorieRepository extends JpaRepository<Categorie, Long> {
}
interface ProdusRepository extends JpaRepository<Produs, Long> {
}
@Service
class CategorieService {
private final CategorieRepository repo;
CategorieService(CategorieRepository repo) {
this.repo = repo;
}
public Categorie gaseste(long id) {
return repo.findById(id).orElseThrow();
}
}
@RestController
class CategorieController {
private final CategorieService service;
CategorieController(CategorieService service) {
this.service = service;
}
@GetMapping("/categorii/{id}")
Categorie una(@PathVariable long id) {
return service.gaseste(id);
}
}Tomcat started on port 8080 (http)
Started Application
GET /categorii/1 → 200
{"nume":"Periferice","produse":["Mouse","Tastatură"]}Indiciu
Mapează entitatea în CategorieDto în interiorul metodei tranzacționale, nu în controller.
Reparația
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.*;
import jakarta.persistence.*;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.*;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@Entity
class Categorie {
@Id
@GeneratedValue
private Long id;
private String nume;
@OneToMany(mappedBy = "categorie")
private List<Produs> produse = new ArrayList<>();
protected Categorie() {
}
Categorie(String nume) {
this.nume = nume;
}
public Long getId() { return id; }
public String getNume() { return nume; }
public List<Produs> getProduse() { return produse; }
}
@Entity
class Produs {
@Id
@GeneratedValue
private Long id;
private String nume;
@ManyToOne
@JsonIgnore
private Categorie categorie;
protected Produs() {
}
Produs(String nume, Categorie categorie) {
this.nume = nume;
this.categorie = categorie;
}
public Long getId() { return id; }
public String getNume() { return nume; }
public Categorie getCategorie() { return categorie; }
}
record CategorieDto(String nume, List<String> produse) { }
interface CategorieRepository extends JpaRepository<Categorie, Long> {
}
interface ProdusRepository extends JpaRepository<Produs, Long> {
}
@Service
class CategorieService {
private final CategorieRepository repo;
CategorieService(CategorieRepository repo) {
this.repo = repo;
}
@Transactional(readOnly = true)
public CategorieDto gaseste(long id) {
Categorie c = repo.findById(id).orElseThrow();
List<String> nume = c.getProduse().stream().map(p -> p.getNume()).toList();
return new CategorieDto(c.getNume(), nume);
}
}
@RestController
class CategorieController {
private final CategorieService service;
CategorieController(CategorieService service) {
this.service = service;
}
@GetMapping("/categorii/{id}")
CategorieDto una(@PathVariable long id) {
return service.gaseste(id);
}
}De ce merge
Colecția produse se încarcă leneș și are nevoie de sesiunea Hibernate. În varianta inițială, Jackson o citea în controller, după ce tranzacția se închisese. Acum service-ul parcurge colecția în metoda @Transactional(readOnly = true), cât sesiunea e deschisă, și întoarce un DTO simplu, pe care Jackson îl serializează fără să mai atingă baza. Bonus: API-ul nu mai depinde de structura entității.
Alte forme ale mesajului
org.hibernate.LazyInitializationException: could not initialize proxy [Produs#1] - no Sessionfailed to lazily initialize a collection of role: Categorie.produse, could not initialize proxy - no SessionCould not write JSON: failed to lazily initialize a collection of role: Categorie.produse: could not initialize proxy - no Session
Cum o eviți pe viitor
- Nu întoarce entități din controllere: mapează-le în DTO-uri în service, în tranzacție.
- Pune
@Transactional(readOnly = true)pe metodele de citire care parcurg relații. - Când știi că ai nevoie de o relație, încarc-o explicit:
JOIN FETCHsau@EntityGraph. - Ia în serios avertismentul despre
spring.jpa.open-in-viewși ia în calcul dezactivarea lui. - Nu schimba relațiile în
FetchType.EAGERdoar ca să scapi de eroare.
Întrebări frecvente
De ce nu pun pur și simplu FetchType.EAGER?
Pentru că atunci fiecare citire a unei categorii aduce toate produsele, chiar când nu ai nevoie de ele, iar listele devin interogări în cascadă (N+1). Problema se mută în performanță.
De ce merge în controller, dar pică într-un test?
Pentru că open-in-view ține sesiunea deschisă doar pe durata unei cereri HTTP. Un test care apelează direct service-ul nu are acea sesiune.
Laboratorul nu dă eroarea. De ce?
Simulatorul ține relațiile ca referințe Java obișnuite, fără încărcare leneșă. În proiectul real, codul din exercițiu este cel care evită eroarea.
Erori înrudite
object references an unsaved transient instance - save the transient instance before flushing: Produs.categorie -> Categorie Salvezi o entitate care trimite (printr-o relație) la alt obiect încă nesalvat, creat cu new. Hibernate nu poate scrie cheia străină pentru un rând care nu există. Salvează întâi obiectul legat (sau încarcă-l din bază), ori pune cascade pe relație dacă părintele îl deține. Transaction silently rolled back because it has been marked as rollback-only O metodă @Transactional apelată din interiorul altei tranzacții a aruncat o excepție, iar tranzacția comună a fost marcată pentru anulare. Metoda exterioară a prins excepția și a vrut să confirme, așa că Spring aruncă UnexpectedRollbackException. Nu ignora excepțiile metodelor tranzacționale interioare: întoarce un rezultat sau lasă excepția să urce. mappedBy reference an unknown target entity property: Produs.categoria in Categorie.produse Valoarea din mappedBy trebuie să fie numele câmpului care deține relația în cealaltă entitate. Ai scris un nume care nu există acolo (categoria în loc de categorie), iar Hibernate oprește pornirea. Copiază exact numele câmpului @ManyToOne din entitatea copil. Î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.
