Spring Data JPA Stream-Abfragemethoden

Einführung

Traditionell kann das Abrufen großer Datenmengen die Speicherressourcen belasten, da oft die gesamte Ergebnismenge in den Speicher geladen werden muss.

=> Stream-Abfragemethoden bieten eine Lösung, indem sie eine Möglichkeit bieten, Daten inkrementell mithilfe von Java 8 Streams zu verarbeiten. Dadurch wird sichergestellt, dass immer nur ein Teil der Daten im Speicher gehalten wird, Leistung und Skalierbarkeit verbessern.

In diesem Blogbeitrag werden wir uns eingehend mit der Funktionsweise von Stream-Abfragemethoden in Spring Data JPA befassen, ihre Anwendungsfälle untersuchen und ihre Implementierung demonstrieren.

Für diesen Leitfaden verwenden wir:

• IDE: IntelliJ IDEA (empfohlen für Spring-Anwendungen) oder Eclipse
• Java-Version: 17
• Spring Data JPA-Version: 2.7.x oder höher (kompatibel mit Spring Boot 3.x)

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

HINWEIS: Für detailliertere Beispiele besuchen Sie bitte mein GitHub-Repository hier

1. Was sind Stream-Abfragemethoden?

Stream-Abfragemethoden in Spring Data JPA ermöglichen es uns, Abfrageergebnisse als Stream anstelle einer Liste oder anderer Sammlungstypen zurückzugeben. Dieser Ansatz bietet mehrere Vorteile:

• Effizientes Ressourcenmanagement: Daten werden inkrementell verarbeitet, wodurch der Speicheraufwand reduziert wird.

• Lazy Processing: Ergebnisse werden bei Bedarf abgerufen und verarbeitet, was ideal für Szenarien wie Paginierung oder Stapelverarbeitung ist.

• Integration mit funktionaler Programmierung: Streams passen zu den funktionalen Programmierfunktionen von Java und ermöglichen Vorgänge wie Filtern, Zuordnen und Sammeln.

2. Wie verwende ich Stream-Abfragemethoden?

=> Stellen wir uns vor, wir entwickeln eine E-Commerce-Anwendung und möchten:

• Rufen Sie alle Kunden ab, die nach einem bestimmten Datum Bestellungen aufgegeben haben.
• Filtern Sie Bestellungen mit einem Gesamtbetrag über einem bestimmten angegebenen Betrag.
• Gruppieren Sie Kunden nach ihrem Gesamtbestellwert innerhalb der letzten 6 Monate.
• Geben Sie die Daten als Zusammenfassung der Kundennamen und ihrer Gesamtbestellwerte zurück.

Entitäten

• Kunde: Stellt einen Kunden dar.

@Setter
@Getter
@Entity
@Entity(name = "tbl_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders;
}

• Bestellung: Stellt eine von einem Kunden aufgegebene Bestellung dar.

@Setter
@Getter
@Entity(name = "tbl_order")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Double amount;
    private LocalDateTime orderDate;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;
}

Repository

• CustomerRepository dient zur Auswahl von Kunden und den damit verbundenen Bestellungen, die nach einem bestimmten Datum aufgegeben werden. Und wir haben Stream statt List um das Ergebnis der Abfrage zu verarbeiten.

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    @Query("""
                SELECT c FROM tbl_customer c JOIN FETCH c.orders o WHERE o.orderDate >= :startDate
            """)
    @QueryHints(
            @QueryHint(name = AvailableHints.HINT_FETCH_SIZE, value = "25")
    )
    Stream<Customer> findCustomerWithOrders(@Param("startDate") LocalDateTime startDate);
}

HINWEIS:

• Der JOIN FETCH stellt sicher, dass Bestellungen eifrig geladen werden.

• Die @QueryHints werden verwendet, um der JPA zusätzliche Hinweise bereitzustellen (z. B. Ruhezustand), um die Abfrageausführung zu optimieren.

=> Wenn meine Abfrage beispielsweise 100 Datensätze zurückgibt:

• Die ersten 25 Datensätze werden von der Anwendung abgerufen und verarbeitet.
• Sobald diese verarbeitet sind, werden die nächsten 25 abgerufen und so weiter, bis alle 100 Datensätze verarbeitet sind.
• Dieses Verhalten minimiert die Speichernutzung und vermeidet das gleichzeitige Laden aller 100 Datensätze in den Speicher.

Service

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Hier ist die Serviceklasse zum Verarbeiten der Daten mit zwei Parametern startDate und minOrderAmount. Wie Sie sehen, filtern wir nicht mithilfe einer SQL-Abfrage, laden alle Daten als Stream und filtern und gruppieren dann nach unserem Java-Code.

Controller

@Setter
@Getter
@Entity
@Entity(name = "tbl_customer")
public class Customer {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private String email;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private List<Order> orders;
}

Testen

=> Um Daten zum Testen zu erstellen, können Sie das folgende Skript in meinem Quellcode ausführen oder es selbst hinzufügen.

src/main/resources/dummy-data.sql

Anfrage:

• Startdatum: 2024-05-01T00:00:00
• Mindestbestellmenge: 100

@Setter
@Getter
@Entity(name = "tbl_order")
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private Double amount;
    private LocalDateTime orderDate;

    @ManyToOne
    @JoinColumn(name = "customer_id")
    private Customer customer;
}

Antwort:

• Alle Kunden mit ihrem Gesamtbetrag zurückgeben, der gleich oder größer als minOrderAmount ist.

public interface CustomerRepository extends JpaRepository<Customer, Long> {
    @Query("""
                SELECT c FROM tbl_customer c JOIN FETCH c.orders o WHERE o.orderDate >= :startDate
            """)
    @QueryHints(
            @QueryHint(name = AvailableHints.HINT_FETCH_SIZE, value = "25")
    )
    Stream<Customer> findCustomerWithOrders(@Param("startDate") LocalDateTime startDate);
}

3. Stream vs. Liste

=> Sie können IntelliJ Profiler verwenden, um die Speichernutzung und die Ausführungszeit zu überwachen. Weitere Einzelheiten zum Hinzufügen und Testen mit großen Datensätzen finden Sie in meinem GitHub-Repository

Kleiner Datensatz: (10 Kunden, 100 Bestellungen)

• Stream: Ausführungszeit (~5 ms), Speichernutzung (Niedrig)
• Liste: Ausführungszeit (~4 ms), Speichernutzung (Niedrig)

Großer Datensatz (10.000 Kunden, 100.000 Bestellungen)

• Stream: Ausführungszeit (~202 ms), Speichernutzung (Moderat)
• Liste: Ausführungszeit (~176 ms), Speichernutzung (hoch)

Leistungsmetriken

Metric	Stream	List
Initial Fetch Time	Slightly slower (due to lazy loading)	Faster (all at once)
Memory Consumption	Low (incremental processing)	High (entire dataset in memory)
Memory Consumption	Low (incremental processing)	High (entire dataset in memory)
Processing Overhead	Efficient for large datasets	May cause memory issues for large datasets
Batch Fetching	Supported (with fetch size)	Not applicable
Error Recovery	Graceful with early termination	Limited, as data is preloaded

Einpacken

Die JPA-Stream-Abfragemethoden von Spring Data bieten eine elegante Möglichkeit, große Datensätze effizient zu verarbeiten und gleichzeitig die Leistungsfähigkeit von Java Streams zu nutzen. Durch die inkrementelle Datenverarbeitung reduzieren sie den Speicherverbrauch und lassen sich nahtlos in moderne funktionale Programmierparadigmen integrieren.

Was halten Sie von Stream-Abfragemethoden? Teilen Sie Ihre Erfahrungen und Anwendungsfälle in den Kommentaren unten!

Wir sehen uns in den nächsten Beiträgen. Viel Spaß beim Codieren!

Das obige ist der detaillierte Inhalt vonSpring Data JPA Stream-Abfragemethoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!