🗃️ JPA Q4 / 63

How can you fetch a LAZY association as EAGER in a NamedQuery?

AI-Powered Answer ✓ Answered

JPA associations, by default, can be fetched either lazily or eagerly. While lazy fetching is often preferred for performance, there are specific scenarios where an association defined as LAZY needs to be eagerly loaded within the context of a particular query. This guide explains how to achieve this using fetch joins in NamedQueries.

Understanding JPA Fetching Strategies

JPA provides two primary fetching strategies: LAZY and EAGER. LAZY fetching means associated entities are loaded only when they are first accessed, while EAGER fetching loads them immediately along with the principal entity. By default, @OneToMany and @ManyToMany associations are LAZY, and @ManyToOne and @OneToOne are EAGER.

The Need to Override LAZY Fetching

Sometimes, for a specific use case, you might need to access a LAZY association immediately after retrieving the main entity, but without incurring additional database queries (the N+1 problem). Directly accessing a LAZY association outside an active transaction (or session) can lead to a LazyInitializationException. Fetch joins provide a way to load these associations eagerly for a particular query.

Solution: Using Fetch Joins in NamedQueries

The most effective way to fetch a LAZY association as EAGER in a NamedQuery is to use FETCH JOIN. A fetch join allows you to retrieve related entities along with the root entity in a single query, preventing the N+1 problem and ensuring the association is initialized.

Example Entity Setup

java

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String orderNumber;

    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private Set<LineItem> lineItems = new HashSet<>();

    // Getters and Setters for id, orderNumber, lineItems
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getOrderNumber() { return orderNumber; }
    public void setOrderNumber(String orderNumber) { this.orderNumber = orderNumber; }
    public Set<LineItem> getLineItems() { return lineItems; }
    public void setLineItems(Set<LineItem> lineItems) { this.lineItems = lineItems; }
}

java

import javax.persistence.*;

@Entity
public class LineItem {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String productCode;
    private int quantity;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "order_id")
    private Order order;

    // Getters and Setters for id, productCode, quantity, order
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getProductCode() { return productCode; }
    public void setProductCode(String productCode) { this.productCode = productCode; }
    public int getQuantity() { return quantity; }
    public void setQuantity(int quantity) { this.quantity = quantity; }
    public Order getOrder() { return order; }
    public void setOrder(Order order) { this.order = order; }
}

Defining the NamedQuery with FETCH JOIN

You define the NamedQuery using the @NamedQuery annotation on the entity class. The query itself will use LEFT JOIN FETCH or INNER JOIN FETCH to include the desired lazy association.

java

import javax.persistence.*;
import java.util.HashSet;
import java.util.Set;

@Entity
@NamedQuery(
    name = "Order.findAllWithLineItems",
    query = "SELECT o FROM Order o LEFT JOIN FETCH o.lineItems WHERE o.id = :orderId"
)
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String orderNumber;

    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY)
    private Set<LineItem> lineItems = new HashSet<>();

    // ... (rest of Getters and Setters omitted for brevity) ...
}

Executing the NamedQuery

Once defined, you can execute the NamedQuery using an EntityManager instance.

java

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.TypedQuery;

public class OrderService {

    public Order getOrderWithLineItems(Long orderId) {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("your-persistence-unit");
        EntityManager em = emf.createEntityManager();
        Order order = null;
        try {
            TypedQuery<Order> query = em.createNamedQuery("Order.findAllWithLineItems", Order.class);
            query.setParameter("orderId", orderId);
            order = query.getSingleResult();

            // Now, order.getLineItems() will be initialized without an extra query
            // and can be accessed even after the EntityManager is closed or outside a transaction.
            System.out.println("Order: " + order.getOrderNumber());
            order.getLineItems().forEach(item -> System.out.println("  Line Item: " + item.getProductCode() + ", Qty: " + item.getQuantity()));

        } finally {
            em.close();
            emf.close();
        }
        return order;
    }
}

Important Considerations

Avoid the N+1 problem: Fetch joins are crucial for performance by loading all necessary data in a single database roundtrip.
Potential for Cartesian product: If you fetch multiple ToMany associations without using DISTINCT in the JPQL, you might get duplicate parent entities in the result set. SELECT DISTINCT o FROM Order o LEFT JOIN FETCH o.lineItems can help, but it might not solve all scenarios, especially with multiple ToMany fetches.
Performance impact: While solving N+1, eagerly fetching too much data for every query can lead to performance degradation due to larger result sets and memory consumption. Use fetch joins judiciously.
Multiple ToMany fetches: JPA implementations generally don't allow multiple ToMany fetch joins in a single query to avoid a massive Cartesian product that can't be easily flattened back into objects without duplicates or errors (e.g., MultipleBagFetchException in Hibernate). You might need separate queries or entity graphs for such scenarios.
Query scope: Fetch joins only apply to the specific query they are used in. The default fetch type defined in the entity mapping remains unchanged for other queries.

← All JPA questions