JPA场景下能否仅单次调用数据库实现分页并获取结果集总数？

可以实现，但具体方式依赖你使用的JPA实现（如Hibernate、EclipseLink），或需要借助自定义查询/原生SQL。以下是几种可行方案：

1. Hibernate专属：ScrollableResults滚动查询 #

利用Hibernate的ScrollableResults，在一次查询中先获取总行数，再定位到分页位置取数据：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<YourEntity> query = cb.createQuery(YourEntity.class);
Root<YourEntity> root = query.from(YourEntity.class);
// 构建你的查询条件，例如：
Predicate whereClause = cb.equal(root.get("status"), "ACTIVE");
query.where(whereClause);

// 开启滚动模式查询
Query jpaQuery = entityManager.createQuery(query);
ScrollableResults scrollableResults = jpaQuery.unwrap(org.hibernate.query.Query.class)
        .scroll(ScrollMode.SCROLL_INSENSITIVE);

// 获取总行数：滚动到最后一行，取行号+1
scrollableResults.last();
int totalCount = scrollableResults.getRowNumber() + 1;

// 滚动回分页起始位置，读取分页数据
scrollableResults.beforeFirst();
scrollableResults.scroll(page * pageSize);
List<YourEntity> pageData = new ArrayList<>();
for (int i = 0; i < pageSize && scrollableResults.next(); i++) {
    pageData.add((YourEntity) scrollableResults.get(0));
}

// 关闭资源
scrollableResults.close();

注意：该方案依赖Hibernate私有API，非JPA标准；大数据集下滚动到最后一行的性能可能不如单独的count查询，需根据场景权衡。

2. JPA标准兼容：子查询+自定义DTO #

通过构造包含总数的子查询，将总数与分页数据封装到同一个DTO中，实现单次数据库调用：

CriteriaBuilder cb = entityManager.getCriteriaBuilder();

// 1. 构建统计总数的子查询（复用主查询条件）
CriteriaQuery<Long> countQuery = cb.createQuery(Long.class);
Root<YourEntity> countRoot = countQuery.from(YourEntity.class);
Predicate whereClause = cb.equal(countRoot.get("status"), "ACTIVE");
countQuery.select(cb.count(countRoot)).where(whereClause);

// 2. 主查询返回包含数据和总数的DTO
CriteriaQuery<ResultWithCount> mainQuery = cb.createQuery(ResultWithCount.class);
Root<YourEntity> mainRoot = mainQuery.from(YourEntity.class);
mainQuery.where(whereClause)
        .select(cb.construct(ResultWithCount.class,
                mainRoot.get("id"),
                mainRoot.get("name"),
                countQuery)) // 嵌入总数子查询
        .setFirstResult(page * pageSize)
        .setMaxResults(pageSize);

List<ResultWithCount> results = entityManager.createQuery(mainQuery).getResultList();
// 提取总数（所有结果的总数一致，取第一条即可）
Long totalCount = results.isEmpty() ? 0L : results.get(0).getTotalCount();
// 转换为业务实体列表
List<YourEntity> pageData = results.stream()
        .map(r -> new YourEntity(r.getId(), r.getName()))
        .toList();

对应的DTO类：

public class ResultWithCount {
    private Long id;
    private String name;
    private Long totalCount;

    // 构造函数需与查询中字段顺序完全匹配
    public ResultWithCount(Long id, String name, Long totalCount) {
        this.id = id;
        this.name = name;
        this.totalCount = totalCount;
    }

    // getter方法
    public Long getTotalCount() { return totalCount; }
    public Long getId() { return id; }
    public String getName() { return name; }
}

注意：数据库实际执行主查询+嵌入子查询，属于单次调用，但复杂条件下子查询的性能需测试验证。

3. 通用方案：原生SQL联合查询 #

通过原生SQL的UNION ALL合并总数查询与分页数据查询，兼容所有JPA实现：

-- 先查总数，再查分页数据，用type字段区分结果类型
SELECT 'COUNT' AS type, COUNT(*) AS total, NULL AS id, NULL AS name 
FROM your_table 
WHERE status = 'ACTIVE'

UNION ALL

SELECT 'DATA' AS type, NULL AS total, id, name 
FROM your_table 
WHERE status = 'ACTIVE' 
LIMIT :offset, :pageSize

JPA中映射结果的代码：

String sql = "-- 上述原生SQL";
Query nativeQuery = entityManager.createNativeQuery(sql, ResultWithCount.class);
nativeQuery.setParameter("offset", page * pageSize);
nativeQuery.setParameter("pageSize", pageSize);
List<ResultWithCount> results = nativeQuery.getResultList();

// 分离总数与分页数据
Long totalCount = results.stream()
        .filter(r -> "COUNT".equals(r.getType()))
        .findFirst()
        .map(ResultWithCount::getTotal)
        .orElse(0L);
List<YourEntity> pageData = results.stream()
        .filter(r -> "DATA".equals(r.getType()))
        .map(r -> new YourEntity(r.getId(), r.getName()))
        .toList();

注意：需根据数据库语法调整LIMIT等关键字（如MySQL用LIMIT，Oracle用ROWNUM），但兼容性最强。

关键权衡点 #

• 单次调用减少了数据库交互次数，但大数据集下，滚动查询/子查询的性能可能不如两次独立查询（尤其是count查询可利用索引优化），需结合实际场景测试。
• 不同JPA实现有专属扩展（如EclipseLink的FETCH COUNT），可参考对应官方文档获取更优方案。

内容的提问来源于stack exchange，提问作者maria_so