MyCodeSchool

Pasul 1 din 5

Spring Boot

Pasul 1 din 5 · Ce construiești

  • Spring Boot
  • Avansat
  • 15 minute

Relații în Spring Data JPA: camere cu plante

Jurnalul de plante din lecția trecută primește camere. O cameră are mai multe plante, o plantă stă într-o singură cameră. Salvezi camera, iar plantele ajung singure în tabel; scoți o plantă din listă, iar rândul ei dispare:

Consola aplicației
Hibernate: insert into camera (nume,id) values (?,default)
Hibernate: insert into planta (camera_id,nume,id) values (?,?,default)
Hibernate: insert into planta (camera_id,nume,id) values (?,?,default)
Hibernate: delete from planta where id=?
1

În baza de date, legătura e o singură coloană: camera_id din tabelul planta. În Java, ai câte o referință în ambele clase. Lecția arată cum le ții sincronizate și ce SQL pleacă atunci când citești o relație.

Pasul 2 din 5

Urmărește tabelele linie cu linie

Clasa Amenajare rulează la pornire, într-o tranzacție. Creează biroul cu două plante, îl salvează, apoi scoate cactusul. flush cere lui Hibernate să trimită acum ce are de trimis.

Amenajare.java
package ro.exemplu.camere;import org.springframework.boot.CommandLineRunner;import org.springframework.stereotype.Component;import org.springframework.transaction.annotation.Transactional;@Componentclass Amenajare implements CommandLineRunner {    private final CameraRepository camere;    Amenajare(CameraRepository camere) {        this.camere = camere;    }    @Transactional    public void run(String... args) {        Camera c = new Camera("Birou");        c.adauga(new Planta("Cactus"));        c.adauga(new Planta("Aloe"));        camere.save(c);        camere.flush();        c.scoate(c.getPlante().get(0));        camere.flush();        System.out.println(                c.getPlante().size());    }}

Tabelele și obiectul c

Consola: SQL și afișări


      

  1. Linia 17. new Camera("Birou") e doar un obiect Java. Nu are id și nu există în bază. Tabelele sunt goale.
  2. Linia 18. adauga face două lucruri: pune cactusul în lista camerei și setează camera în cactus. Ambele capete ale relației arată la fel.
  3. Linia 19. La fel pentru aloe. Încă nimic în bază: totul e în memorie.
  4. Linia 20. Salvezi doar camera. Pentru că lista are cascade = ALL, Hibernate salvează și plantele. Cu id-uri de tip IDENTITY, insert-urile pleacă imediat: baza trebuie să dea id-ul camerei înainte ca plantele să-l primească în camera_id.
  5. Linia 21. flush nu mai are nimic de trimis: totul a plecat la save.
  6. Linia 22. scoate elimină cactusul din listă și îi șterge camera. Deocamdată schimbarea e doar în memorie.
  7. Linia 23. La flush, Hibernate observă că un copil a rămas fără părinte. Cu orphanRemoval = true, rândul lui e șters.
  8. Linia 24. În listă a rămas doar aloe, deci se afișează 1.
  9. Gata. Metoda se termină, iar tranzacția se confirmă (commit).

Prezice ieșirea

Ștergi orphanRemoval = true din Camera și rulezi din nou. Ce se întâmplă cu rândul cactusului?

Răspuns: rămâne, cu camera_id gol.

scoate a pus null în câmpul camera al cactusului, iar Planta deține relația. Fără orphanRemoval, Hibernate trimite un update pe camera_id, nu un delete.

Pasul 3 din 5

Cine deține relația și când se încarcă

Patru idei, apoi două capcane. Exemplele de citire rulează pe trei camere, fiecare cu două plante.

@ManyToOne: partea cu cheia străină

Planta.java
package ro.exemplu.camere;import jakarta.persistence.*;@Entitypublic class Planta {    @Id    @GeneratedValue(            strategy = GenerationType.IDENTITY)    private Long id;    private String nume;    @ManyToOne(fetch = FetchType.LAZY)    @JoinColumn(name = "camera_id")    private Camera camera;    protected Planta() {    }    public Planta(String nume) {        this.nume = nume;    }    public String getNume() { return nume; }    public Camera getCamera() { return camera; }    void setCamera(Camera camera) {        this.camera = camera;    }}

Multe plante, o cameră: în Planta scrii @ManyToOne. Aici stă coloana camera_id, numită cu @JoinColumn. Partea cu cheia străină deține relația: Hibernate scrie camera_id doar după valoarea câmpului camera din plantă.

Setter-ul n-are public: camera se schimbă doar prin metodele din Camera, ca listele să nu se desincronizeze.

@OneToMany(mappedBy): oglinda

Camera.java
package ro.exemplu.camere;import jakarta.persistence.*;import java.util.ArrayList;import java.util.List;@Entitypublic class Camera {    @Id    @GeneratedValue(            strategy = GenerationType.IDENTITY)    private Long id;    private String nume;    @OneToMany(mappedBy = "camera",            cascade = CascadeType.ALL,            orphanRemoval = true)    private List<Planta> plante =            new ArrayList<>();    protected Camera() {    }    public Camera(String nume) {        this.nume = nume;    }    public void adauga(Planta p) {        plante.add(p);        p.setCamera(this);    }    public void scoate(Planta p) {        plante.remove(p);        p.setCamera(null);    }    public String getNume() { return nume; }    public List<Planta> getPlante() {        return plante;    }}

mappedBy = "camera" spune: „relația e deja descrisă de câmpul camera din Planta, eu doar o oglindesc”. Lista nu adaugă nicio coloană. De aceea metoda adauga setează ambele capete: dacă ai pune planta doar în listă, camera_id ar rămâne gol.

cascade = CascadeType.ALL propagă save și delete de la cameră la plante. orphanRemoval = true merge mai departe: o plantă scoasă din listă e ștearsă.

LAZY și problema N+1

Toate camerele, într-o tranzacție
for (Camera c : camere.findAll()) {    System.out.println(c.getNume() + ": "            + c.getPlante().size());}

Ce apare în consolă

Hibernate: select c1_0.id,c1_0.nume from camera c1_0
Hibernate: select p1_0.camera_id,p1_0.id,p1_0.nume from planta p1_0 where p1_0.camera_id=?
Birou: 2
Hibernate: select p1_0.camera_id,p1_0.id,p1_0.nume from planta p1_0 where p1_0.camera_id=?
Hol: 2
Hibernate: select p1_0.camera_id,p1_0.id,p1_0.nume from planta p1_0 where p1_0.camera_id=?
Dormitor: 2

O colecție @OneToMany e implicit LAZY: lista se încarcă abia când o atingi. Un select pentru camere, apoi câte unul pentru plantele fiecărei camere: 1 + N interogări. Cu 3 camere nu se simte, cu 3.000 da.

Repară cu metoda cuPlante din repository, care folosește left join fetch. Același ciclu, cu camere.cuPlante() în loc de findAll(), trimite un singur select:

Ce apare în consolă

Hibernate: select c1_0.id,c1_0.nume,p1_0.camera_id,p1_0.id,p1_0.nume from camera c1_0 left join planta p1_0 on c1_0.id=p1_0.camera_id

Atenție, @ManyToOne e implicit EAGER. De aceea în Planta am scris fetch = FetchType.LAZY: altfel, fiecare plantă citită își aduce camera, chiar dacă nu ai nevoie de ea.

Mulți la mulți: entitatea de legătură

Fertilizare.java
package ro.exemplu.camere;import jakarta.persistence.*;import java.time.LocalDate;@Entitypublic class Fertilizare {    @Id    @GeneratedValue    private Long id;    @ManyToOne(fetch = FetchType.LAZY)    private Planta planta;    @ManyToOne(fetch = FetchType.LAZY)    private Ingrasamant ingrasamant;    private LocalDate data;    private int doza;}

O plantă primește mai multe îngrășăminte, un îngrășământ ajunge la mai multe plante. @ManyToMany ar crea singur un tabel de legătură cu două coloane. Dar aproape mereu vrei să știi și când și cât.

Soluția: o entitate proprie pentru legătură, cu două @ManyToOne și coloanele ei. Hibernate creează tabelul fertilizare cu planta_id, ingrasamant_id, data și doza.

Capcană: lista citită după tranzacție

Fără tranzacție în jur, sesiunea Hibernate se închide imediat după findById. Numele e deja în obiect, dar lista de plante nu a fost încărcată:

Citire fără @Transactional
Camera c = camere.findById(1L)        .orElseThrow();System.out.println(c.getNume());System.out.println(c.getPlante().size());
Birou
Exception in thread "main" org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: ro.exemplu.camere.Camera.plante: could not initialize proxy - no Session

Repară citind lista într-o metodă cu @Transactional sau aducând-o dinainte, cu join fetch. Nu pune EAGER peste tot: muți problema în N+1.

Capcană: @OneToMany fără mappedBy

Pare suficient să pui adnotarea pe listă și @ManyToOne în plantă. Hibernate le tratează însă ca pe două relații separate:

Camera.java, fără mappedBy
@OneToManyprivate List<Planta> plante =        new ArrayList<>();
Hibernate: create table camera_plante (camera_id bigint not null, plante_id bigint not null unique)
Hibernate: create table planta (camera_id bigint, id bigint generated by default as identity, primary key (id))

Repară cu @OneToMany(mappedBy = "camera"): tabelul în plus dispare și rămâne doar planta.camera_id.

Pasul 4 din 5

Verifică-te

Cinci întrebări pe aceleași entități: trei camere, fiecare cu două plante.

1 din 5 · Prezice ieșirea

Codul rulează într-o tranzacție. Ce SQL pleacă după cele două select-uri?

Golirea holului
Camera c = camere.findById(2L)        .orElseThrow();c.getPlante().clear();

Răspuns: două delete from planta.

Ambele plante au rămas fără cameră, iar orphanRemoval = true le șterge la commit. Camera rămâne, doar goală.

2 din 5 · Alege varianta

Care parte deține relația dintre Camera și Planta?

Răspuns: Planta.

Coloana camera_id e în tabelul planta. Partea cu mappedBy e doar oglinda: modificările făcute numai pe listă nu ajung în bază.

3 din 5 · Prezice ieșirea

Rulezi ciclul cu camere.findAll() din cardul 3 pe cele trei camere. Câte select-uri apar în log?

Răspuns: 4.

Unul pentru camere, apoi câte unul pentru lista fiecărei camere: 1 + 3. Cu cuPlante() și left join fetch rămâne unul singur.

4 din 5 · Alege varianta

Primești LazyInitializationException la getPlante(). Ce reparație e cea bună?

Răspuns: @Transactional sau join fetch.

Lista are nevoie de o sesiune deschisă ca să se încarce. EAGER peste tot încarcă date de care nu ai nevoie, iar o listă goală ar ascunde plante care există.

5 din 5 · Prezice ieșirea

Dormitorul, cu id-ul 3, are două plante. Câte delete-uri trimite Hibernate?

Ștergerea dormitorului
camere.deleteById(3L);

Răspuns: 3.

Cu cascade = ALL, deleteById încarcă întâi camera și plantele ei, șterge plantele, apoi camera. Ordinea contează: rândurile din planta trimit spre cameră, deci pleacă primele.

Pasul 5 din 5

Ce ai învățat

Repository-ul cu join fetch

Singura interogare scrisă de mână din lecție. Copiaz-o, apoi încearcă o variantă care aduce doar camerele cu cel puțin o plantă, cu join fetch în loc de left join fetch.

CameraRepository.java
package ro.exemplu.camere;import java.util.List;import org.springframework.data.jpa.repository.*;public interface CameraRepository        extends JpaRepository<Camera, Long> {    @Query("""            select c from Camera c            left join fetch c.plante""")    List<Camera> cuPlante();}

Continuă cu