Fetch types (LAZY vs EAGER) in Spring Boot - Hands-On Comparison

Fetch types (LAZY vs EAGER) in Spring Boot JPA

📖 Scenario: You are building a simple Spring Boot application to manage Authors and their Books. Each author can have multiple books.In real life, sometimes you want to load all books of an author immediately when you get the author (EAGER fetching). Other times, you want to load the books only when you really need them (LAZY fetching).

🎯 Goal: Learn how to define JPA entity relationships with fetch = FetchType.LAZY and fetch = FetchType.EAGER in Spring Boot. You will create two entities, configure fetch types, and see how to set them up in code.

📋 What You'll Learn

Create two JPA entities: Author and Book

Set up a one-to-many relationship from Author to Book

Configure the fetch type for the books collection

Understand how to switch between LAZY and EAGER fetching

💡 Why This Matters

🌍 Real World

In real applications, controlling when related data loads helps improve performance and user experience. For example, loading all books eagerly might slow down the app if an author has many books.

💼 Career

Understanding fetch types is essential for backend developers working with Spring Boot and JPA to write efficient and maintainable data access code.

1

Create the Author entity with a books list

Create a JPA entity class called Author with fields id (Long, primary key), name (String), and a list of Book called books. Use @Entity and @Id annotations. Initialize books as an empty list.

Spring Boot

@Entity
public class Author {
    // Your code here
}

Hint

Remember to import javax.persistence.Entity, javax.persistence.Id, and java.util.List and java.util.ArrayList.

2

Create the Book entity with a reference to Author

Create a JPA entity class called Book with fields id (Long, primary key), title (String), and a reference to Author called author. Use @Entity, @Id, and @ManyToOne annotations.

Spring Boot

@Entity
public class Author {
    @Id
    private Long id;
    private String name;
    @OneToMany(mappedBy = "author")
    private List books = new ArrayList();

    // getters and setters
}

@Entity
public class Book {
    // Your code here
}

Hint

Remember the @ManyToOne annotation to link back to the author.

3

Set fetch type to LAZY on the books collection

Modify the books field in the Author class to use fetch = FetchType.LAZY in the @OneToMany annotation.

Spring Boot

@Entity
public class Author {
    @Id
    private Long id;
    private String name;
    @OneToMany(mappedBy = "author", fetch = FetchType.LAZY)
    private List books = new ArrayList();

    // getters and setters
}

// Your code here if needed

Hint

Use fetch = FetchType.LAZY inside the @OneToMany annotation.

4

Change fetch type to EAGER on the books collection

Change the fetch type on the books field in Author to FetchType.EAGER in the @OneToMany annotation.

Spring Boot

import javax.persistence.FetchType;
// Change fetch type to EAGER below
@Entity
public class Author {
    @Id
    private Long id;
    private String name;
    @OneToMany(mappedBy = "author", fetch = FetchType.EAGER)
    private List books = new ArrayList();

    // getters and setters
}

// Your code here if needed

Hint

Simply replace FetchType.LAZY with FetchType.EAGER in the annotation.

Practice

1. What does the LAZY fetch type do in Spring Boot JPA?

easy

A. It disables loading of related entities completely.

B. It loads all related entities immediately with the main entity.

C. It delays loading related entities until they are accessed.

D. It loads related entities only during application startup.

Solution

1. Step 1: Understand fetch types in JPA

   Fetch types control when related data is loaded from the database.

2. Step 2: Define LAZY fetch behavior

   LAZY means related entities are loaded only when you access them, not immediately.

3. Final Answer:

   It delays loading related entities until they are accessed. -> Option C

4. Quick Check:

   LAZY = delayed loading [OK]

Hint: LAZY means wait to load until needed [OK]

Common Mistakes:

• Confusing LAZY with EAGER loading
• Thinking LAZY loads data immediately
• Assuming LAZY disables loading

2. Which is the correct way to specify EAGER fetching on a JPA relationship in Spring Boot?

easy

A. @ManyToOne(fetch = FetchType.EAGER)

B. @OneToMany(fetch = FetchType.LAZY)

C. @OneToOne(fetch = FetchType.LAZY)

D. @ManyToMany(fetch = FetchType.LAZY)

Solution

1. Step 1: Identify correct annotation and fetch type

   EAGER fetch type is set using fetch = FetchType.EAGER inside relationship annotations.

2. Step 2: Match correct relationship and fetch type

   @ManyToOne(fetch = FetchType.EAGER) uses @ManyToOne(fetch = FetchType.EAGER), which is valid and correct.

3. Final Answer:

   @ManyToOne(fetch = FetchType.EAGER) -> Option A

4. Quick Check:

   EAGER fetch uses FetchType.EAGER [OK]

Hint: EAGER fetch uses FetchType.EAGER in annotation [OK]

Common Mistakes:

• Using LAZY instead of EAGER for eager loading
• Mixing relationship types with wrong fetch types
• Forgetting to specify fetch attribute

3. Given the following code snippet, what will happen when order.getItems() is called if items is marked with fetch = FetchType.LAZY?

@Entity
class Order {
  @OneToMany(fetch = FetchType.LAZY)
  private List<Item> items;
}
Order order = entityManager.find(Order.class, 1L);
// No call to getItems() yet

medium

A. The items list is loaded immediately when the order is fetched.

B. The items list is never loaded, causing a null pointer exception.

C. The items list is loaded during application startup.

D. The items list is loaded only when getItems() is called.

Solution

1. Step 1: Understand LAZY fetch behavior on collections

   With LAZY fetch, related collections like items are not loaded immediately.

2. Step 2: When is data loaded?

   The data loads only when the getter getItems() is called, triggering the fetch.

3. Final Answer:

   The items list is loaded only when getItems() is called. -> Option D

4. Quick Check:

   LAZY fetch loads on access [OK]

Hint: LAZY loads collections only on getter call [OK]

Common Mistakes:

• Assuming collections load immediately with LAZY
• Expecting null instead of a proxy collection
• Confusing LAZY with EAGER behavior

4. You have a @OneToMany(fetch = FetchType.LAZY) relationship, but you get a LazyInitializationException when accessing the collection outside a transaction. What is the likely cause?

medium

A. The fetch type should be LAZY, so this exception is unexpected.

B. The collection was accessed after the session was closed.

C. The entity was not annotated with @Entity.

D. The database connection is lost.

Solution

1. Step 1: Understand LazyInitializationException cause

   This exception happens when a LAZY collection is accessed outside an open session or transaction.

2. Step 2: Identify session state during access

   If the session is closed before accessing the collection, the proxy cannot load data, causing the exception.

3. Final Answer:

   The collection was accessed after the session was closed. -> Option B

4. Quick Check:

   LazyInitializationException = access after session close [OK]

Hint: Access LAZY data only inside open session/transaction [OK]

Common Mistakes:

• Thinking fetch type alone prevents exceptions
• Ignoring session lifecycle in JPA
• Blaming database connection instead

5. You have an entity Author with a @OneToMany(fetch = FetchType.LAZY) relationship to Book. You want to display all authors with their books immediately to avoid multiple queries later. Which approach is best?

hard

A. Keep LAZY fetch and use a JPQL query with JOIN FETCH to load books eagerly.

B. Use native SQL queries only to load all data at once.

C. Load authors and books separately in two queries and merge in Java code.

D. Change the fetch type to EAGER on the relationship.

Solution

1. Step 1: Understand pros and cons of fetch types

   Changing to EAGER can cause performance issues if not always needed.

2. Step 2: Use JOIN FETCH for selective eager loading

   JPQL with JOIN FETCH loads related entities eagerly only when needed, avoiding multiple queries.

3. Step 3: Evaluate other options

   Loading separately or using native queries is less efficient or more complex.

4. Final Answer:

   Keep LAZY fetch and use a JPQL query with JOIN FETCH to load books eagerly. -> Option A

5. Quick Check:

   JOIN FETCH = selective eager loading [OK]

Hint: Use JOIN FETCH query to eagerly load LAZY relations [OK]

Common Mistakes:

• Switching to EAGER globally causing overhead
• Ignoring JPQL JOIN FETCH option
• Overcomplicating with native queries