当前位置：首页 > 文章列表 > 文章 > java教程 > Spring Data JPA 流查询方法

Spring Data JPA 流查询方法

来源：dev.to 2024-11-20 19:51:54 0浏览收藏

哈喽！今天心血来潮给大家带来了《Spring Data JPA 流查询方法》，想必大家应该对文章都不陌生吧，那么阅读本文就都不会很困难，以下内容主要涉及到，若是你正在学习文章，千万别错过这篇文章~希望能帮助到你！

介绍

传统上，获取大量数据可能会导致内存资源紧张，因为它通常涉及将整个结果集加载到内存中。

=> 流查询方法通过提供一种使用 java 8 streams 增量处理数据的方法来提供解决方案。这可确保任何时候只有一部分数据保存在内存中，增强性能和可扩展性。

在这篇博文中，我们将深入研究流查询方法在 spring data jpa 中的工作原理，探索它们的用例，并演示它们的实现。

对于本指南，我们使用：


    org.springframework.boot
    spring-boot-starter-data-jpa

注意：有关更详细的示例，请访问我的 github 存储库

1.什么是流查询方式？

spring data jpa 中的流查询方法允许我们以 stream 的形式返回查询结果，而不是 list 或其他集合类型。这种方法有几个好处：

高效的资源管理：增量处理数据，减少内存开销。
延迟处理：按需获取和处理结果，非常适合分页或批处理等场景。
与函数式编程集成：流符合 java 的函数式编程特性，支持过滤、映射和收集等操作。

2.如何使用流查询方法？

=> 假设我们正在开发一个电子商务应用程序并希望：

实体

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

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

存储库

而不是 list 来处理查询结果。

public interface customerrepository extends jparepository {
    @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 findcustomerwithorders(@param("startdate") localdatetime startdate);
}

注意：

join fetch 确保订单被急切加载。
@queryhints 用于向 jpa（例如 hibernate）提供额外提示以优化查询执行。

=> 例如，当我的查询返回 100 条记录时：

服务

@service
@requiredargsconstructor
public class customerorderservice {
    private final customerrepository customerrepository;

    @transactional(readonly = true)
    public map getcustomerordersummary(localdatetime startdate, double minorderamount) {
        try (stream customerstream = customerrepository.findcustomerwithorders(startdate)) {
            return customerstream
                    // filter customers with orders above the threshold
                    .flatmap(customer -> customer.getorders().stream()
                            .filter(order -> order.getamount() >= minorderamount)
                            .map(order -> new abstractmap.simpleentry<>(customer.getname(), order.getamount())))
                    // group by customer name and sum order amounts
                    .collect(collectors.groupingby(
                            abstractmap.simpleentry::getkey,
                            collectors.summingdouble(abstractmap.simpleentry::getvalue)
                    ));
        }
    }
}

这里是处理数据的服务类，有两个参数startdate和minorderamount。正如您所看到的，我们不使用 sql 查询进行过滤，而是将所有数据作为流加载，然后通过 java 代码进行过滤和分组。

控制器

@restcontroller
@requestmapping("/customers")
@requiredargsconstructor
public class customerordercontroller {
    private final customerorderservice customerorderservice;

    @getmapping("/orders")
    public responseentity> getcustomerordersummary(
            @requestparam @datetimeformat(iso = datetimeformat.iso.date_time) localdatetime startdate,
            @requestparam double minorderamount
    ) {
        map ordersummary = customerorderservice.getcustomerordersummary(startdate, minorderamount);
        return responseentity.ok(ordersummary);
    }
}

测试

=> 要创建测试数据，您可以在我的源代码中执行以下脚本或自己添加。

src/main/resources/dummy-data.sql

请求：

curl --location 'http://localhost:8090/customers/orders?startdate=2024-05-01t00%3a00%3a00&minorderamount=100'

回应：

{
  "Jane Roe": 500.0,
  "John Doe": 150.0,
  "Bob Brown": 350.0,
  "Alice Smith": 520.0
}

3. 流与列表

=> 您可以使用 intellij profiler 监控内存使用情况和执行时间。有关如何添加和测试大数据集的更多详细信息，您可以在我的 github 存储库中找到

小数据集：（10 个客户，100 个订单）

大型数据集（10.000 个客户，100.000 个订单）

性能指标

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