使用JPA和Hibernate查询分页

最新推荐文章于 2024-05-10 15:18:23 发布
最新推荐文章于 2024-05-10 15:18:23 发布
阅读量826 收藏 2
点赞数
文章标签： hibernate 数据库 postgresql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/allway2/article/details/128177430
版权

介绍

受到我最近给出的StackOverflow答案的启发，我决定是时候写一篇关于使用JPA和Hibernate时查询分页的文章了。

在本文中，您将了解如何使用查询分页来限制 JDBC大小并避免获取不必要的数据。ResultSet

如何在#Hibernate中使用查询分页来限制 JDBC 结果集的大小并避免获取不必要的数据。@vlad_mihalceahttps://t.co/fkd8ne1mYjpic.twitter.com/Ca78OhlIP1

— Java （@java） 2018 年 10 月 12 日

域模型

现在，假设我们在应用程序中定义了以下实体类：PostPostComment

类是父实体，而子实体是子实体，因为它与实体有关联。两个实体都实现了提供用于访问基础实体标识符的协定的接口。PostPostComment@ManyToOnePostIdentifiable

接下来，我们将在数据库中保存以下内容和实体：PostPostComment

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
LocalDateTime timestamp = LocalDateTime.of(
    2018, 10, 9, 12, 0, 0, 0
);
 
int commentsSize = 5;
 
LongStream.range(1, 50).forEach(postId -> {
    Post post = new Post();
    post.setId(postId);
    post.setTitle(
        String.format("Post nr. %d", postId)
    );
    post.setCreatedOn(
         Timestamp.valueOf(
            timestamp.plusMinutes(postId)
        )
    );
 
    LongStream.range(1, commentsSize + 1).forEach(commentOffset -> {
        long commentId = ((postId - 1) * commentsSize) + commentOffset;
 
        PostComment comment = new PostComment();       
        comment.setId(commentId);
        comment.setReview(
            String.format("Comment nr. %d", comment.getId())
        );
        comment.setCreatedOn(
            Timestamp.valueOf(
                timestamp.plusMinutes(commentId)
            )
        );
 
        post.addComment(comment);
 
    });
     
    entityManager.persist(post);
});

限制结果集大小

为了限制基础查询大小，JPA接口提供了setMaxResults方法。ResultSetQuery

因此，在执行以下 JPQL 查询时：

1
2
3
4
5
6
7
8
9
10
11
List<Post> posts = entityManager
.createQuery(
    "select p " +
    "from Post p " +
    "order by p.createdOn ")
.setMaxResults(10)
.getResultList();
 
assertEquals(10, posts.size());
assertEquals("Post nr. 1", posts.get(0).getTitle());
assertEquals("Post nr. 10", posts.get(9).getTitle());

Hibernate在PostgreSQL上生成以下SQL语句：

1
2
3
4
5
6
SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
LIMIT 10

在 SQL Server 2012（或更高版本）上，Hibernate 将执行以下 SQL 查询：

1
2
3
4
5
6
SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
OFFSET 0 ROWS FETCH NEXT 10 ROWS ONLY

因此，SQL 分页查询适用于基础数据库引擎功能。

使用查询分页时，使用 of 是强制性的，因为 SQL 不保证任何特定的顺序，除非我们通过子句提供一个。ORDER BYORDER BY

使用偏移来定位结果集

如果上一个查询是给定分页查询的第一页的典型查询，则导航下一页需要将结果集定位在最后一页结束的位置。为此，JPA接口提供了setFirstResult方法。Query

1
2
3
4
5
6
7
8
9
10
11
12
List<Post> posts = entityManager
.createQuery(
    "select p " +
    "from Post p " +
    "order by p.createdOn ")
.setFirstResult(10)
.setMaxResults(10)
.getResultList();
 
assertEquals(10, posts.size());
assertEquals("Post nr. 11", posts.get(0).getTitle());
assertEquals("Post nr. 20", posts.get(9).getTitle());

在 PostgreSQL 上运行之前的 JPQL 查询时，Hibernate 执行以下 SQL SELECT 语句：

1
2
3
4
5
6
7
SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
LIMIT 10
OFFSET 10

在 SQL Server 2012（或更高版本）上，Hibernate 将生成以下 SQL 查询：

1
2
3
4
5
6
SELECT p.id AS id1_0_,
       p.created_on AS created_2_0_,
       p.title AS title3_0_
FROM post p
ORDER BY p.created_on
OFFSET 10 ROWS FETCH NEXT 10 ROWS ONLY

DTO投影查询

JPA 查询分页不限于仅返回实体的实体查询。您也可以将其用于DTO投影。

假设我们有以下DTO：PostCommentSummary

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class PostCommentSummary {
 
    private Number id;
    private String title;
    private String review;
 
    public PostCommentSummary(
            Number id,
            String title,
            String review) {
        this.id = id;
        this.title = title;
        this.review = review;
    }
 
    public PostCommentSummary() {}
 
    //Getters omitted for brevity
}

运行以下 DTO 投影查询时：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
List<PostCommentSummary> summaries = entityManager
.createQuery(
    "select new " +
    "   com.vladmihalcea.book.hpjp.hibernate.fetching.PostCommentSummary( " +
    "       p.id, p.title, c.review " +
    "   ) " +
    "from PostComment c " +
    "join c.post p " +
    "order by c.createdOn")
.setMaxResults(10)
.getResultList();
 
assertEquals(10, summaries.size());
assertEquals("Post nr. 1", summaries.get(0).getTitle());
assertEquals("Comment nr. 1", summaries.get(0).getReview());
 
assertEquals("Post nr. 2", summaries.get(9).getTitle());
assertEquals("Comment nr. 10", summaries.get(9).getReview());

Hibernate将分页子句附加到底层SQL查询：

1
2
3
4
5
6
7
SELECT p.id AS col_0_0_,
       p.title AS col_1_0_,
       c.review AS col_2_0_
FROM post_comment c
INNER JOIN post p ON c.post_id=p.id
ORDER BY c.created_on
LIMIT 10

有关使用 JPA 和 Hibernate 进行 DTO 投影的更多详细信息，请查看本文。

本机 SQL 查询

JPA 查询分页不限于实体查询，例如 JPQL 或条件 API。您也可以将其用于本机 SQL 查询。

1
2
3
4
5
6
7
8
9
10
11
12
List<Tuple> posts = entityManager
.createNativeQuery(
    "select p.id as id, p.title as title " +
    "from post p " +
    "order by p.created_on", Tuple.class)
.setFirstResult(10)
.setMaxResults(10)
.getResultList();
 
assertEquals(10, posts.size());
assertEquals("Post nr. 11", posts.get(0).get("title"));
assertEquals("Post nr. 20", posts.get(9).get("title"));

运行上述 SQL 查询时，Hibernate 会附加特定于 DB 的分页子句：

1
2
3
4
5
6
SELECT p.id AS id,
       p.title AS title
FROM post p
ORDER BY p.created_on
LIMIT 10
OFFSET 10

加入抓取和分页

但是，如果我们尝试在实体查询中使用子句，同时也使用 JPA 分页：JOIN FETCH

1
2
3
4
5
6
7
8
9
List<Post> posts = entityManager.createQuery(
    "select p " +
    "from Post p " +
    "left join fetch p.comments " +
    "order by p.createdOn", Post.class)
.setMaxResults(10)
.getResultList();
 
assertEquals(10, posts.size());

休眠将发出以下警告消息：

1
HHH000104: firstResult/maxResults specified with collection fetch; applying in memory!

并且执行的 SQL 查询将缺少分页子句：

1
2
3
4
5
6
7
8
9
10
11
12
SELECT p.id AS id1_0_0_,
       c.id AS id1_1_1_,
       p.created_on AS created_2_0_0_,
       p.title AS title3_0_0_,
       c.created_on AS created_2_1_1_,
       c.post_id AS post_id4_1_1_,
       c.review AS review3_1_1_,
       c.post_id AS post_id4_1_0__,
       c.id AS id1_1_0__
FROM post p
LEFT OUTER JOIN post_comment c ON p.id=c.post_id
ORDER BY p.created_on

这是因为 Hibernate 希望完全获取实体及其集合，如子句所示，而 SQL 级分页可能会截断可能使父实体在集合中具有较少元素。JOIN FETCHResultSetPostcomments

警告的问题在于Hibernate将获取andentities的乘积，并且由于结果集的大小，查询响应时间将很长。HHH000104PostPostComment

为了解决此限制，您必须使用窗口函数查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
List<Post> posts = entityManager
.createNativeQuery(
    "select * " +
    "from (   " +
    "    select *, dense_rank() OVER (ORDER BY post_id) rank " +
    "    from (   " +
    "        select p.*, pc.* " +
    "        from post p  " +
    "        left join post_comment pc on p.id = pc.post_id  " +
    "        order by p.created_on " +
    "    ) p_pc " +
    ") p_pc_r " +
    "where p_pc_r.rank <= :rank", Post.class)
.setParameter("rank", 10)
.unwrap(NativeQuery.class)
.addEntity("p", Post.class)
.addEntity("pc", PostComment.class)
.setResultTransformer(DistinctPostResultTransformer.INSTANCE)
.getResultList();

有关使用窗口函数修复问题及其代码的更多详细信息，请查看本文。HHH000104DistinctPostResultTransformer

为什么不改用查询流式处理？

JPA 2.2 添加了该方法，您可能认为它是分页的有效替代方案。但是，流结果不会向查询计划程序提供结果集大小，因此可能会选择次优的执行计划。因此，在获取少量数据时，使用分页比流式传输更有效。getResultStreamQuery

有关为什么分页比流式传输更有效的更多详细信息，请查看本文。

键集分页

Markus Winand撰写了《SQL Performance Explained》一书，他提倡使用Keyset分页而不是Offset。尽管偏移分页是 SQL 标准功能，但有两个原因让您更喜欢密钥集分页：

  • 性能（索引必须扫描到偏移量，而对于键集分页，我们可以直接转到按谓词和过滤条件匹配顺序的第一个索引条目）
  • 正确性（如果在两者之间添加元素，偏移分页将无法提供一致的读取）

即使 Hibernate 不支持键集分页，您也可以使用本机 SQL 查询来实现此目的。

结论

获取所需数量的数据是数据访问性能方面最重要的技巧之一。提取数据时，分页允许您控制结果集大小，以便即使基础数据集随时间增长，性能也保持稳定。

虽然键集分页为大型结果集提供了更好的性能，但如果您可以使用正确的过滤谓词缩小扫描的数据集，则偏移分页的性能将相当好。为了获得一致的读取，您必须确保扫描的数据集始终以这样一种方式进行排序，即新条目附加到集的末尾，而不是混合在旧条目之间。

allway2
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate-分页查询
xiaohahaaa的博客
06-18 111
分页查询的目的：可以减少每次查询的内容，加快响应速度。 具体代码如下： Query query=session.createQuery("from User"); List users=query.list(); Number pageCount = users.size() / 3; int pageSize = (int) pageCount + 1; //分页页数 for (int i = 0; i < pageSize ; i++) { Sy
Spring JPA 实现动态SQL查询及分页
Li_Zhongxin的博客
07-31 1361
spring JPA优雅的动态sql语句查询
Hibernate 分页 查询
weixin_34407348的博客
12-15 202
 昨天的作业  分页： 主要的代码块：（明天实现分页的封装） 1 package com.cy.beans; 2 3 import java.util.List; 4 5 /** 6 * 定义一个分页对象 7 * @author acer 8 * 9 */ 10 public class Pager { 11 12 pr...
Java最全Springboot 快速学会使用 JPA 分页查询，百度java面试经验
最新发布
2401_84002542的博客
05-10 931
关于面试刷题也是有方法可言的，建议最好是按照专题来进行，然后由基础到高级，由浅入深来，效果会更好。Java基础部分算法与编程数据库部分流行的框架与新技术（Spring+SpringCloud+SpringCloudAlibaba）这份面试文档当然不止这些内容，实际上像JVM、设计模式、ZK、MQ、数据结构等其他部分的面试内容均有涉及，因为文章篇幅，就不全部在这里阐述了。
Hibernate查询——HQL，包括分页查询
weixin_44677005的博客
06-06 2102
hibernate查询 概述：数据查询与检索是Hibernate中的一个亮点。相对其他ORM实现而言，Hibernate提供了灵活多样的查询机制。 HQL ——(Hibernate Query Language)：Hibernate语言查询它是完全面向对象的查询语句，查询功能非常强大，具备继承、多态和关联等特性 。Hibernate官方推荐使用HQL进行查询。 QBC——(Query By Criteria)：标准化对象查询，以对象的方式进行查询，将查询语句封装为对象操作。优点：可读性好，符合Java 程序
使用entityManager做分页查询
s252294703的博客
05-20 5122
场景 jpa遇到查询条件不固定的情况下，使用原生sql查询可以解决这个问题 例子 接口类 @ApiOperation("PC端,根据条件查询审批分页数据") @GetMapping("/pc/getPageApproval") public Result<ResultPageVo<ApprovalPagePcVo>> getPageOfApprova...
在Spring Boot中使用Spring-data-jpa实现分页查询
08-29
Spring Boot中使用Spring Data JPA实现分页查询 在 Spring Boot 项目中，使用 Spring Data JPA 实现分页查询是一种非常常见的需求。下面我们将介绍如何使用 JPA 进行多条件查询以及查询列表分页。 首先，我们需要...
hibernate的分页模糊查询功能
08-31
在数据库操作中，分页主要是通过SQL的LIMIT和OFFSET关键字实现的，但在Hibernate中，我们不能直接使用这两个关键字，而是需要通过Query接口的setFirstResult和setMaxResults方法来设置查询的起始位置和每页数据的...
Jpa 原生SQL分页查询“一个别名引发的一场血案”
12-14
问题描述： 备注：刚开始SQL 没有加任何AS ... WITH query AS (SELECT inner_query.*, ROW_NUMBER() OVER (ORDER BY CURRENT_TIMESTAMP) as __hibernate_row_nr__ FROM 第二页 明显不一样的处理逻辑 select med.* fro
SpringBoot中使用Spring-data-jpa分页查询
04-27
使用SpringBoot和Spring-data-jpa进行分页查询可以大大简化编码流程并提高开发效率。 在使用Spring-data-jpa进行分页查询时，需要遵循以下步骤： 引入依赖 在pom.xml文件中加入spring-boot-starter-data-jpa依赖，...
JPA(hibernate) Dao 和 DaoSupport
04-13
在JPA和Hibernate中，可以使用`Page`或`Slice`接口（Spring Data提供）来实现分页查询，这些接口允许你指定页码和每页大小，返回结果包含当前页的数据以及总页数等信息。 2. **PageIndex.java** - 这个类可能是用于...
Java工作笔记-JPA中使用@query注解（分页查询实例）
12-14
运行截图如下： 这里对应的数据库内容如下： 此处的关键代码如下： 通过sql语句去做，这里nativeQuery = true，这样就可以使用原始的sql语句了 其实真实的分页是这样的：limit (page – 1) * size , size 因为limit后面不能接运算符，这里我们这service层处理： sql文件如下： CREATE DATABASE /*!32312 IF NOT EXISTS*/`jap_repository_demo` /*!40100 DEFAULT CHARACTER SET utf8 COLLATE utf8_unicode_ci */; USE
SpringBoot+Jpa+Hibernate（基础使用、原生SQL、分页查询、动态SQL）
Sid小杰的博客
06-10 7515
一、pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocatio...
JPA---Specifications
lanleihhh的博客
03-20 3332
/ 查询单个对象 Optional < T > findOne(@Nullable Specification < T > spec);// 查询列表 List < T > findAll(@Nullable Specification < T > spec);// 查询全部，分页；
使用jpa进行多表联查、分页
weixin_69411453的博客
11-14 926
首先dao层mapper继承。
【java】spring-data-jpa 集成hibernate实现多条件分页查询
a84480766的博客
11-04 144
初次接触spring-data-jpa，实现多条件分页查询。 基础环境 Spring Boot+spring-data-jpa+hibernate+mysql 1.接口 要继承这个接口，这个接口提供了多条件分页的方法。 public interface RjAuthuInfoRespository extends JpaRepository<Rj...
JPA Hibernate HQL limit 分页写法 Pageable PageRequest
wuyujin1997的博客
11-11 1896
Pageable 和 PageRequest 传参解决 要用到的两个API： org.springframework.data.domain.Pageable; org.sprineframework.data.domain.PapeRequest; StudentRepository.java import com.wuyujin.model.entity.Student; import org.springframework.data.domain.Pageable; import org.sprin
Hibernate的分页查询
温暖的博客
06-03 414
按条件进行分页查询：条件查询,分页查询 Dao层： public List getBranchProductWithPage(BaseQuery baseQuery) { DetachedCriteria criteria = DetachedCriteria.forClass(Article.class); criteria.addOrder(Order.desc("date"));
javax.persistence.Query和javax.persistence.EntityManager的分页查询使用
u010741112的博客
09-21 2666
javax.persistence.Query和javax.persistence.EntityManager都是JAP发布的接口，是用于对象持久化API。 EntityManager接口用于与持久化上下文交互。一个EntityManager实例与持久化上下文相关的。一个持久化上下文是一组中的实体实例的任何持久的实体的身份有一个独特的实体实例。在持久性上下文中，实体实例及其生命周期管理。这个EntityManagerAPI是用于创建和删除持久的实体实例，根据主键找到实体，并查询实体。实体可以通过一个给定的管
jpa分页连表查询hql
10-28
JPA分页连表查询HQL是指使用Hibernate Query Language(HQL)进行多表查询并进行分页操作。在使用JPA进行多表查询时，如果使用实体类进行查询，会导致多余的数据库查询，而使用HQL可以避免这种情况的发生。同时，使用HQL还可以直接进行分页操作，不需要使用countQuery。下面是一个简单的JPA分页连表查询HQL的示例： ``` String hql = "select new com.xxx.xxx(a.field1, b.field2) from EntityA a, EntityB b where a.id = b.aId"; Query query = entityManager.createQuery(hql); query.setFirstResult(pageable.getPageNumber() * pageable.getPageSize()); query.setMaxResults(pageable.getPageSize()); List<Object[]> resultList = query.getResultList(); List<VO> voList = new ArrayList<>(); for (Object[] result : resultList) { VO vo = new VO(); vo.setField1(result[0]); vo.setField2(result[1]); voList.add(vo); } return new PageImpl<>(voList, pageable, totalCount); ``` 其中，EntityA和EntityB是两个实体类，a.field1和b.field2是需要查询的字段，VO是一个值对象，用于封装查询结果。在查询时，使用了select new语句来创建VO对象，并使用setFirstResult和setMaxResults方法进行分页操作。最后，将查询结果封装到VO对象中，并返回一个Page对象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值