Fetch types (LAZY vs EAGER) in Spring Boot - Visual Side-by-Side Comparison

Concept Flow - Fetch types (LAZY vs EAGER)

Start Entity Load

↓

Fetch Type?

EAGER→Load Related Data Immediately

↓

Load Proxy Placeholder

↓

Access Related Data?

No→Return Proxy

Yes↓

Fetch Related Data Now

↓

Return Full Data

When loading an entity, eager fetch loads related data immediately, while lazy fetch loads a placeholder and fetches related data only when accessed.

Execution Sample

Spring Boot

class Order {
  @OneToMany(fetch = FetchType.LAZY)
  List<Item> items;
}

Order order = repo.findById(1).orElse(null);
order.getItems();

This code loads an Order entity with items fetched lazily, so items load only when getItems() is called.

Execution Table

Step	Action	Fetch Type	Data Loaded	Result
1	Load Order entity	LAZY	Order data only	Order object with items proxy
2	Access order.getItems()	LAZY	Items data fetched now	Full Order with items loaded
3	Load Order entity	EAGER	Order and items data	Full Order with items loaded immediately
4	Access order.getItems()	EAGER	No additional fetch	Items already loaded

💡 Execution stops after data is fully loaded or proxy returned depending on fetch type.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4
order	null	Order with items proxy	Order with items loaded	Order with items loaded	Order with items loaded

Key Moments - 2 Insights

Why does accessing items trigger a database call in LAZY fetch?

Because at Step 1 in execution_table, only a proxy is loaded. The actual items data is fetched only when getItems() is called at Step 2.

Does EAGER fetch load related data immediately or later?

EAGER fetch loads related data immediately as shown in Step 3, so no extra fetch happens when accessing items at Step 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is loaded at Step 1 with LAZY fetch?

A Order data only with items proxy

B Order and items data fully loaded

C Only items data loaded

D No data loaded yet

💡 Hint

Check Step 1 row under Data Loaded column in execution_table.

At which step does the actual items data load in LAZY fetch?

A Step 3

B Step 1

C Step 2

D Step 4

💡 Hint

Look at when 'Items data fetched now' happens in execution_table.

If fetch type changes from LAZY to EAGER, what changes in the execution?

A Items load only when accessed at Step 2

B Items load immediately with Order at Step 3

C Order does not load at all

D Items never load

💡 Hint

Compare Step 3 and Step 1 rows for EAGER vs LAZY in execution_table.

Concept Snapshot

Fetch Types in Spring Boot:
- LAZY: Load main entity first, related data loads only on access.
- EAGER: Load main entity and related data immediately.
- LAZY uses proxy placeholders to delay loading.
- EAGER fetch can impact performance if related data is large.
- Choose fetch type based on use case to optimize loading.

Full Transcript

In Spring Boot, fetch types control when related data loads with an entity. EAGER fetch loads all related data immediately when the main entity loads. LAZY fetch loads only the main entity first and uses a proxy for related data. The related data loads only when accessed later. This helps optimize performance by delaying data loading until needed. The execution table shows that with LAZY, the items list is a proxy after loading the order, and only fetches items when getItems() is called. With EAGER, items load immediately with the order. Understanding this helps avoid unexpected database calls and performance issues.