← Java

Java · 21 / 24

JPA-Abfragen und das N+1-Problem

Du misst zusätzliche Datenbankabfragen und prüfst einen gezielten Fetch Join.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: PostgreSQL, JPA und Flyway verstehen

In diesem Tutorial
  1. Den Fachvertrag lesen
  2. Die Umgebung isoliert starten
  3. Erfolg und Fehler prüfen
  4. Eine Regression sichtbar machen
  5. Den Vertrag erweitern
  6. Die Lösung und ihre Grenzen erklären
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

Einrichtung und Prüfstand

JDK 21, Maven ab 3.9, Docker. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.

verify.py startet PostgreSQL selbst. mvn test allein benötigt entsprechende Datenbank-Umgebungsvariablen.

Geprüft am 20.10.2026 unter Linux x86_64. Drei Datensätze erzeugen im langsamen Pfad vier Statements und mit Fetch Join eines. Nach einem vierten Datensatz erwartet die Lösung fünf gegenüber einem Statement. Das ist keine pauschale Empfehlung für Collection-Fetch-Joins mit Pagination.

Ein ORM kann mehrere SQL-Abfragen hinter scheinbar einfachen Feldzugriffen verstecken. Der Test speichert drei Fahrzeuge mit je einem Eintrag. Danach leert er den Persistence Context, damit bereits geladene Objekte das Problem nicht verdecken. Hibernate-Statistiken messen die Statements gegen eine echte PostgreSQL-Datenbank.

Paketinhalt und einzelne Dateien

01Den Fachvertrag lesen

LAZY verschiebt das Laden einer Beziehung. Der Zugriff auf getName kann daher eine weitere SQL-Abfrage auslösen. Ein Fetch Join lädt die benötigte Beziehung in derselben Abfrage. em.clear verhindert, dass der First-Level-Cache den Vergleich verfälscht.

src/main/java/tutorial/Application.java · javaDatei öffnen
package tutorial;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

@jakarta.persistence.Entity(name = "Vehicle")
class Vehicle {

  @jakarta.persistence.Id
  Long id;

  String name;

  public String getName() {
    return name;
  }

  protected Vehicle() {}

  Vehicle(long id, String name) {
    this.id = id;
    this.name = name;
  }
}

@jakarta.persistence.Entity(name = "RecordEntry")
class RecordEntry {

  @jakarta.persistence.Id
  Long id;

  @jakarta.persistence.ManyToOne(fetch = jakarta.persistence.FetchType.LAZY)
  Vehicle vehicle;

  protected RecordEntry() {}

  RecordEntry(long id, Vehicle v) {
    this.id = id;
    this.vehicle = v;
  }
}

02Die Umgebung isoliert starten

Java 21 ist die festgelegte Sprachbasis. Maven löst die Abhängigkeiten aus der POM auf. verify.py erzeugt eine eigene PostgreSQL-Instanz auf einem freien lokalen Port und entfernt nur diesen Container nach dem Test.

pom.xml · xmlDatei öffnen
<project xmlns="http://maven.apache.org/POM/4.0.0">
<modelVersion>4.0.0</modelVersion>
<parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>4.1.0</version></parent>
<groupId>learning</groupId><artifactId>tutorial</artifactId><version>1.0</version>
<properties><java.version>21</java.version></properties>
<dependencies>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.postgresql</groupId><artifactId>postgresql</artifactId></dependency>
</dependencies>
<build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build>
</project>

03Erfolg und Fehler prüfen

Drei Datensätze erzeugen im langsamen Pfad vier Statements und mit Fetch Join eines. Nach einem vierten Datensatz erwartet die Lösung fünf gegenüber einem Statement. Das ist keine pauschale Empfehlung für Collection-Fetch-Joins mit Pagination.

src/test/java/tutorial/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import jakarta.persistence.*;
import org.hibernate.SessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

@SpringBootTest
@Transactional
class LessonTest {

  @PersistenceContext
  EntityManager em;

  @Test
  void fetchJoinAvoidsExtraStatements() {
    for (long i = 1; i <= 3; i++) {
      var v = new Vehicle(i, "Vehicle " + i);
      em.persist(v);
      em.persist(new RecordEntry(i, v));
    }
    em.flush();
    em.clear();
    var stats = em
      .getEntityManagerFactory()
      .unwrap(SessionFactory.class)
      .getStatistics();
    stats.clear();
    var slow = em
      .createQuery(
        "select e from RecordEntry e order by e.id",
        RecordEntry.class
      )
      .getResultList();
    var names = slow
      .stream()
      .map(e -> e.vehicle.getName())
      .toList();
    assertEquals(3, names.size());
    assertEquals(4, stats.getPrepareStatementCount());
    em.clear();
    stats.clear();
    var fast = em
      .createQuery(
        "select e from RecordEntry e join fetch e.vehicle order by e.id",
        RecordEntry.class
      )
      .getResultList();
    assertEquals(
      names,
      fast
        .stream()
        .map(e -> e.vehicle.getName())
        .toList()
    );
    assertEquals(1, stats.getPrepareStatementCount());
  }
}

Starten / prüfen

python3 verify.py
Erwartetes Ergebnis

Drei Datensätze erzeugen im langsamen Pfad vier Statements und mit Fetch Join eines. Nach einem vierten Datensatz erwartet die Lösung fünf gegenüber einem Statement. Das ist keine pauschale Empfehlung für Collection-Fetch-Joins mit Pagination.

04Eine Regression sichtbar machen

Verändere eine fachliche Erwartung und starte den Test erneut. Maven muss einen Fehler melden. Ein übersprungener Datenbanktest ist kein Nachweis. Stelle anschließend die richtige Erwartung wieder her.

05Den Vertrag erweitern

Ergänze einen vierten Datensatz und passe die erwartete Statementzahl des langsamen Pfads an.

06Die Lösung und ihre Grenzen erklären

Der langsame Pfad führt eine Listenabfrage und vier Nachladeabfragen aus. Der Fetch Join bleibt bei einer Abfrage. Das sagt noch nichts über Pagination bei Collection-Fetch-Joins aus. Dafür ist ein eigener Abfrageentwurf nötig. Kopiere solution/LessonTest.java über die Testdatei und wiederhole denselben Prüfablauf.

Erwartetes Ergebnis

Alle Testfälle bestehen, einschließlich der zusätzlichen Lösungserwartung.

Deine Übung

Ergänze einen vierten Datensatz und passe die erwartete Statementzahl des langsamen Pfads an.

Lösung mit Erklärung anzeigen

Der langsame Pfad führt eine Listenabfrage und vier Nachladeabfragen aus. Der Fetch Join bleibt bei einer Abfrage. Das sagt noch nichts über Pagination bei Collection-Fetch-Joins aus. Dafür ist ein eigener Abfrageentwurf nötig.

solution/LessonTest.java · javaDatei öffnen
package tutorial;

import static org.junit.jupiter.api.Assertions.*;

import jakarta.persistence.*;
import org.hibernate.SessionFactory;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

@SpringBootTest
@Transactional
class LessonTest {

  @PersistenceContext
  EntityManager em;

  @Test
  void fetchJoinAvoidsExtraStatements() {
    for (long i = 1; i <= 4; i++) {
      var v = new Vehicle(i, "Vehicle " + i);
      em.persist(v);
      em.persist(new RecordEntry(i, v));
    }
    em.flush();
    em.clear();
    var stats = em
      .getEntityManagerFactory()
      .unwrap(SessionFactory.class)
      .getStatistics();
    stats.clear();
    var slow = em
      .createQuery(
        "select e from RecordEntry e order by e.id",
        RecordEntry.class
      )
      .getResultList();
    var names = slow
      .stream()
      .map(e -> e.vehicle.getName())
      .toList();
    assertEquals(4, names.size());
    assertEquals(5, stats.getPrepareStatementCount());
    em.clear();
    stats.clear();
    var fast = em
      .createQuery(
        "select e from RecordEntry e join fetch e.vehicle order by e.id",
        RecordEntry.class
      )
      .getResultList();
    assertEquals(
      names,
      fast
        .stream()
        .map(e -> e.vehicle.getName())
        .toList()
    );
    assertEquals(1, stats.getPrepareStatementCount());
  }
}

Projektbezug und Quellen

Das eigenständige Lernprojekt vertieft ein Thema aus diesem Technologiebereich. Die Projektverweise zeigen einen festgehaltenen Quellstand als Architekturkontext. Sie sind kein Beleg dafür, dass jede hier neu eingeführte Bibliothek oder Funktion bereits in dieser App verwendet wird.