Vorbește despre problema N+1 în Hibernate.

Problema N+1 apare în timpul încărcării eager a entităților legate. În loc să execute o singură interogare pentru a obține entitatea principală și relațiile sale, Hibernate execută o interogare pentru entitatea principală și N interogări suplimentare pentru fiecare dintre cele N entități legate, unde N este numărul entităților principale. Acest lucru duce la o încetinire semnificativă a aplicației și la creșterea încărcării bazei de date.

Exemplu:

// Entitatea principală
@Entity
public class Order {

    @OneToMany(fetch = FetchType.EAGER, mappedBy = "order")
    private List<OrderItem> orderItems;

    // ...
}

// Obținerea listei de comenzi
List<Order> orders = entityManager.createQuery("SELECT o FROM Order o").getResultList();

// Pentru fiecare comandă, se va executa o interogare separată pentru a obține OrderItem
for (Order order : orders) {
    order.getOrderItems().size(); // Inițiază N interogări suplimentare către BD
}

Soluții pentru problemă:

Lazy Loading: Utilizarea FetchType.LAZY (implicit pentru colecții și OneToMany/ManyToMany). Entitățile legate sunt încărcate doar la acces.
```
@OneToMany(fetch = FetchType.LAZY, mappedBy = "order")
private List<OrderItem> orderItems;
```
Această abordare poate duce la problema "LazyInitializationException" dacă se încearcă accesarea datelor încărcate lazy în afara unei sesiuni Hibernate active.
Join Fetch: Specificarea explicită a Hibernate să încarce entitățile legate într-o singură interogare folosind JOIN FETCH.
```
List<Order> orders = entityManager.createQuery("SELECT o FROM Order o JOIN FETCH o.orderItems").getResultList();
```
Join Fetch evită problema N+1, dar poate duce la duplicare în rezultat dacă entitatea principală are multe elemente legate.
Batch Fetching: Optimizarea încărcării entităților legate în grupuri (BatchSize). Hibernate va încărca entitățile legate pentru mai multe entități principale într-o singură interogare.
```
@OneToMany(mappedBy = "order")
@BatchSize(size = 10) // Încarcă OrderItem pentru 10 comenzi simultan
private List<OrderItem> orderItems;
```
Subselect Fetching: Încărcarea entităților legate într-o interogare separată, folosind identificatorii entităților principale în clauze IN.
```
@OneToMany(mappedBy = "order")
@Fetch(FetchMode.SUBSELECT)
private List<OrderItem> orderItems;
```
Poate fi mai puțin eficient pentru un număr mare de entități principale.

Entity Graphs: Mecanism în JPA 2.1 pentru definirea unui graf de entități care trebuie încărcat. Permite controlul explicit asupra relațiilor care trebuie încărcate.

// Definirea unui Entity Graph
@NamedEntityGraph(name = "order-with-items", attributeNodes = @NamedAttributeNode("orderItems"))
@Entity
public class Order { ... }

// Utilizarea Entity Graph în interogare
Map<String, Object> hints = new HashMap<>();
hints.put("javax.persistence.fetchgraph", entityManager.getEntityGraph("order-with-items"));
List<Order> orders = entityManager.createQuery("SELECT o FROM Order o").setHint("javax.persistence.fetchgraph", entityManager.getEntityGraph("order-with-items")).getResultList();