Kaedah Pertanyaan Strim JPA Data Spring

pengenalan

Secara tradisinya, mengambil sejumlah besar data boleh membebankan sumber memori, kerana ia selalunya melibatkan pemuatan keseluruhan set hasil ke dalam memori.

=> Kaedah pertanyaan strim menawarkan penyelesaian dengan menyediakan cara untuk memproses data secara berperingkat menggunakan Java 8 Streams. Ini memastikan bahawa hanya sebahagian daripada data disimpan dalam ingatan pada bila-bila masa, meningkatkan prestasi dan kebolehskalaan.

Dalam catatan blog ini, kami akan mendalami cara kaedah pertanyaan strim berfungsi dalam Spring Data JPA, meneroka kes penggunaannya dan menunjukkan pelaksanaannya.

Untuk panduan ini, kami menggunakan:

• IDE: IntelliJ IDEA (disyorkan untuk aplikasi Spring) atau Eclipse
• Versi Java: 17
• Spring Data JPA Versi: 2.7.x atau lebih tinggi (serasi dengan Spring Boot 3.x)

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-jpa</artifactid>
</dependency>

NOTA: Untuk contoh yang lebih terperinci, sila lawati repositori GitHub saya di sini

1. Apakah Kaedah Pertanyaan Strim?

Kaedah pertanyaan strim dalam Spring Data JPA membolehkan kami mengembalikan hasil pertanyaan sebagai Strim dan bukannya Senarai atau jenis koleksi lain. Pendekatan ini memberikan beberapa faedah:

• Pengurusan Sumber yang Cekap: Data diproses secara berperingkat, mengurangkan overhed memori.

• Malas Memproses: Keputusan diambil dan diproses atas permintaan, yang sesuai untuk senario seperti penomboran atau pemprosesan kelompok.

• Integrasi dengan Pengaturcaraan Fungsian: Strim sesuai dengan ciri pengaturcaraan berfungsi Java, membolehkan operasi seperti penapis, peta dan pengumpulan.

2. Bagaimana Untuk Menggunakan Kaedah Pertanyaan Strim?

=> Bayangkan kita sedang membangunkan aplikasi e-dagang dan ingin:

• Dapatkan semula semua pelanggan yang membuat pesanan selepas tarikh tertentu.
• Tapis pesanan dengan jumlah keseluruhan melebihi jumlah tertentu yang disediakan.
• Kumpulkan pelanggan mengikut jumlah nilai pesanan mereka dalam tempoh 6 bulan yang lalu.
• Kembalikan data sebagai ringkasan nama pelanggan dan jumlah nilai pesanan mereka.

Entiti

• Pelanggan: Mewakili pelanggan.

@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;
}
</order>

• Pesanan: Mewakili pesanan yang dibuat oleh pelanggan.

@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;
}

Repositori

• CustomerRepository digunakan untuk memilih pelanggan dan pesanan berkaitan mereka dibuat selepas tarikh tertentu. Dan kami menggunakan Stream bukannya Senarai untuk mengendalikan hasil pertanyaan.

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);
}
</customer></customer>

NOTA:

• JOIN FETCH memastikan pesanan dimuatkan dengan penuh semangat.

• @QueryHints yang digunakan untuk memberikan pembayang tambahan kepada JPA menyediakan (cth. Hibernate) untuk mengoptimumkan pelaksanaan pertanyaan.

=> Contohnya, apabila pertanyaan saya mengembalikan 100 rekod:

• 25 rekod pertama diambil dan diproses oleh aplikasi.
• Setelah diproses, 25 rekod seterusnya akan diambil, dan seterusnya, sehingga kesemua 100 rekod diproses.
• Tingkah laku ini meminimumkan penggunaan memori dan mengelakkan memuatkan kesemua 100 rekod ke dalam memori sekaligus.

Perkhidmatan

<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-data-jpa</artifactid>
</dependency>

Berikut ialah kelas perkhidmatan untuk memproses data dengan dua parameter startDate dan minOrderAmount. Seperti yang anda lihat, kami tidak menapis dengan menggunakan pertanyaan sql dan memuatkan semua data sebagai strim kemudian menapis dan mengumpulkan mengikut kod Java kami.

Pengawal

@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;
}
</order>

Ujian

=> Untuk membuat data untuk ujian, anda boleh melaksanakan skrip berikut di dalam kod sumber saya atau menambah sendiri.

src/main/resources/dummy-data.sql

Permintaan:

• Tarikh mula: 2024-05-01T00:00:00
• minAmaun Pesanan: 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;
}

Jawapan:

• Pulangan semua pelanggan dengan jumlah amaun mereka yang sama atau lebih besar daripada minOrderAmount.

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);
}
</customer></customer>

3. Strim vs Senarai

=> Anda boleh menggunakan IntelliJ Profiler untuk memantau penggunaan memori dan masa pelaksanaan. Untuk butiran lanjut tentang cara menambah dan menguji dengan set data yang besar, anda boleh temui dalam repositori GitHub saya

Set Data Kecil: (10 pelanggan, 100 pesanan)

• Strim: Masa pelaksanaan (~5ms), Penggunaan memori (Rendah)
• Senarai: Masa pelaksanaan (~4ms), Penggunaan memori (Rendah)

Set Data Besar (10.000 pelanggan, 100.000 pesanan)

• Strim: Masa pelaksanaan (~202ms), Penggunaan memori (Sederhana)
• Senarai: Masa pelaksanaan (~176ms), Penggunaan memori (Tinggi)

Metrik Prestasi

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

Membungkus

Kaedah pertanyaan aliran JPA Data Musim Bunga menawarkan cara yang elegan untuk memproses set data yang besar dengan cekap sambil memanfaatkan kuasa Java Stream. Dengan memproses data secara berperingkat, ia mengurangkan penggunaan memori dan menyepadukan dengan lancar dengan paradigma pengaturcaraan berfungsi moden.

Apakah pendapat anda tentang kaedah pertanyaan strim? Kongsi pengalaman dan kes penggunaan anda dalam ulasan di bawah!

Jumpa anda dalam siaran seterusnya. Selamat Mengekod!

Atas ialah kandungan terperinci Kaedah Pertanyaan Strim JPA Data Spring. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!