Understanding and Solving the N+1 Problem in Spring Data JPA / Hibernate

programming coyote — Sun, 09 Aug 2026 16:52:01 +0000

If you are working with ORM (Object-Relational Mapping) tools like Hibernate or Spring Data JPA, there is a high chance you will run into a common performance issue called the N+1 Problem.
Whether you work with Java, Node.js (Prisma), Python (Django), or C# (.NET), this concept applies to almost every modern backend framework.

🧐 What is the N+1 Problem?

The N+1 problem occurs when an ORM executes 1 initial query to fetch a list of records, and then executes N additional queries to fetch related data for each item in that list.
Instead of fetching all the required data in one single query, your application ends up making $1 + N$ queries to the database.

⚙️ When Does It Happen?

The N+1 problem usually happens when three conditions are met:

You have two or more related database tables (e.g., Marks and Student).
You define entity relationships like @ManyToOne, @OneToMany, or @ManyToMany.
The relationship uses Lazy Loading (FetchType.LAZY).

💡 Step-by-Step Example

Let’s say we have two entities: MarksEntity and StudentEntity. Each mark belongs to a student (@ManyToOne).
We want to retrieve 10 mark records along with the student details for each mark.

Here is what happens behind the scenes with Lazy Loading:

1. First Query (1)

Spring Data JPA fetches 10 records from the marks table.

SELECT * FROM marks LIMIT 10;

2. Creating Proxy (Dummy) Objects

Because student is set to LAZY loading, Hibernate does not fetch the student data immediately. Instead, it puts a Proxy (Dummy) Object inside the mark entity.

3. Subsequent Queries (N = 10)

Now, in your service layer or DTO mapper, you loop through the marks and access the student’s name: mark.getStudent().getName().
The moment you call getStudent(), Hibernate realizes the actual student data is missing. It fires an extra query to fetch the student for that specific mark. Since there are 10 marks, it fires 10 extra queries!

SELECT * FROM student WHERE id = 1;
SELECT * FROM student WHERE id = 2;
…
SELECT * FROM student WHERE id = 10;

📊 Total Queries Sent to the Database:

Total Queries = 1 (Initial Query) + 10 (Student Queries) = 11 Queries

🛑 Why is this bad for performance?

If you fetch 10,000 records in production, your application will fire 10,001 queries to the database. This causes high network latency, heavy CPU usage, and slows down your entire application.

🛠️ How to Fix the N+1 Problem

To fix this, we need to tell the database: “Do not create dummy objects. Join the tables and fetch all the required data in a single query.”

In Spring Data JPA, there are two primary ways to do this:

Method 1: @EntityGraph (Declarative / Annotation Method) 🏆

Method 2: JOIN FETCH (Explicit JPQL Method) 🥈

Method 1: @EntityGraph (Declarative / Annotation Method) 🏆

This is the easiest and cleanest way provided by Spring Data JPA. You do not need to write custom JPQL queries. You simply add the @EntityGraph annotation above your repository method and specify which relationships to fetch eagerly.

// Overriding the built-in findAll method
@EntityGraph(attributePaths = {"student"})
List<MarksEntity> findAll();

// Using with a custom derived query
@EntityGraph(attributePaths = {"student"})
List<MarksEntity> findBySubject(String subject);

🟢 Pros:

Clean and simple: No need to write manual SQL or JPQL queries.
Pagination friendly: Works seamlessly with Pageable (Page < MarksEntity>).
Multi-level joins: You can easily fetch nested relationships (e.g., attributePaths = {"student", "student.school"}).

Method 2: JOIN FETCH (Explicit JPQL Method) 🥈

This method involves writing a custom JPQL query using the JOIN FETCH keyword. It tells Hibernate to join the table and populate the related entity fields immediately.

// Using JOIN FETCH in a custom JPQL query
@Query(“SELECT m FROM MarksEntity m JOIN FETCH m.student”)
List<MarksEntity> findAllWithStudent();

// Using JOIN FETCH with a WHERE clause
@Query(“SELECT m FROM MarksEntity m JOIN FETCH m.student s WHERE s.city = :city”)
List<MarksEntity> findByStudentCity(@Param(“city”) String city);