JPA N+1 Problemi

1
@Entity
2
@Table(name = "card_statements")
3
public class CardStatement {
4

5
    @Id @GeneratedValue(strategy = GenerationType.SEQUENCE)
6
    private Long id;
7

8
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
9
    private CardAccount account;
10

11
    // Stays LAZY. Fetching is decided per query, not per mapping.
12
    @OneToMany(mappedBy = "statement")
13
    @BatchSize(size = 50)
14
    private List<CardTransaction> transactions = new ArrayList<>();
15

16
    private LocalDate cutOffDate;            // "hesap kesim tarihi"
17
    private LocalDate dueDate;               // "son ödeme tarihi"
18
    private BigDecimal totalDue;
19
    private BigDecimal minimumPayment;
20

21
    public List<CardTransaction> getTransactions() {
22
        return Collections.unmodifiableList(transactions);
23
    }
24

25
    // other getters omitted
26
}

1
interface CardStatementRepository extends JpaRepository<CardStatement, Long> {
2

3
    // One collection, no paging: a fetch join loads statements and transactions in one query.
4
    @Query("""
5
            select distinct s from CardStatement s
6
            join fetch s.transactions
7
            where s.cutOffDate = :cutOff
8
            """)
9
    List<CardStatement> findWithTransactions(LocalDate cutOff);
10

11
    // The customer's statement history screen, without writing JPQL.
12
    @EntityGraph(attributePaths = {"account", "transactions"})
13
    List<CardStatement> findByAccountIdOrderByCutOffDateDesc(long accountId);
14

15
    // Paging step 1: only ids, so LIMIT/OFFSET is applied by the database.
16
    @Query("select s.id from CardStatement s where s.cutOffDate = :cutOff order by s.id")
17
    Page<Long> findIdsByCutOff(LocalDate cutOff, Pageable pageable);
18

19
    // Paging step 2: the page's statements with their transactions.
20
    @Query("select distinct s from CardStatement s join fetch s.transactions where s.id in :ids")
21
    List<CardStatement> findWithTransactionsByIds(Collection<Long> ids);
22
}

1
@Service
2
class StatementRunService {
3

4
    private final CardStatementRepository statements;
5

6
    StatementRunService(CardStatementRepository statements) {
7
        this.statements = statements;
8
    }
9

10
    // The back-office screen lists every statement cut on one day: hundreds of
11
    // thousands of rows on a busy cut-off date, so it has to page in the database.
12
    // A fetch join combined with Pageable would page in memory (Hibernate warns:
13
    // "firstResult/maxResults specified with collection fetch; applying in memory").
14
    @Transactional(readOnly = true)
15
    public Page<StatementRow> page(LocalDate cutOff, Pageable pageable) {
16
        Page<Long> ids = statements.findIdsByCutOff(cutOff, pageable);                // ids + count
17
        Map<Long, CardStatement> loaded = statements.findWithTransactionsByIds(ids.getContent())
18
                .stream()
19
                .collect(Collectors.toMap(CardStatement::getId, Function.identity()));
20

21
        // Keep the database's order, not the map's.
22
        return ids.map(id -> StatementRow.of(loaded.get(id)));
23
    }
24
}

1
spring:
2
  jpa:
3
    open-in-view: false            # lazy loading outside a transaction fails fast
4
    properties:
5
      hibernate:
6
        default_batch_fetch_size: 50   # the global safety net behind @BatchSize
7
        generate_statistics: false     # turned on in tests only
8

9
logging:
10
  level:
11
    org.hibernate.SQL: DEBUG            # see every statement while developing

1
@DataJpaTest(properties = "spring.jpa.properties.hibernate.generate_statistics=true")
2
@Import(StatementRunService.class)
3
class StatementRunQueryCountTest {
4

5
    @Autowired StatementRunService runs;
6
    @Autowired EntityManagerFactory emf;
7
    @Autowired TestEntityManager em;
8

9
    private static final LocalDate CUT_OFF = LocalDate.of(2026, 9, 20);
10

11
    @Test
12
    void statementPageUsesAFixedNumberOfQueriesWhateverThePageSize() {
13
        Fixtures.statementsWithTransactions(em, CUT_OFF, 30, 3);   // 30 statements, 3 transactions each
14
        em.clear();
15

16
        Statistics stats = emf.unwrap(SessionFactory.class).getStatistics();
17
        stats.clear();
18

19
        Page<StatementRow> page = runs.page(CUT_OFF, PageRequest.of(0, 20));
20
        page.forEach(row -> assertThat(row.transactionCount()).isEqualTo(3));
21

22
        // ids, count (the page is full, so Spring Data asks for the total), statements
23
        // with transactions. N+1 would show 22 here, and 42 with a page size of 40.
24
        assertThat(stats.getPrepareStatementCount()).isEqualTo(3);
25
    }
26
}