Why relationships matter in JPA in Spring Boot - Performance Evidence

Performance: Why relationships matter in JPA

HIGH IMPACT

This affects database query performance and page load speed by controlling how related data is fetched and rendered.

Fetching related entities in a web application

Spring Boot

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

// Items load only when accessed, reducing initial query size

Lazy fetching delays loading related data until needed, reducing initial query size and speeding up rendering.

📈 Performance GainReduces initial query time by 50%+, improves LCP by loading main content faster

Fetching related entities in a web application

Spring Boot

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

// Fetching orders triggers loading all items immediately, even if not needed

Eager fetching loads all related entities upfront, causing large queries and slow page load.

📉 Performance CostTriggers large SQL joins, increasing query time and blocking rendering for 200+ ms

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
Eager fetching all relationships	N/A (backend data)	N/A	Blocks rendering due to slow data arrival	[X] Bad
Lazy fetching with selective joins	N/A (backend data)	N/A	Faster data arrival, smoother rendering	[OK] Good

Rendering Pipeline

JPA relationships affect how data is fetched from the database and passed to the frontend. Eager loading causes large queries and delays data availability, impacting the browser's ability to render main content quickly.

→Data Fetching

→JavaScript Execution

→Rendering

⚠️ BottleneckData Fetching stage due to large or multiple SQL queries

Core Web Vital Affected

LCP

This affects database query performance and page load speed by controlling how related data is fetched and rendered.

Optimization Tips

1Avoid eager fetching for large or multiple relationships to prevent slow queries.

2Use lazy fetching to load related data only when necessary.

3Optimize queries with fetch joins to balance data loading and performance.

Performance Quiz - 3 Questions

What is the main performance risk of using eager fetching for all JPA relationships?

A It improves browser rendering speed

B It causes large database queries that delay page rendering

C It reduces the number of database queries

D It decreases memory usage on the server

DevTools: Network

How to check: Open DevTools, go to Network tab, reload page, and observe SQL API calls or backend data fetch timing.

What to look for: Look for large or multiple slow API calls caused by eager loading; fewer and faster calls indicate better performance.

Practice

1. Why are relationships important in JPA when working with entities?

easy

A. They allow easy navigation and management of related data between entities.

B. They improve the speed of the Java compiler.

C. They automatically generate user interfaces for entities.

D. They replace the need for database tables.

Solution

1. Step 1: Understand the role of relationships in JPA

   Relationships link entities so you can access related data easily, like a map connecting places.

2. Step 2: Recognize the benefit of these links

   They help manage and query related data without manual joins or extra queries.

3. Final Answer:

   They allow easy navigation and management of related data between entities. -> Option A

4. Quick Check:

   Relationships = Easy data navigation [OK]

Hint: Think of relationships as bridges connecting data [OK]

Common Mistakes:

• Confusing relationships with UI features
• Assuming relationships speed up compilation
• Believing relationships remove database tables

2. Which annotation correctly defines a many-to-one relationship in JPA?

easy

A. @OneToMany

B. @ManyToMany

C. @ManyToOne

D. @OneToOne

Solution

1. Step 1: Recall JPA relationship annotations

   @ManyToOne is used when many entities relate to one entity, like many orders to one customer.

2. Step 2: Match the annotation to the relationship type

   @ManyToOne fits the question, others represent different relationships.

3. Final Answer:

   @ManyToOne -> Option C

4. Quick Check:

   @ManyToOne = many to one link [OK]

Hint: Many to one? Use @ManyToOne annotation [OK]

Common Mistakes:

• Using @OneToMany instead of @ManyToOne
• Confusing @OneToOne with many-to-one
• Mixing up @ManyToMany for simple many-to-one

3. Given the following JPA entities, what will be the output when fetching a Book and accessing its author.getName()?

@Entity
class Book {
  @Id
  Long id;
  String title;
  @ManyToOne
  Author author;
}

@Entity
class Author {
  @Id
  Long id;
  String name;
}

medium

A. NullPointerException because author is not initialized.

B. A compilation error due to missing @JoinColumn annotation.

C. The book's title will be returned instead of the author's name.

D. The author's name linked to the book will be returned.

Solution

1. Step 1: Understand the @ManyToOne relationship

   The Book entity has a many-to-one link to Author, so each book has one author object.

2. Step 2: Accessing author.getName()

   When fetching a Book, JPA loads the linked Author, so calling getName() returns the author's name.

3. Final Answer:

   The author's name linked to the book will be returned. -> Option D

4. Quick Check:

   Book.author.getName() = Author's name [OK]

Hint: ManyToOne means book has one author object [OK]

Common Mistakes:

• Assuming missing @JoinColumn causes compile error
• Expecting NullPointerException without checking data
• Confusing book title with author name

4. Identify the error in this JPA relationship mapping:

@Entity
class Order {
  @Id
  Long id;
  @OneToMany
  Customer customer;
}

medium

A. Using @OneToMany on a single Customer field instead of a collection.

B. Missing @Id annotation on Customer entity.

C. Order entity should not have any relationships.

D. The @OneToMany annotation should be replaced with @ManyToOne.

Solution

1. Step 1: Check the @OneToMany usage

   @OneToMany expects a collection (like List or Set), not a single object.

2. Step 2: Identify the field type mismatch

   The field 'customer' is a single Customer, so @OneToMany is incorrect here.

3. Final Answer:

   Using @OneToMany on a single Customer field instead of a collection. -> Option A

4. Quick Check:

   @OneToMany needs collection, not single object [OK]

Hint: @OneToMany always needs a collection type [OK]

Common Mistakes:

• Applying @OneToMany to a single entity field
• Ignoring collection requirement for @OneToMany
• Confusing relationship direction annotations

5. You have two entities: Student and Course. A student can enroll in many courses, and a course can have many students. Which JPA relationship setup correctly models this, and why is it important to define it properly?

hard

A. Use @OneToMany on Student and @ManyToOne on Course; it simplifies the database schema.

B. Use @ManyToMany on both sides with a join table; it ensures proper linking and querying of students and courses.

C. Use @OneToOne on both entities; it guarantees unique pairs.

D. No relationship annotations needed; just store IDs manually.

Solution

1. Step 1: Identify the relationship type

   Many students can enroll in many courses, so the relationship is many-to-many.

2. Step 2: Choose correct annotations and explain importance

   @ManyToMany on both sides with a join table models this correctly, allowing JPA to manage links and queries efficiently.

3. Final Answer:

   Use @ManyToMany on both sides with a join table; it ensures proper linking and querying of students and courses. -> Option B

4. Quick Check:

   Many-to-many needs @ManyToMany with join table [OK]

Hint: Many-to-many? Use @ManyToMany with join table [OK]

Common Mistakes:

• Using one-to-many for many-to-many relationships
• Skipping relationship annotations and managing IDs manually
• Using one-to-one where many-to-many is needed