当前位置：首页 > 文章列表 > 文章 > java教程 > Java分页查询实现方法与代码示例

Java分页查询实现方法与代码示例

2025-07-22 10:15:14 0浏览收藏

本篇文章给大家分享《Java分页查询实现与代码示例》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

Java中实现分页查询的核心在于利用数据库的物理分页机制，如LIMIT和OFFSET，并结合PageRequest和Page类进行参数封装与结果返回。1. 定义PageRequest类用于封装pageNum和pageSize，并提供计算offset的方法；2. 在DAO层使用JDBC或MyBatis等技术将分页参数拼接到SQL语句中执行；3. 提供countTotalEntities方法获取总记录数；4. 在服务层通过Page类封装分页结果，包括内容、总数、总页数等信息；5. 使用Spring Data JPA时可通过Pageable接口简化分页操作。分页查询在大型应用中至关重要，原因包括：1. 减少单次查询数据量，提高系统性能；2. 提升用户体验，加快页面响应速度；3. 缓解数据库压力，避免资源耗尽；4. 降低服务器资源消耗，优化成本控制。常见的Java分页策略分为物理分页和逻辑分页，其中物理分页更高效，推荐使用LIMIT/OFFSET、ROWNUM、TOP/OFFSET FETCH等数据库特性结合JDBC、MyBatis或Spring Data JPA实现；而逻辑分页则适用于数据量小且变化不频繁的场景。分页查询可能遇到的性能陷阱及优化建议有：1. 大偏移量导致效率下降，可采用基于游标的分页方式；2. COUNT(*)查询开销大，可通过缓存总数、估算总数或异步加载解决；3. 查询性能差需创建合适索引，避免在索引列上使用函数；4. 数据库连接池配置不当应合理设置连接池大小并监控状态。

如何在Java中实现分页查询 Java分页逻辑与实现示例

Java中实现分页查询，核心在于限定每次从数据库或数据源中获取的数据量，通常通过SQL的LIMIT和OFFSET（或类似机制）结合后端逻辑来完成，确保高效加载并优化用户体验。这不仅仅是数据截取，更是对系统资源和用户体验的综合考量。

解决方案

在Java中实现分页查询，通常涉及后端数据层（DAO/Repository）和业务逻辑层。最常见的做法是利用数据库自身的物理分页能力。

首先，定义一个承载分页参数的类，例如PageRequest：

public class PageRequest {
    private int pageNum;  // 当前页码，从1开始
    private int pageSize; // 每页大小

    public PageRequest(int pageNum, int pageSize) {
        if (pageNum < 1) this.pageNum = 1; // 确保页码不小于1
        else this.pageNum = pageNum;
        if (pageSize < 1) this.pageSize = 10; // 默认每页10条
        else this.pageSize = pageSize;
    }

    public int getOffset() {
        return (pageNum - 1) * pageSize; // 计算偏移量
    }

    public int getPageNum() { return pageNum; }
    public int getPageSize() { return pageSize; }
}

接着，在数据访问层（如使用JDBC或MyBatis），将分页参数传入SQL查询：

// 假设这是DAO层的一个方法
public List<YourEntity> findPagedEntities(PageRequest pageRequest) {
    List<YourEntity> entities = new ArrayList<>();
    // 假设使用JDBC连接
    String sql = "SELECT * FROM your_table ORDER BY id LIMIT ? OFFSET ?"; // MySQL/PostgreSQL示例
    // 或者对于Oracle: SELECT * FROM (SELECT ROWNUM rn, t.* FROM your_table t) WHERE rn BETWEEN ? AND ?;
    // 或者对于SQL Server: SELECT * FROM your_table ORDER BY id OFFSET ? ROWS FETCH NEXT ? ROWS ONLY;

    try (Connection conn = DriverManager.getConnection("jdbc:your_db_url");
         PreparedStatement ps = conn.prepareStatement(sql)) {

        ps.setInt(1, pageRequest.getPageSize()); // LIMIT
        ps.setInt(2, pageRequest.getOffset());   // OFFSET

        ResultSet rs = ps.executeQuery();
        while (rs.next()) {
            // 将ResultSet映射到YourEntity对象
            YourEntity entity = new YourEntity();
            // ... 设置实体属性 ...
            entities.add(entity);
        }
    } catch (SQLException e) {
        // 异常处理
        e.printStackTrace();
    }
    return entities;
}

// 同时，还需要一个方法获取总记录数，用于计算总页数
public long countTotalEntities() {
    long total = 0;
    String sql = "SELECT COUNT(*) FROM your_table";
    try (Connection conn = DriverManager.getConnection("jdbc:your_db_url");
         PreparedStatement ps = conn.prepareStatement(sql);
         ResultSet rs = ps.executeQuery()) {
        if (rs.next()) {
            total = rs.getLong(1);
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return total;
}

最后，在业务逻辑层或服务层组装分页结果，通常封装成一个Page对象：

public class Page<T> {
    private List<T> content;
    private long totalElements;
    private int totalPages;
    private int pageNum;
    private int pageSize;

    public Page(List<T> content, long totalElements, int pageNum, int pageSize) {
        this.content = content;
        this.totalElements = totalElements;
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.totalPages = (int) Math.ceil((double) totalElements / pageSize);
    }

    // Getters...
}

// 服务层示例
public Page<YourEntity> getEntitiesByPage(int pageNum, int pageSize) {
    PageRequest pageRequest = new PageRequest(pageNum, pageSize);
    List<YourEntity> entities = findPagedEntities(pageRequest); // 调用DAO方法
    long total = countTotalEntities(); // 调用DAO方法获取总数
    return new Page<>(entities, total, pageNum, pageSize);
}

对于Spring Data JPA，实现会更简洁，因为它提供了Pageable接口和PagingAndSortingRepository，极大地简化了分页操作。你只需要在Repository接口中定义方法，并传入Pageable参数即可。

为什么分页查询在大型应用中不可或缺？

在我看来，分页查询在任何数据量稍大的应用中都不仅仅是“好用”，它简直是“救命”的存在。我记得几年前，一个同事在没有分页的情况下尝试从数据库拉取上百万条记录到内存进行处理，结果可想而知——内存溢出，服务直接崩溃。那次经历让我深刻认识到，分页绝不是可有可无的优化，它是构建健壮、高性能系统的基石。

首先，从性能角度看，分页能显著减少单次查询的数据量。一次性从数据库中取出几十万、上百万条记录，不仅数据库执行效率低下，网络传输也会成为瓶颈，更别提后端服务器需要耗费大量内存来存储这些数据，极易导致内存溢出或GC频繁，影响整个应用的稳定性。

其次，用户体验是另一个核心驱动力。没有人愿意等待一个页面加载几十秒甚至几分钟。分页将海量数据切割成用户可接受的小块，每次只加载当前页的数据，页面响应速度快，用户可以流畅地浏览、翻页，大大提升了使用感受。想象一下，一个电商网站，如果商品列表不分页，用户可能还没看到第一个商品，浏览器就卡死了。

再者，对数据库压力的缓解作用也十分明显。数据库的资源是有限的，如果大量用户同时进行全表查询，很容易耗尽数据库的CPU、内存和I/O资源，导致整个数据库集群性能下降甚至瘫痪。分页查询将大查询拆分成小查询，降低了单次查询的资源消耗，提高了数据库的并发处理能力。

最后，它也优化了服务器资源消耗。服务器不再需要为每个请求缓存或处理海量数据，从而降低了内存、CPU和网络带宽的占用。这对于云原生环境下的弹性伸缩和成本控制尤为重要。所以，分页不仅仅是技术实现，它更是一种深思熟虑的架构设计和产品体验考量。

常见的Java分页实现策略有哪些？

在Java中实现分页，策略主要分为两大类：物理分页和逻辑分页。我个人绝大部分时间都倾向于使用物理分页，因为它更高效、更符合数据库处理数据的本质。

1. 物理分页（Physical Pagination）

这是最主流、最推荐的方式，其核心思想是在数据库层面就限定返回的数据量。Java应用只负责构建正确的查询语句并接收结果。

数据库层面的实现：

LIMIT 和 OFFSET (MySQL, PostgreSQL, SQLite): 这是我最常用的一种，直观且高效。

SELECT * FROM products ORDER BY id ASC LIMIT 10 OFFSET 20;
-- 含义：从第20条记录开始（不包含），取10条记录。
-- Java代码中：LIMIT pageSize OFFSET (pageNum - 1) * pageSize

ROWNUM (Oracle): Oracle早期版本常用的分页方式，通常结合子查询实现。

SELECT * FROM (
    SELECT t.*, ROWNUM rn FROM your_table t WHERE ROWNUM <= (pageNum * pageSize)
) WHERE rn > ((pageNum - 1) * pageSize);

TOP 和 OFFSET FETCH (SQL Server 2012+): SQL Server的新式分页语法，非常清晰。

SELECT * FROM your_table ORDER BY id OFFSET 20 ROWS FETCH NEXT 10 ROWS ONLY;
-- 含义：跳过20行，然后获取接下来的10行。

Java后端集成：
- JDBC原生： 如前面“解决方案”部分所示，通过PreparedStatement设置参数。
- MyBatis/Hibernate等ORM框架： 这些框架通常提供了对数据库分页语法的抽象和支持。例如，MyBatis可以通过配置分页插件（如PageHelper）实现无侵入式分页；Hibernate则通过setFirstResult()和setMaxResults()方法。
- Spring Data JPA： 这是我日常开发中使用最多的，它通过Pageable接口和PagingAndSortingRepository极大地简化了分页操作。你只需要在Repository方法签名中传入Pageable参数，Spring Data JPA会自动处理底层数据库的分页逻辑。
```
// Repository接口
public interface UserRepository extends PagingAndSortingRepository<User, Long> {
    Page<User> findByEmailContaining(String email, Pageable pageable);
}

// Service层调用
Pageable pageable = PageRequest.of(0, 10, Sort.by("id").descending()); // 页码从0开始
Page<User> userPage = userRepository.findByEmailContaining("example.com", pageable);
List<User> users = userPage.getContent();
long totalUsers = userPage.getTotalElements();
```
  这种方式的优点是代码简洁，将分页逻辑下沉到框架和数据库层面，业务代码无需关心具体的SQL分页语法。

2. 逻辑分页（Logical Pagination）/ 内存分页

这种方式是先将所有符合条件的数据一次性从数据库中取出到内存，然后在Java代码中进行截取和分页。

实现方式：

public List<YourEntity> getAllEntitiesInMemory() {
    // ... 从数据库查询所有符合条件的记录 ...
    return allEntities;
}

public List<YourEntity> getPagedEntitiesInMemory(int pageNum, int pageSize) {
    List<YourEntity> allEntities = getAllEntitiesInMemory();
    int startIndex = (pageNum - 1) * pageSize;
    int endIndex = Math.min(startIndex + pageSize, allEntities.size());

    if (startIndex >= allEntities.size()) {
        return Collections.emptyList(); // 超出范围
    }
    return allEntities.subList(startIndex, endIndex);
}

适用场景与缺点：
- 适用场景： 仅适用于数据量非常小（比如几十条、几百条）且数据变化不频繁的情况，或者数据已经存在于缓存中，无需再次查询数据库。例如，一个固定的配置项列表。
- 缺点： 这种方式的缺点是显而易见的——它会一次性加载所有数据到内存，对于大数据量而言，会造成严重的内存消耗、GC压力，并带来巨大的网络传输开销和数据库查询压力。我个人在实际项目中几乎不会采用这种方式，因为它通常意味着在架构设计上存在问题，把数据库的活儿搬到了应用层。

总的来说，物理分页是处理绝大多数分页需求的黄金标准，而逻辑分页则应慎之又慎，仅在特定、数据量极小的场景下作为备选。

分页查询中可能遇到的性能陷阱与优化建议

分页查询虽然解决了大数据的展示问题，但如果不加注意，也可能引入新的性能瓶颈。我踩过一些坑，也总结了一些经验，这些“陷阱”和“银弹”值得分享。

1. OFFSET 大偏移量问题

这是最常见也最容易被忽视的性能陷阱。当使用LIMIT M OFFSET N（或类似语法）进行分页时，随着页码N的增大，数据库可能需要扫描N + M条记录，然后丢弃前面的N条，只返回M条。这意味着，你翻到第1000页时，数据库可能已经扫描了数十万甚至上百万条记录，效率会急剧下降。我记得有一次，用户抱怨一个列表翻到后面几页就巨慢，排查后发现就是这个OFFSET惹的祸。

优化建议：基于游标/最后ID的分页（Cursor-based / Keyset Pagination） 这是解决大偏移量问题的“银弹”。它的核心思想不是“跳过N条”，而是“从上次查询的最后一条记录之后开始取M条”。例如：SELECT * FROM your_table WHERE id > [last_id_from_previous_page] ORDER BY id ASC LIMIT 10; 这种方式利用了索引的有序性，数据库可以直接定位到last_id之后的位置，避免了全表扫描或大量跳过操作。
- 优点： 性能稳定，不受页码深度影响。
- 缺点： 需要一个稳定的排序字段（通常是主键ID或时间戳），且只能“下一页”，无法直接跳转到任意页码。前端实现上会稍微复杂一些，通常只提供“下一页”和“上一页”功能，或者记录已加载的游标点。但在大数据量场景下，性能的提升是质的飞跃。

2. 总记录数查询开销

每次分页查询时，为了显示总页数，我们通常会执行一个SELECT COUNT(*)查询。对于拥有数百万甚至上亿记录的大表，COUNT(*)操作可能会非常耗时，因为它通常需要扫描整个表或索引。

优化建议：
- 缓存总数： 如果数据变化不频繁，可以定期将COUNT(*)的结果缓存起来（例如，放入Redis或内存），减少数据库查询次数。
- 估算总数/不显示精确总数： 对于超大表，可以考虑不显示精确的总记录数或总页数。只显示“下一页”按钮，或者只提供一个大致的数字（例如“超过1000条”）。很多大型社交媒体或新闻网站就采取了这种策略，因为用户更关心内容本身，而不是精确的数字。
- 异步加载总数： 可以先加载第一页数据，然后异步地去查询总记录数，等总数查询完成后再更新页面上的总页数信息。

3. 慢查询与索引缺失

任何查询，包括分页查询，如果其WHERE子句或ORDER BY子句涉及的字段没有合适的索引，都可能导致全表扫描，从而严重影响性能。

优化建议：
- 创建合适的索引： 确保所有用于过滤（WHERE子句）和排序（ORDER BY子句）的字段都有合适的索引。特别是ORDER BY的字段，如果能与LIMIT/OFFSET结合形成覆盖索引，效果更佳。
- 复合索引： 如果WHERE和ORDER BY涉及多个字段，考虑创建复合索引，并注意索引中字段的顺序。
- 避免在索引列上使用函数： 例如，WHERE DATE(create_time) = '2023-01-01'会使create_time上的索引失效。应改为WHERE create_time >= '2023-01-01 00:00:00' AND create_time < '2023-01-02 00:00:00'。