Resolving Hibernate MultipleBagFetchException: Best Practices for Multiple @OneToMany Relationships

The Hibernate MultipleBagFetchException occurs when you attempt to fetch multiple @OneToMany collections with FetchType.EAGER, causing Hibernate to generate a Cartesian product in SQL. To resolve this, you can use Set instead of List for collections, implement query splitting, or leverage lazy loading strategies with @LazyCollection(FALSE) instead of FetchType.EAGER for better performance and control over data fetching.

Contents

• Understanding Hibernate MultipleBagFetchException
• Why Multiple @OneToMany Collections with FetchType.EAGER Cause Problems
• Solution 1: Using Set Instead of List
• Solution 2: Query Splitting for Multiple Collections
• Solution 3: Lazy Loading Strategies
• Advanced Techniques: EntityGraph and Batch Fetching
• Best Practices for Multiple @OneToMany Relationships
• Conclusion

Understanding Hibernate MultipleBagFetchException

When working with Hibernate in Java applications, the MultipleBagFetchException is a common runtime exception that occurs when you attempt to fetch multiple @OneToMany collections with FetchType.EAGER loading. This error specifically targets collections that Hibernate considers “bags” - typically Lists without an order column - and prevents simultaneous eager fetching of multiple such collections. The exception message typically indicates “cannot simultaneously fetch multiple bags” and occurs because Hibernate would generate SQL with Cartesian products that could potentially return thousands or millions of rows, causing performance issues and excessive memory consumption.

From Vlad Mihalcea’s blog, we understand that Hibernate treats List collections as bags unless they have an @OrderColumn annotation. When you have multiple @OneToMany relationships marked with FetchType.EAGER, Hibernate struggles to generate an efficient SQL query that fetches all the associated collections without creating a Cartesian product. This is why Hibernate throws the MultipleBagFetchException as a protective measure against potentially catastrophic query results.

Why Multiple @OneToMany Collections with FetchType.EAGER Cause Problems

The root cause of the MultipleBagFetchException lies in how Hibernate generates SQL queries for collections and how it handles multiple eager-loaded relationships. When you have multiple @OneToMany collections with FetchType.EAGER, Hibernate needs to fetch all entities and their associated collections in a single query to avoid the N+1 query problem. However, when dealing with List collections (which Hibernate treats as bags), this creates a mathematical problem.

According to Thorben Janssen’s Hibernate tips, the issue is that Hibernate would need to generate a join that creates a Cartesian product between all the collections. For example, if you have a Parent entity with two List children and three grandchildren, the query would generate 3 × 3 = 9 rows for each parent entity instead of the expected 3 + 3 = 6 rows. This exponential growth makes queries inefficient and potentially disastrous for performance.

Hibernate’s solution is to throw the MultipleBagFetchException rather than risk generating a query that could consume excessive memory and processing time. This is actually a protective feature that forces developers to think about their data access patterns and choose more efficient approaches.

Solution 1: Using Set Instead of List

One of the most straightforward solutions to the MultipleBagFetchException is to replace List collections with Set collections in your entity mappings. Sets naturally avoid duplicates and don’t have the ordering issue that causes Hibernate to treat Lists as bags.

Here’s how you can modify your entity:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
 private Set<Child> children = new HashSet<>();
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
 private Set<Grandchild> grandchildren = new HashSet<>();
 
 // Getters and setters
}

However, as Thorben Janssen points out, this is not a silver bullet. While Sets avoid the MultipleBagFetchException for two collections, they still cause performance issues when you have multiple collections. The SQL join still creates a Cartesian product, just without the duplicate entries that Lists would produce.

For example, if you have 10 children and 5 grandchildren, the join would still create 10 × 5 = 50 rows instead of 10 + 5 = 15 rows. This can still lead to excessive memory usage and processing time, especially with large datasets.

Solution 2: Query Splitting for Multiple Collections

A more robust solution is to implement query splitting, where you fetch the main entity and its collections in separate queries. This approach avoids the Cartesian product issue while still maintaining control over when and how data is loaded.

Here’s how you can implement query splitting:

@Repository
public class ParentRepository {
 
 @PersistenceContext
 private EntityManager entityManager;
 
 public Parent findByIdWithChildren(Long id) {
 Parent parent = entityManager.find(Parent.class, id);
 if (parent != null) {
 // Force initialization of children collection
 parent.getChildren().size();
 }
 return parent;
 }
 
 public Parent findByIdWithGrandchildren(Long id) {
 Parent parent = entityManager.find(Parent.class, id);
 if (parent != null) {
 // Force initialization of grandchildren collection
 parent.getGrandchildren().size();
 }
 return parent;
 }
}

You can also use a combination of eager fetching for one collection and lazy loading for others, then initialize the lazy collections when needed:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
 private List<Child> children = new ArrayList<>();
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 private List<Grandchild> grandchildren = new ArrayList<>();
 
 // Getters and setters
}

// In your service
public Parent getParentWithAllCollections(Long id) {
 Parent parent = parentRepository.findById(id);
 if (parent != null) {
 // Initialize lazy collection
 Hibernate.initialize(parent.getGrandchildren());
 }
 return parent;
}

Query splitting gives you more control over your data access patterns and avoids the Cartesian product issue entirely. However, it does require more code and careful management of when collections are initialized.

Solution 3: Lazy Loading Strategies

Lazy loading is often the most efficient approach for handling multiple collections in Hibernate. Instead of loading all collections eagerly when the parent entity is loaded, you load them only when they’re actually accessed.

The key question is when to use @LazyCollection(LazyCollectionOption.FALSE) versus FetchType.EAGER. As Thorben Janssen explains, there’s an important distinction:

1. FetchType.LAZY (default): The collection is loaded only when it’s accessed for the first time.
2. FetchType.EAGER: The collection is loaded when the parent entity is loaded.
3. @LazyCollection(FALSE): This is equivalent to FetchType.EAGER and will cause the same issues with multiple collections.
4. @LazyCollection(TRUE): This is the default behavior and equivalent to FetchType.LAZY.

When dealing with multiple collections, FetchType.LAZY should be your default choice. You can then selectively initialize collections when needed:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 private List<Child> children = new ArrayList<>();
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 private List<Grandchild> grandchildren = new ArrayList<>();
 
 // Getters and setters
}

// In your service
public Parent getParentWithChildren(Long id) {
 Parent parent = parentRepository.findById(id);
 if (parent != null) {
 // Initialize only the children collection
 Hibernate.initialize(parent.getChildren());
 }
 return parent;
}

For collections that you know will always be needed together, you can use FetchType.EAGER for one collection and FetchType.LAZY for others, then initialize the lazy collections when needed. This approach gives you more control while avoiding the MultipleBagFetchException.

Advanced Techniques: EntityGraph and Batch Fetching

For more complex scenarios, Hibernate provides several advanced techniques for handling multiple collections efficiently:

EntityGraph

EntityGraph allows you to specify exactly which associations should be fetched in a particular query:

@Repository
public class ParentRepository {
 
 @PersistenceContext
 private EntityManager entityManager;
 
 public Parent findByIdWithChildrenAndGrandchildren(Long id) {
 EntityGraph<Parent> graph = entityManager.createEntityGraph(Parent.class);
 graph.addAttributeNodes("children");
 graph.addAttributeNodes("grandchildren");
 
 Map<String, Object> properties = new HashMap<>();
 properties.put("javax.persistence.fetchgraph", graph);
 
 return entityManager.find(Parent.class, id, properties);
 }
}

This approach gives you fine-grained control over which associations are fetched without modifying your entity mappings.

Batch Fetching

Batch fetching allows Hibernate to fetch multiple entities in a single query, reducing the number of database roundtrips:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 @BatchSize(size = 10)
 private List<Child> children = new ArrayList<>();
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 @BatchSize(size = 10)
 private List<Grandchild> grandchildren = new ArrayList<>();
 
 // Getters and setters
}

The @BatchSize annotation tells Hibernate to fetch up to 10 child entities or grandchildren at a time when initializing lazy collections.

FetchMode

You can also use @Fetch to specify how associations should be fetched:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 @Fetch(FetchMode.SELECT)
 private List<Child> children = new ArrayList<>();
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
 @Fetch(FetchMode.JOIN)
 private List<Grandchild> grandchildren = new ArrayList<>();
 
 // Getters and setters
}

Here, FetchMode.SELECT will use a separate query to load children, while FetchMode.JOIN will use a SQL join to load grandchildren.

Best Practices for Multiple @OneToMany Relationships

When working with multiple @OneToMany relationships in Hibernate, consider these best practices:

1. Default to FetchType.LAZY: Unless you have a specific reason to use eager loading, keep your collections lazy-loaded by default. This prevents unintended data loading and reduces memory usage.

2. Use Sets When Order Doesn’t Matter: If you don’t need to maintain the order of elements in a collection, use Set instead of List. This helps avoid the MultipleBagFetchException and ensures no duplicates.

3. Implement Query Splitting: For collections that you need together but can’t load eagerly, implement query splitting to fetch them in separate queries when needed.

4. Use EntityGraph for Dynamic Fetching: When you need to fetch specific associations for a particular use case, use EntityGraph to specify exactly which associations should be loaded.

5. Consider Batch Fetching for Large Collections: Use @BatchSize to efficiently load large collections by fetching them in batches rather than one at a time.

6. Avoid Multiple Eager Collections: Never mark multiple @OneToMany collections with FetchType.EAGER in the same entity. This is a recipe for performance issues and the MultipleBagFetchException.

7. Use DTOs for Complex Queries: When you need data from multiple entities for a specific view, consider using DTOs (Data Transfer Objects) with JPQL queries to fetch only the data you need.

8. Profile Your Queries: Use Hibernate’s logging or profiling tools to understand how your queries are performing and identify potential issues.

9. Consider Using @OrderColumn for Lists: If you must use List collections and need them to be eager-loaded, add @OrderColumn to make them ordered lists instead of bags:

@Entity
public class Parent {
 @Id
 @GeneratedValue
 private Long id;
 
 private String name;
 
 @OneToMany(mappedBy = "parent", cascade = CascadeType.ALL, fetch = FetchType.EAGER)
 @OrderColumn(name = "child_order")
 private List<Child> children = new ArrayList<>();
 
 // Getters and setters
}

10. Document Your Fetch Strategy: Make sure your team understands the fetch strategy for each collection and document why certain decisions were made. This helps maintain consistency and avoid future issues.

Sources

1. Vlad Mihalcea’s Hibernate Blog — Detailed explanation of MultipleBagFetchException and its root causes: https://vladmihalcea.com/hibernate-multiplebagfetchexception/
2. Thorben Janssen’s Hibernate Tips — How to avoid Hibernate’s MultipleBagFetchException with practical solutions: https://thorben-janssen.com/hibernate-tips-how-to-avoid-hibernates-multiplebagfetchexception/
3. Thorben Janssen’s Fix Guide — Comprehensive comparison of @LazyCollection(FALSE) vs FetchType.EAGER: https://thorben-janssen.com/fix-multiplebagfetchexception-hibernate/
4. Stack Overflow Discussion — Community solutions and practical workarounds for MultipleBagFetchException: https://stackoverflow.com/questions/17566304/multiple-fetches-with-eager-type-in-hibernate-with-jpa
5. Stack Overflow Performance Considerations — Discussion on performance implications and best practices: https://stackoverflow.com/questions/37282850/hibernate-org-hibernate-loader-multiplebagfetchexception-cannot-simultaneousl

Conclusion

Resolving the Hibernate MultipleBagFetchException requires understanding how Hibernate handles collections and choosing appropriate strategies for your specific use case. While using Set instead of List can prevent the exception, it doesn’t solve the underlying performance issue of Cartesian products. Query splitting provides a more robust solution by fetching collections separately when needed.

For most applications, the best approach is to default to FetchType.LAZY and initialize collections only when they’re actually required. Use @LazyCollection(FALSE) sparingly and only when you have a specific need for eager loading of a single collection. For more complex scenarios, leverage advanced techniques like EntityGraph, batch fetching, and custom DTO queries to precisely control how data is fetched.

Ultimately, the key to handling multiple @OneToMany relationships in Hibernate is to be deliberate about your data access patterns, avoid multiple eager collections, and use lazy loading as your default strategy. By following these practices, you can avoid the MultipleBagFetchException while maintaining optimal performance in your Java applications.