Fetch types (LAZY vs EAGER) in Spring Boot - Practice Questions

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when accessing a LAZY fetched collection outside a transaction?

Consider a Spring Boot JPA entity with a @OneToMany(fetch = FetchType.LAZY) collection. What will happen if you try to access this collection after the transaction has closed?

Spring Boot

public class Author {
    @OneToMany(fetch = FetchType.LAZY, mappedBy = "author")
    private List<Book> books;

    public List<Book> getBooks() {
        return books;
    }
}

// In service method with @Transactional
Author author = authorRepository.findById(1L).get();
// Transaction ends here
List<Book> books = author.getBooks(); // What happens here?

A Returns an empty list because no books were loaded.

B Throws a LazyInitializationException because the collection was not loaded and session is closed.

C Returns the full list of books without any error.

D Throws a NullPointerException because the collection is null.

💡 Hint

Think about when the data is actually loaded from the database with LAZY fetch.

LAZY fetch means the collection is loaded only when accessed inside an open session/transaction. Accessing it outside causes a LazyInitializationException.

❓ state_output

intermediate

What is the default fetch type for @ManyToOne in Spring Data JPA?

Given the following entity snippet, what is the default fetch type for the @ManyToOne association?

Spring Boot

public class Book {
    @ManyToOne
    private Author author;

    public Author getAuthor() {
        return author;
    }
}

A LAZY

B Depends on the database configuration

C EAGER

D FetchType is not defined by default and must be set explicitly

💡 Hint

Check the JPA specification defaults for @ManyToOne.

By default, @ManyToOne associations are fetched eagerly, meaning the related entity is loaded immediately with the parent.

📝 Syntax

advanced

Which code snippet correctly sets a LAZY fetch type for a @OneToOne association?

Choose the correct way to declare a @OneToOne association with LAZY fetching in Spring Data JPA.

A

@OneToOne(fetch = FetchType.LAZY)
private Profile profile;

B

@OneToOne(lazy = true)
private Profile profile;

C

@OneToOne(fetchType = FetchType.LAZY)
private Profile profile;

D

@OneToOne(fetch = LAZY)
private Profile profile;

💡 Hint

Look carefully at the attribute name and enum usage in the annotation.

The correct attribute name is fetch and the value must be FetchType.LAZY. Other options have syntax errors or wrong attribute names.

🔧 Debug

advanced

Why does this EAGER fetch cause performance issues?

Given this entity relationship, why might setting fetch = FetchType.EAGER on a @OneToMany cause performance problems?

Spring Boot

public class Author {
    @OneToMany(fetch = FetchType.EAGER, mappedBy = "author")
    private List<Book> books;
}

A Because EAGER fetch disables caching and forces database hits every time.

B Because EAGER fetch delays loading the books until explicitly accessed.

C Because EAGER fetch causes the books list to be null until initialized.

D Because EAGER fetch loads all related books immediately, causing large joins or multiple queries.

💡 Hint

Think about what happens when many related entities are loaded eagerly.

EAGER fetch loads all related entities immediately, which can cause large joins or multiple queries, slowing down performance especially with large collections.

🧠 Conceptual

expert

How does Spring Boot handle LAZY fetch proxies in REST controllers by default?

In a Spring Boot REST controller, if you return an entity with LAZY loaded associations, what is the typical behavior when serializing to JSON?

A Serialization fails with a LazyInitializationException because the session is closed.

B The LAZY associations are automatically fetched and included in the JSON output.

C The LAZY associations are ignored and not included in the JSON output.

D The LAZY associations are serialized as empty objects.

💡 Hint

Consider when the Hibernate session is open and how Jackson serializes proxies.

By default, the Hibernate session is closed before serialization, so accessing LAZY proxies causes LazyInitializationException during JSON serialization.

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