@OneToMany relationship in Spring Boot - Performance & Optimization

Performance: @OneToMany relationship

MEDIUM IMPACT

This affects server response time and client rendering speed due to data loading and serialization of related entities.

Fetching parent entity with many child entities

Spring Boot

@Entity
public class Parent {
  @OneToMany(fetch = FetchType.LAZY)
  private List<Child> children;
}

Lazy loading fetches children only when needed, reducing initial data load and speeding response.

📈 Performance GainReduces initial payload size, improves LCP by loading less data upfront

Fetching parent entity with many child entities

Spring Boot

@Entity
public class Parent {
  @OneToMany(fetch = FetchType.EAGER)
  private List<Child> children;
}

Eager fetching loads all children immediately, causing large data transfer and slow response.

📉 Performance CostBlocks server response longer, increases payload size, delays LCP

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Eager @OneToMany loading	N/A (server-side)	N/A	Large JSON payload delays rendering	[X] Bad
Lazy @OneToMany loading with pagination	N/A (server-side)	N/A	Smaller payload improves rendering speed	[OK] Good

Rendering Pipeline

The server fetches parent and child entities, serializes them to JSON, sends to client, which then renders the data. Large @OneToMany collections increase serialization and transfer time.

→Data Fetching

→Serialization

→Network Transfer

→Client Rendering

⚠️ BottleneckSerialization and network transfer of large collections

Core Web Vital Affected

LCP

This affects server response time and client rendering speed due to data loading and serialization of related entities.

Optimization Tips

1Avoid FetchType.EAGER on large @OneToMany collections to prevent slow page loads.

2Use FetchType.LAZY and load child entities only when needed.

3Implement pagination or DTO projections to limit data size sent to clients.

Performance Quiz - 3 Questions

What is the main performance issue with using FetchType.EAGER on a @OneToMany relationship?

A It delays loading related entities until explicitly accessed.

B It loads all related entities immediately, increasing payload size and slowing response.

C It caches entities on the client side.

D It compresses data to reduce network usage.

DevTools: Network

How to check: Open DevTools, go to Network tab, reload page, inspect JSON response size and load time for API calls fetching @OneToMany data.

What to look for: Look for large payload sizes and long transfer times indicating heavy eager loading.