Ce este problema N+1 în Hibernate și cum poate fi…

Problema N+1 în Hibernate apare în timpul extragerii datelor, când se execută o interogare pentru a obține obiectele părinte, apoi pentru fiecare obiect copil (sau colecție de obiecte copil) se execută o interogare separată. Aceasta duce la N+1 interogări către bază, unde N este numărul de obiecte părinte, în loc de o singură interogare optimă sau câteva interogări cu join-uri.

Exemplu de scenariu cu problema N+1:

Să presupunem că avem clasele Author și Book, unde un autor poate avea mai multe cărți.

// Entitatea Author
@Entity
public class Author {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;

    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY) // fetch LAZY implicit pentru colecții
    private List<Book> books;

    // getters și setters
}

// Entitatea Book
@Entity
public class Book {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;

    @ManyToOne
    private Author author;

    // getters și setters
}

Dacă dorim să afișăm toți autorii și titlurile cărților lor:

Session session = sessionFactory.openSession();
List<Author> authors = session.createQuery("FROM Author", Author.class).list(); // 1 interogare pentru Author

for (Author author : authors) {
    System.out.println("Author: " + author.getName());
    for (Book book : author.getBooks()) { // N interogări pentru Book (una pentru fiecare autor)
        System.out.println("- Book: " + book.getTitle());
    }
}
session.close();

În acest exemplu:

Se execută o singură interogare pentru a obține toți Author.
Apoi, în buclă, pentru fiecare Author, se execută o interogare separată pentru a încărca colecția books. Dacă avem 100 de autori, vor fi executate 100 de interogări suplimentare pentru tabelul Book. Total: 1 (pentru autori) + 100 (pentru cărți) = 101 interogări.

Soluții pentru problema N+1:

Utilizarea JOIN FETCH în JPQL/HQL: Încarcă explicit entitățile legate într-o singură interogare.

Session session = sessionFactory.openSession();
List<Author> authors = session.createQuery("SELECT DISTINCT a FROM Author a JOIN FETCH a.books", Author.class).list(); // Încarcă Author și Books în o singură interogare

for (Author author : authors) {
    System.out.println("Author: " + author.getName());
    for (Book book : author.getBooks()) {
        System.out.println("- Book: " + book.getTitle());
    }
}
session.close();

Operatorul DISTINCT este folosit pentru a evita duplicarea rezultatelor în cazul join-urilor one-to-many.

Schimbarea tipului de fetch la EAGER: Modifică fetch = FetchType.LAZY (implicit) la fetch = FetchType.EAGER.
```
@Entity
public class Author {
    // ... alte câmpuri
    @OneToMany(mappedBy = "author", fetch = FetchType.EAGER) // fetch EAGER
    private List<Book> books;
    // ... getters și setters
}
```
Nu este recomandat pentru colecții sau entități cu multe relații, deoarece poate duce la încărcarea de date redundante și probleme de performanță (efectul "produs cartesian"). Potrivit pentru relații ManyToOne/OneToOne, unde se așteaptă ca obiectul legat să fie întotdeauna necesar.

Utilizarea FetchMode în Criteria API: Permite specificarea modului de încărcare a entităților legate.

Session session = sessionFactory.openSession();
Criteria criteria = session.createCriteria(Author.class)
    .setFetchMode("books", FetchMode.JOIN); // Utilizează LEFT OUTER JOIN pentru încărcarea books

List<Author> authors = criteria.list();

for (Author author : authors) {
    System.out.println("Author: " + author.getName());
    for (Book book : author.getBooks()) {
        System.out.println("- Book: " + book.getTitle());
    }
}
session.close();

Utilizarea adnotării BatchSize: Indică Hibernate să încarce obiectele legate (sau colecțiile) în grupuri de o anumită dimensiune, reducând numărul de interogări, chiar dacă nu le reduce la una singură.
```
@Entity
@BatchSize(size = 10) // Hibernate va încărca Author în loturi de 10
public class Author {
    // ... alte câmpuri
    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
    @BatchSize(size = 10) // Hibernate va încărca books pentru loturi de 10 autori
    private List<Book> books;
    // ... getters și setters
}
```
La traversarea colecției books pentru primul autor, Hibernate va încărca books și pentru următorii 9 autori (dacă au fost încărcați în aceeași sesiune). Acest lucru reduce semnificativ numărul de interogări comparativ cu N+1.

Utilizarea Entity Graphs: Permite definirea explicită a obiectelor sau colecțiilor legate care trebuie încărcate.

@NamedEntityGraph(name = "author-with-books",
    attributeNodes = @NamedAttributeNode("books")
)
@Entity
public class Author {
    // ... câmpuri și relații
}

Session session = sessionFactory.openSession();
jakarta.persistence.EntityGraph<Author> entityGraph = session.createEntityGraph(Author.class);
entityGraph.addAttributeNodes("books");

List<Author> authors = session.createQuery("SELECT a FROM Author a", Author.class)
    .setHint("jakarta.persistence.fetchgraph", entityGraph) // sau fetchgraph în funcție de comportamentul dorit
    .getResultList();

for (Author author : authors) {
    System.out.println("Author: " + author.getName());
    for (Book book : author.getBooks()) {
        System.out.println("- Book: " + book.getTitle());
    }
}
session.close();

Alegerea soluției specifice depinde de context, relațiile one-to-one/one-to-many/many-to-many, volumul de date și flexibilitatea necesară. JOIN FETCH și Entity Graphs sunt adesea preferate pentru încărcarea tuturor datelor legate într-o singură interogare, în timp ce BatchSize este eficient pentru lucrul cu un număr mare de entități și poate fi util când JOIN FETCH duce la rezultate prea mari.

Ce este problema N+1 în Hibernate și cum poate fi rezolvată?