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.