...
Eroare Spring Boot · Relații și tranzacții

LazyInitializationException: failed to lazily initialize a collection of role: Categorie.produse: could not initialize proxy - no Session

Pe scurt

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

Greșit
JAVA
@GetMapping("/categorii/{id}")
Categorie una(@PathVariable long id) {
    return repo.findById(id).orElseThrow();
}
Corect
JAVA
@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

Greșit
JAVA
Categorie c = service.gaseste(id); // fără tranzacție aici
int n = c.getProduse().size();
Corect
JAVA
@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

Greșit
JAVA
Produs p = repo.getReferenceById(1L);
return p.getNume(); // în afara tranzacției
Corect
JAVA
Produs p = repo.findById(1L).orElseThrow();
return p.getNume();

getReferenceById întoarce doar un proxy; câmpurile se încarcă abia la acces, cu sesiune deschisă.

Repară tu

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.

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

Alte forme ale mesajului

  • org.hibernate.LazyInitializationException: could not initialize proxy [Produs#1] - no Session
  • failed to lazily initialize a collection of role: Categorie.produse, could not initialize proxy - no Session
  • Could 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 FETCH sau @EntityGraph.
  • Ia în serios avertismentul despre spring.jpa.open-in-view și ia în calcul dezactivarea lui.
  • Nu schimba relațiile în FetchType.EAGER doar 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

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