Relationships & the N+1 Problem

Real data is connected. A Member has many Loans; each Loan belongs to one Book. JPA maps these relationships between entities - and hides one of the most common performance traps in all of Spring: the N+1 problem.

Mapping relationships

@Entity
class Loan {
    @Id @GeneratedValue Long id;

    @ManyToOne                       // many loans -> one book
    Book book;

    @ManyToOne                       // many loans -> one member
    Member member;

    LocalDate borrowedAt;
    LocalDate dueAt;
}

@Entity
class Member {
    @Id @GeneratedValue Long id;
    String displayName;

    @OneToMany(mappedBy = "member")  // one member -> many loans
    List<Loan> loans;
}

@ManyToOne and @OneToMany describe the two sides; mappedBy says which side owns the foreign key (the Loan.member column).

Lazy vs eager loading

To-many relationships (@OneToMany) are lazy by default: the loans list isn't loaded until you actually access it. That's usually what you want - you don't pay to load loans every time you fetch a member. But laziness is exactly what sets the trap.

The N+1 problem

Load 100 members, then loop and read each member's loans:

List<Member> members = memberRepository.findAll();   // 1 query
for (Member m : members) {
    m.getLoans().size();                             // + 1 query PER member!
}

That's 1 query for the members, then N more (one per member) to lazily fetch each one's loans: N+1 queries where a single join would do. With 100 members that's 101 database round-trips - a silent killer that looks fine with test data and melts in production.

The fix: fetch it in one query

Ask for the relationship up front with a JOIN FETCH (or an entity graph):

@Query("SELECT m FROM Member m JOIN FETCH m.loans")
List<Member> findAllWithLoans();          // members AND their loans — ONE query

Now it's 1 query total. Keep relationships lazy by default, and explicitly fetch what a given use case needs.