掌握Java分页技术：从数据库到UI的完整页数代码实现指南261

在现代企业级应用开发中，数据量往往是巨大的。无论是后台管理系统、电商平台还是内容发布网站，直接向用户展示所有数据几乎是不可能的，这不仅会导致页面加载缓慢、服务器资源消耗过大，还会严重影响用户体验。此时，“分页”技术应运而生，它允许我们将大量数据拆分成若干个可管理的页面，按需加载和显示。对于Java开发者而言，无论是处理数据库查询结果、处理内存中的集合，还是构建前端交互，掌握高效且健壮的“页数代码”实现至关重要。

本文将作为一名资深Java程序员的视角，深入探讨Java中实现分页的各种策略和代码实践，从核心概念到数据库集成，再到前端展示，力求提供一份全面且实用的指南。

一、分页的核心概念与计算逻辑

在开始编写代码之前，我们需要理解分页的几个基本组成部分和它们之间的数学关系：
每页大小 (Page Size / pageSize)：每页显示的数据条数。这是最基本也是最重要的参数。
当前页码 (Current Page / currentPage)：用户当前正在查看的页码。通常从1开始计数，但有些内部实现（如Spring Data JPA）会使用0作为起始页。
总记录数 (Total Items / totalItems)：数据源中所有数据的总条数。
总页数 (Total Pages / totalPages)：根据总记录数和每页大小计算出的总页数。
起始索引 (Start Index / startIndex)：当前页第一条数据在总记录集中的起始位置（通常0-based）。
结束索引 (End Index / endIndex)：当前页最后一条数据在总记录集中的结束位置（不包含）。

这些参数之间存在以下计算关系：
总页数：totalPages = ceil(totalItems / pageSize)。这里需要向上取整，以确保即使剩下不足一页的数据也能被显示。
起始索引：startIndex = (currentPage - 1) * pageSize (如果currentPage是1-based)。
结束索引：endIndex = min(startIndex + pageSize, totalItems)。

在实际应用中，我们通常会封装一个Page或PaginationInfo对象来承载这些分页信息，方便在不同层之间传递和使用。
// 示例：一个简单的分页信息封装类
public class PageInfo<T> {
private int currentPage; // 当前页码 (1-based)
private int pageSize; // 每页大小
private long totalItems; // 总记录数
private int totalPages; // 总页数
private List<T> content; // 当前页的数据列表
public PageInfo(int currentPage, int pageSize, long totalItems, List<T> content) {
= (1, currentPage); // 确保页码至少为1
= (1, pageSize); // 确保页大小至少为1
= totalItems;
= content;
= (int) ((double) totalItems / );
// 确保currentPage不超过totalPages
if ( > && > 0) {
= ;
} else if ( == 0) { // 如果没有数据，总页数为0，当前页也设为1
= 1;
}
}
// Getters
public int getCurrentPage() { return currentPage; }
public int getPageSize() { return pageSize; }
public long getTotalItems() { return totalItems; }
public int getTotalPages() { return totalPages; }
public List<T> getContent() { return content; }
// 是否有上一页
public boolean hasPrevious() {
return currentPage > 1;
}
// 是否有下一页
public boolean hasNext() {
return currentPage < totalPages;
}
}

二、Java中的分页实现策略

1. 数据库层分页（推荐且最常用）

这是最推荐的分页方式，因为数据库擅长处理大量数据，并且可以在数据传输到应用层之前就完成数据筛选和截取，大大减少网络传输和内存开销。

a. 使用JDBC和原生SQL

不同的数据库有不同的分页语法。以下是一些常见数据库的示例：
MySQL/PostgreSQL: 使用LIMIT和OFFSET


SELECT * FROM your_table
ORDER BY id ASC
LIMIT {pageSize} OFFSET {(currentPage - 1) * pageSize};

或者，如果使用LIMIT offset, row_count语法：
SELECT * FROM your_table
ORDER BY id ASC
LIMIT {(currentPage - 1) * pageSize}, {pageSize};


SQL Server (2012及以上版本): 使用OFFSET FETCH


SELECT * FROM your_table
ORDER BY id ASC
OFFSET {(currentPage - 1) * pageSize} ROWS
FETCH NEXT {pageSize} ROWS ONLY;


Oracle (12c及以上版本): 使用OFFSET FETCH


SELECT * FROM your_table
ORDER BY id ASC
OFFSET {(currentPage - 1) * pageSize} ROWS
FETCH NEXT {pageSize} ROWS ONLY;

在Java代码中，你需要构建这些SQL语句，并通过JDBC执行。同时，你还需要执行一个COUNT(*)查询来获取totalItems。
// 示例：使用JDBC实现分页 (伪代码)
public PageInfo<MyObject> getMyObjectsByPageJDBC(int currentPage, int pageSize) {
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
List<MyObject> content = new ArrayList<>();
long totalItems = 0;
try {
conn = getConnection(); // 获取数据库连接
// 1. 获取总记录数
ps = ("SELECT COUNT(*) FROM your_table");
rs = ();
if (()) {
totalItems = (1);
}
close(rs, ps); // 关闭之前的ResultSet和PreparedStatement
// 2. 获取当前页数据
int offset = (currentPage - 1) * pageSize;
// 假设使用MySQL语法
String sql = "SELECT * FROM your_table ORDER BY id ASC LIMIT ? OFFSET ?";
ps = (sql);
(1, pageSize);
(2, offset);
rs = ();
while (()) {
// 将ResultSet映射到MyObject
(mapRowToMyObject(rs));
}
} catch (SQLException e) {
// 异常处理
();
} finally {
close(rs, ps, conn); // 关闭资源
}
return new PageInfo<>(currentPage, pageSize, totalItems, content);
}

b. 使用ORM框架（如Hibernate/JPA）

使用ORM框架进行分页是更现代、更简洁的方式。Spring Data JPA提供了一套非常强大的分页抽象。
Spring Data JPA的Pageable和Page接口

Pageable接口用于传递分页和排序信息给Repository层。它通常通过PageRequest静态工厂方法创建。
import ;
import ;
import ;
import ;
import ;
// 假设我们有一个实体类 User
// @Entity
// public class User { /* ... */ }
// Repository接口
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
// Spring Data JPA会自动实现这个方法，执行分页查询
Page<User> findByAgeGreaterThan(int age, Pageable pageable);
}
// Service层调用
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public Page<User> getUsersPaged(int pageNum, int pageSize, String sortBy, String sortOrder) {
// pageNum在Spring Data JPA中是0-based，所以如果前端传1，这里要-1
int zeroBasedPageNum = pageNum - 1;
if (zeroBasedPageNum < 0) zeroBasedPageNum = 0;
Sort sort = (("asc") ? : , sortBy);
Pageable pageable = (zeroBasedPageNum, pageSize, sort);
// 调用Repository方法，Spring Data JPA会自动构建SQL并执行分页
return (pageable);
}
}
// Controller层（示例）
@RestController
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping
public Page<User> getPaginatedUsers(
@RequestParam(defaultValue = "1") int page,
@RequestParam(defaultValue = "10") int size,
@RequestParam(defaultValue = "id") String sortBy,
@RequestParam(defaultValue = "asc") String sortOrder) {
return (page, size, sortBy, sortOrder);
}
}

对象封装了所有分页信息（content、totalElements、totalPages、number（当前页码，0-based）、size等），非常方便。
MyBatis分页插件 (如PageHelper)

对于使用MyBatis的项目，PageHelper是一个非常流行的分页插件。它通过AOP（Aspect-Oriented Programming）的方式，在执行SQL查询前自动修改SQL，添加分页逻辑。
// Maven依赖
// <dependency>
// <groupId></groupId>
// <artifactId>pagehelper-spring-boot-starter</artifactId>
// <version>1.4.6</version>
// </dependency>
// Mapper接口
public interface UserMapper {
List<User> findAllUsers(); // 不需要修改Mapper方法
}
// Service层调用
@Service
public class UserService {
@Autowired
private UserMapper userMapper;
public PageInfo<User> getAllUsers(int pageNum, int pageSize) {
// 设置分页参数，仅对紧接着的第一个查询有效
(pageNum, pageSize);
List<User> userList = ();
// 使用PageInfo封装查询结果，包含分页信息
return new PageInfo<>(userList);
}
}

PageHelper的PageInfo是其自定义的类，与我们上面示例的PageInfo概念类似，但提供了更丰富的API。

2. 内存集合分页

这种方式适用于数据量不大，或者数据已经一次性加载到内存中的情况。例如，对一个已有的List进行分页展示。
public <T> PageInfo<T> paginateList(List<T> fullList, int currentPage, int pageSize) {
long totalItems = ();
if (totalItems == 0) {
return new PageInfo<>(1, pageSize, 0, ());
}
// 调整页码和页大小，确保在有效范围内
currentPage = (1, currentPage);
pageSize = (1, pageSize);
int totalPages = (int) ((double) totalItems / pageSize);
if (currentPage > totalPages) {
currentPage = totalPages;
}
int startIndex = (currentPage - 1) * pageSize;
// 确保起始索引不会超出列表大小
if (startIndex >= totalItems) {
startIndex = (int) totalItems - 1; // 应该返回空列表或处理为最后一页
if (startIndex < 0) startIndex = 0; // 防止totalItems为0的情况
// 更合理的处理：如果startIndex超出总记录数，说明请求的页码太高，返回空列表
return new PageInfo<>(currentPage, pageSize, totalItems, ());
}
int endIndex = (startIndex + pageSize, (int) totalItems);
List<T> pageContent = (startIndex, endIndex);
return new PageInfo<>(currentPage, pageSize, totalItems, pageContent);
}
// 示例调用
List<String> allData = ("A", "B", "C", "D", "E", "F", "G", "H", "I", "J");
PageInfo<String> page = paginateList(allData, 2, 3); // 获取第二页，每页3条
// () 会是 ["D", "E", "F"]

这种方式简单，但缺点是所有数据都需要加载到内存，对于大数据集是不可接受的。

3. 文件/流式数据分页（较少见，但有特定场景）

当处理大型文本文件或网络数据流时，我们可能需要按“页”读取。这里的“页”可能不是固定行数，而是固定字节数，或者逻辑上的一段数据。

例如，读取一个大文件，每“页”读取100行：
public List<String> readFilePage(String filePath, int currentPage, int pageSize) throws IOException {
List<String> pageLines = new ArrayList<>();
try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
int startLine = (currentPage - 1) * pageSize;
int endLine = startLine + pageSize;
int currentLineNum = 0;
String line;
// 跳过之前的行
while (currentLineNum < startLine && (line = ()) != null) {
currentLineNum++;
}
// 读取当前页的行
while (currentLineNum < endLine && (line = ()) != null) {
(line);
currentLineNum++;
}
}
return pageLines;
}

这种方式的挑战在于获取totalItems（总行数），通常需要提前遍历一次文件，或者在文件元数据中存储。对于非常大的文件，这可能效率低下。

三、前端与后端的分页交互

一个完整的分页功能需要前端和后端协同工作。通常的流程是：
前端请求：用户点击页码或“下一页”按钮，前端将currentPage和pageSize（可能还有排序参数）作为请求参数（URL参数、请求体等）发送给后端。
后端处理：后端接收参数，调用Service层进行数据查询，并将查询结果封装成一个包含分页信息的对象（如Page<T>或PageInfo<T>）返回。
前端渲染：前端接收后端返回的分页数据和分页元信息。

根据content渲染数据列表。
根据currentPage、totalPages、totalItems等信息动态生成页码链接（1, 2, ..., N, 下一页），并高亮当前页。

URL示例:
GET /api/users?page=2&size=10&sortBy=name&sortOrder=asc

后端返回JSON示例 (Spring Data JPA的Page对象转换为JSON):
{
"content": [
{ "id": 11, "name": "User K", "age": 31 },
{ "id": 12, "name": "User L", "age": 28 },
// ... (10条数据)
],
"pageable": {
"sort": { "empty": false, "sorted": true, "unsorted": false },
"offset": 10,
"pageNumber": 1, // 0-based page number
"pageSize": 10,
"paged": true,
"unpaged": false
},
"last": false,
"totalPages": 5,
"totalElements": 48,
"size": 10,
"number": 1, // 0-based current page
"first": false,
"numberOfElements": 10,
"empty": false
}

前端（例如使用Thymeleaf、Vue、React等框架）会根据这些信息进行渲染。以Thymeleaf为例，渲染页码的伪代码：
<div th:if="${ > 0}" class="pagination">
<a th:if="${()}"
th:href="@{/users(page=${ - 1}, size=${})}">上一页</a>
<span th:each="i : ${#(1, )}">
<a th:if="${i != }"
th:href="@{/users(page=${i}, size=${})}" th:text="${i}"></a>
<span th:if="${i == }" th:text="${i}" class="current-page"></span>
</span>
<a th:if="${()}"
th:href="@{/users(page=${ + 1}, size=${})}">下一页</a>
</div>

四、分页的最佳实践与高级考量
一致的页码起始：在整个项目中，统一使用0-based（如Spring Data JPA内部）或1-based（如前端展示和MyBatis PageHelper）页码。建议前端展示和对外API使用1-based，内部转换。
参数校验：始终对currentPage和pageSize进行校验，防止传入负数、零或过大的值导致异常或性能问题。
默认值：为currentPage和pageSize设置合理的默认值，例如currentPage=1，pageSize=10或20。
性能优化：

避免深分页问题：对于OFFSET很大的查询（如OFFSET 100000 LIMIT 10），数据库需要扫描大量行然后丢弃，效率非常低。对于这类场景，考虑使用“键集分页”（Keyset Pagination / Cursor-based Pagination），即通过上次查询的最后一条记录的某个有序字段（如ID或时间戳）来定位下一页的起始位置。例如：SELECT * FROM your_table WHERE id > {last_id_on_previous_page} ORDER BY id ASC LIMIT {pageSize}。
索引优化：确保分页排序的字段（ORDER BY子句中的字段）有索引，以及查询条件字段有索引。
缓存：对于不经常变化的数据，可以考虑对分页结果进行缓存。


封装性：将分页逻辑封装在统一的工具类、Service层或使用ORM框架的内置能力，避免在各处重复编写。
可扩展性：设计分页接口时，应考虑未来可能添加的排序、过滤等功能。
用户体验：提供清晰的页码导航、总页数、总记录数等信息。考虑“跳到N页”功能。

五、总结

Java中的“页数代码”实现是一个贯穿应用全生命周期的重要技术点。从数据库层面的高效查询优化（如SQL的LIMIT/OFFSET、Spring Data JPA的Pageable、MyBatis PageHelper），到内存中集合的简易处理，再到前后端的无缝数据交互和用户界面渲染，每一步都体现了软件工程的智慧。

作为专业的程序员，我们不仅要了解如何实现基本的分页功能，更要深入理解其背后的原理、性能考量和最佳实践。选择合适的分页策略，关注数据一致性和用户体验，并持续优化性能，是构建高质量、高可用Java应用的关键。

希望这篇详细的指南能帮助您在Java项目中游刃有余地处理各种分页需求！

2025-11-06

上一篇：Java字符流深度解析：文本I/O操作的核心方法与最佳实践

下一篇：揭秘自如背后的Java力量：构建高性能、高可用租房服务