网址:www.xservx.com | 备案号:蜀ICP备2026035467号-3

java分页实现方式

〈一〉⚡Java分页实现基础概念与核心原理

分页是Web应用中处理大量数据展示的核心机制,其本质是将数据库中查询出的全量数据按指定大小切分为多个逻辑片段,仅向用户返回当前页所需数据。在Java技术栈中,分页实现方式多样,既包括传统的JSP + JDBC分页,也涵盖现代ORM框架(如MyBatis、Hibernate、Spring Data JPA)的原生分页能力,以及第三方插件(如PageHelper、DataX)的自动化解决方案。

分页的关键参数包括:

  • 当前页码(currentPage):用户请求查看的页数,通常从1开始计数
  • 每页大小(pageSize):每页显示的记录条数,常见值为10、20、50、100
  • 总记录数(total):满足查询条件的总数据量
  • 总页数(totalPages):total ÷ pageSize 向上取整

分页策略可分为物理分页与逻辑分页两类:

物理分页:在数据库层面通过SQL语句限制结果集大小(如MySQL的LIMIT、Oracle的ROWNUM),仅传输必要数据,性能高,推荐使用。

逻辑分页:一次性查询全部数据后在内存中截取,适用于小数据量场景(如缓存列表),大数据量下易导致OOM。

主流数据库分页语法对比:

数据库 分页语法 说明
MySQL LIMIT offset, size offset为起始位置,size为返回条数
PostgreSQL LIMIT size OFFSET offset 语法更符合SQL标准
Oracle ROWNUM或FETCH FIRST N ROWS 高版本支持FETCH FIRST语法
SQL Server OFFSET-FETCH或TOP 2012+支持OFFSET-FETCH

以MySQL为例,分页SQL基本结构如下:

SELECT * FROM users WHERE status=1 ORDER BY create_time DESC LIMIT 10, 20;

该语句表示:跳过前10条记录,返回接下来的20条记录(即第2页,每页20条)。

〈二〉⚙️JSP页面中的分页实现方式

在早期Java Web开发中,JSP页面常与JDBC直接结合实现分页功能。其流程为:JSP页面接收页码参数 → 调用Servlet或JavaBean查询数据库 → 返回分页结果 → 在JSP中循环渲染列表。该方式虽已逐步被MVC框架替代,但理解其原理对掌握分页本质仍有重要意义。

1. 核心步骤

  1. 定义分页请求参数(currentPage、pageSize)
  2. 在Service层计算总记录数与总页数
  3. 通过PreparedStatement设置LIMIT参数执行分页查询
  4. 将分页数据封装为Page对象并存入request作用域
  5. JSP页面通过JSTL标签循环输出列表

2. 分页JavaBean实现示例

public class PageBean { private int currentPage = 1; // 当前页 private int pageSize = 10; // 每页大小 private int total; // 总记录数 private List<User> list; // 当前页数据 public int getTotalPages() { return (total + pageSize - 1) / pageSize; } // 构造方法、getter/setter省略 }

3. JDBC分页查询代码

String sql = "SELECT * FROM users LIMIT ?, ?"; PreparedStatement ps = conn.prepareStatement(sql); ps.setInt(1, (currentPage - 1) * pageSize); ps.setInt(2, pageSize); ResultSet rs = ps.executeQuery();

4. JSP页面渲染逻辑

<c:forEach items="${pageBean.list}" var="user"> <p>${user.name} - ${user.email}</p> </c:forEach> <p>共${pageBean.totalPages}页 / ${pageBean.total}条记录</p>

5. 性能瓶颈与改进方向

  • 每次查询均需执行两次SQL(一次查总记录数,一次查当前页数据)
  • 未对分页参数做校验(如pageSize过大导致性能问题)
  • 未实现结果集缓存机制

现代开发中,建议使用MyBatis或Spring Data JPA替代原生JDBC分页,以提升开发效率与可维护性。

〈三〉⚡Servlet + JDBC分页的完整实现

采用MVC模式时,Servlet作为控制器负责接收请求、调用业务逻辑、跳转页面。分页功能在此模式下体现为请求参数解析、分页数据查询与视图渲染的完整闭环。

1. 分页Servlet核心逻辑

public class UserServlet extends HttpServlet { protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String cp = req.getParameter("currentPage"); String ps = req.getParameter("pageSize"); int currentPage = cp == null ? 1 : Integer.parseInt(cp); int pageSize = ps == null ? 10 : Integer.parseInt(ps); UserService service = new UserService(); PageBean page = service.findUserPage(currentPage, pageSize); req.setAttribute("page", page); req.getRequestDispatcher("/userList.jsp").forward(req, resp); } }

2. Service层分页实现

public PageBean findUserPage(int currentPage, int pageSize) { // 查询总记录数 int total = userDao.count(); // 查询当前页数据 List<User> list = userDao.findByPage((currentPage - 1) * pageSize, pageSize); // 封装PageBean PageBean page = new PageBean(currentPage, pageSize, total, list); return page; }

3. DAO层JDBC查询

public List<User> findByPage(int offset, int limit) { String sql = "SELECT * FROM users ORDER BY id LIMIT ?, ?"; return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class), offset, limit); }

4. 注意事项

  • 必须对输入参数做边界校验(如currentPage ≥ 1,pageSize ≤ 100)
  • 使用PreparedStatement防止SQL注入
  • 对高并发场景可引入Redis缓存总记录数(每5分钟刷新)

该方案虽功能完整,但存在重复代码多、配置繁琐等缺点。随着MyBatis等框架的普及,原生JDBC分页已较少用于生产环境。

〈四〉⚡MyBatis分页实现:原生分页与PageHelper插件

MyBatis作为半自动ORM框架,提供两种分页方式:原生LIMIT分页与PageHelper插件自动化分页。后者已成为行业标准,大幅简化开发流程。

1. 原生分页实现

<select id="selectUserByPage" resultType="User"> SELECT * FROM users WHERE status = 1 ORDER BY create_time DESC LIMIT #{offset}, #{limit} </select>

Service调用示例:

int offset = (currentPage - 1) * pageSize; List<User> list = userMapper.selectUserByPage(offset, pageSize);

2. PageHelper插件配置与使用

在pom.xml中引入依赖:

<dependency> <groupId>com.github.pagehelper</groupId> <artifactId>pagehelper-spring-boot-starter</artifactId> <version>1.4.6</version> </dependency>

核心用法(自动计算总记录数与总页数):

PageHelper.startPage(currentPage, pageSize); List<User> list = userMapper.selectAll(); PageInfo<User> pageInfo = new PageInfo<>(list);

PageInfo对象包含完整分页信息:

属性 说明
pageNum 当前页码
pageSize 每页大小
total 总记录数
pages 总页数
list 当前页数据列表
hasNextPage 是否有下一页
hasPreviousPage 是否有上一页

3. 分页参数安全校验

PageHelper支持通过配置限制最大pageSize:

pagehelper.helper-dialect=mysql pagehelper.params=count=countSql pagehelper.reasonable=true pagehelper.page-size-zero=true pagehelper.support-methods-arguments=true pagehelper.params.pageNum=pageNum pagehelper.params.pageSize=pageSize

建议在Controller中增加参数校验:

@RequestParam(defaultValue = "1") @Min(1) Integer currentPage, @RequestParam(defaultValue = "10") @Max(100) Integer pageSize

4. 复杂查询分页示例

当分页查询涉及多表JOIN时,PageHelper会自动优化SQL:

PageHelper.startPage(currentPage, pageSize); List<OrderWithUser> orders = orderMapper.selectWithUser();

生成的SQL自动包裹为:

SELECT COUNT(*) FROM (SELECT ... ) tmp_count SELECT ... FROM orders o JOIN users u ON o.user_id = u.id LIMIT ?, ?

注意:若使用自定义COUNT查询(如复杂聚合),需通过PageHelper.count()手动指定。

〈五〉⚡Spring Data JPA分页实现:Pageable与PagingAndSortingRepository

Spring Data JPA通过Pageable接口与PagingAndSortingRepository提供声明式分页支持,结合JPA Criteria API或QueryDSL可构建类型安全的分页查询。

1. 基础分页Repository定义

public interface UserRepository extends PagingAndSortingRepository<User, Long> { Page<User> findByStatus(@Param("status") int status, Pageable pageable); }

2. Service层调用示例

Pageable pageable = PageRequest.of(currentPage - 1, pageSize, Sort.by("createTime").descending()); Page<User> page = userRepository.findByStatus(1, pageable); // 获取分页信息 int totalPages = page.getTotalPages(); long totalElements = page.getTotalElements(); List<User> content = page.getContent();

3. 动态条件分页

使用Specification构建动态查询:

Specification<User> spec = (root, query, cb) -> { List<Predicate> predicates = new ArrayList<>(); if (status != null) { predicates.add(cb.equal(root.get("status"), status)); } if (StringUtils.hasText(keyword)) { predicates.add(cb.or( cb.like(root.get("name"), "%" + keyword + "%"), cb.like(root.get("email"), "%" + keyword + "%") )); } return cb.and(predicates.toArray(new Predicate[0])); }; Pageable pageable = PageRequest.of(currentPage - 1, pageSize); Page<User> page = userRepository.findAll(spec, pageable);

4. 自定义COUNT查询优化

当默认COUNT查询性能不佳时,可通过@Query自定义COUNT语句:

@Query(value = "SELECT u FROM User u WHERE u.status = :status") Page<User> findByStatus(@Param("status") int status, Pageable pageable); @Query("SELECT COUNT(*) FROM User u WHERE u.status = :status") long countByStatus(@Param("status") int status);

5. 分页与排序结合

支持多字段排序:

Pageable pageable = PageRequest.of(currentPage - 1, pageSize, Sort.by("createTime").descending().and(Sort.by("name").ascending()));

6. 注意事项

  • currentPage从1开始,但PageRequest.of()中页码从0开始,需手动转换
  • 避免在大数据量表上使用Pageable,考虑使用ScrollableResult
  • 对频繁分页查询的场景,可启用JPA二级缓存

〈六〉⚡Hibernate原生分页与Query.setFirstResult()实现

Hibernate作为成熟的ORM框架,提供HQL分页与Criteria API分页两种方式。其分页机制基于数据库方言自动适配LIMIT语法。

1. HQL分页实现

String hql = "FROM User WHERE status = :status ORDER BY createTime DESC"; Query query = session.createQuery(hql); query.setParameter("status", 1); query.setFirstResult((currentPage - 1) * pageSize); query.setMaxResults(pageSize); List<User> users = query.list();

2. Criteria分页实现

CriteriaBuilder cb = session.getCriteriaBuilder(); CriteriaQuery<User> cq = cb.createQuery(User.class); Root<User> root = cq.from(User.class); cq.select(root).where(cb.equal(root.get("status"), 1)) .orderBy(cb.desc(root.get("createTime"))); Query<User> query = session.createQuery(cq); query.setFirstResult((currentPage - 1) * pageSize); query.setMaxResults(pageSize); List<User> users = query.getResultList();

3. 统计总记录数

String countHql = "SELECT COUNT(*) FROM User WHERE status = :status"; Query countQuery = session.createQuery(countHql); countQuery.setParameter("status", 1); long total = (Long) countQuery.getSingleResult();

4. 性能优化技巧

  • 使用scroll()方法处理超大数据集(避免一次性加载到内存)
  • 对COUNT查询结果缓存(每5分钟刷新)
  • 通过batch-size优化关联查询性能

5. 与Spring集成示例

@Repository public class UserRepositoryImpl implements UserRepository { @PersistenceContext private EntityManager em; public Page<User> findUsers(int currentPage, int pageSize, Integer status) { String hql = "FROM User WHERE status = :status"; Query query = em.createQuery(hql); query.setParameter("status", status); query.setFirstResult((currentPage - 1) * pageSize); query.setMaxResults(pageSize); String countHql = "SELECT COUNT(*) FROM User WHERE status = :status"; Query countQuery = em.createQuery(countHql); countQuery.setParameter("status", status); long total = (Long) countQuery.getSingleResult(); return new PageImpl<>(query.getResultList(), PageRequest.of(currentPage - 1, pageSize), total); } }

6. 注意事项

  • 分页查询不支持join fetch,需单独处理关联数据
  • 对大数据量场景,建议使用ScrollableResults
  • 确保数据库索引覆盖WHERE与ORDER BY字段

〈七〉⚡分页插件方案:PageHelper vs SmartPage vs DataX

PageHelper:最流行的MyBatis分页插件

PageHelper支持MySQL、Oracle、PostgreSQL等17种数据库,核心优势在于:

  • 零侵入性:只需调用startPage()即可自动分页
  • 自动COUNT:无需手动编写COUNT查询
  • 参数安全:内置pageSize上限限制
  • 多数据库支持:通过helper-dialect自动适配

高级配置示例

# application.yml pagehelper: helper-dialect: mysql reasonable: true support-methods-arguments: true params: count=countSql page-size-zero: true

复杂场景处理

当分页查询包含GROUP BY时,需禁用COUNT优化:

PageHelper.startPage(currentPage, pageSize, false); // 第三个参数为false List<OrderStat> stats = orderMapper.selectGroupByStat();

SmartPage:国产轻量级分页插件

SmartPage专为微服务设计,支持Spring Boot 2.x+,核心特性:

  • 自动识别COUNT查询:无需额外配置
  • 支持Lambda表达式查询
  • 内置分页参数转换器
  • 支持分页结果脱敏

使用示例

SmartPage page = new SmartPage(currentPage, pageSize); List<User> users = userMapper.selectPage(page, new LambdaQueryWrapper<User>().eq(User::getStatus, 1));

与MyBatis-Plus集成

SmartPage天然兼容MyBatis-Plus,可无缝替代其自带分页插件:

// 替换MyBatis-Plus的PaginationInnerInterceptor @Bean public MybatisPlusInterceptor mybatisPlusInterceptor() { MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor(); interceptor.addInnerInterceptor(new SmartPageInterceptor()); return interceptor; }

DataX:大数据分页同步方案

DataX是阿里开源的数据同步工具,其分页插件适用于海量数据迁移场景:

  • 支持分库分表数据同步
  • 自动处理断点续传
  • 支持JDBC URL参数化分页

配置示例

"reader": { "name": "mysqlreader", "parameter": { "username": "xxx", "password": "xxx", "column": ["id", "name", "email"], "where": ["id > 10000"], "splitPk": "id", "connection": [{ "table": ["users"], "jdbcUrl": ["jdbc:mysql://127.0.0.1:3306/db?useSSL=false"] }] } }

适用场景

  • 千万级数据迁移
  • 跨数据库同步
  • ETL任务分页处理

〈八〉⚡分页性能优化实战:索引、查询与架构方案

1. 数据库层面优化

索引优化

  • 确保ORDER BY字段建立索引(复合索引优先)
  • 避免WHERE与ORDER BY使用不同索引
  • 对分页查询频繁的表,考虑覆盖索引

SQL改写技巧

大偏移量分页(如第10000页)性能差,可改用“基于游标”的分页:

-- 原始方式(性能差) SELECT * FROM orders ORDER BY create_time DESC LIMIT 100000, 20; -- 游标分页(性能优) SELECT * FROM orders WHERE create_time < ? ORDER BY create_time DESC LIMIT 20;

COUNT查询优化

避免全表COUNT,可采用以下方案:

  • 使用近似COUNT(如Redis计数器,每5分钟刷新)
  • 对统计表预聚合COUNT结果
  • 在数据写入时维护COUNT字段

2. 应用层优化

缓存策略

对热门分页数据缓存:

// Redis缓存分页结果(TTL=300秒) String cacheKey = String.format("user_page_%d_%d", currentPage, pageSize); String cacheData = redisTemplate.opsForValue().get(cacheKey); if (cacheData == null) { Page<User> page = userService.findPage(currentPage, pageSize); redisTemplate.opsForValue().set(cacheKey, JSON.toJSONString(page), 300, TimeUnit.SECONDS); }

懒加载优化

避免一次性加载关联数据:

// 不推荐:JOIN查询加载所有关联 List<User> users = userMapper.selectWithOrders(); // 推荐:分页查询用户,按需加载订单 List<User> users = userMapper.selectPage(currentPage, pageSize); for (User user : users) { user.setOrders(orderService.findByUserId(user.getId())); }

3. 架构层方案

ES分页

对全文检索场景,使用Elasticsearch的search_after参数:

{ "size": 20, "query": { "match_all": {} }, "sort": [ { "create_time": "desc" }, { "_id": "asc" } ], "search_after": [1620000000000, "abc123"] }

NoSQL分页

MongoDB分页推荐使用skip+limit(小数据量)或游标分页:

// 小数据量(skip < 50000) db.users.find({status:1}).skip(1000).limit(20); // 大数据量(基于游标) db.users.find({status:1, _id: {$gt: lastId}}).limit(20).sort({_id:1});

〈九〉⚡分页常见陷阱与避坑指南

陷阱1:currentPage参数校验缺失

未校验currentPage ≤ 0 或currentPage > totalPages会导致异常:

// 错误示例 int offset = (currentPage - 1) * pageSize; // currentPage=0时offset=-1 // 正确做法 currentPage = Math.max(1, currentPage); currentPage = Math.min(currentPage, totalPages);

陷阱2:pageSize过大导致性能问题

用户传入pageSize=10000可能引发OOM:

// 限制pageSize上限 pageSize = Math.min(pageSize, 100);

陷阱3:COUNT查询与分页SQL不一致

MyBatis中常见错误:

SELECT * FROM users WHERE status = 1 ORDER BY create_time DESC LIMIT ?, ? SELECT COUNT(*) FROM users SELECT COUNT(*) FROM users WHERE status = 1

陷阱4:分页与JOIN查询冲突

当分页查询包含JOIN时,COUNT可能不准确:

-- 错误:COUNT(*)会重复计算JOIN产生的行 SELECT COUNT(*) FROM orders o JOIN users u ON o.user_id = u.id -- 正确:COUNT(DISTINCT o.id)或子查询 SELECT COUNT(*) FROM ( SELECT DISTINCT o.id FROM orders o JOIN users u ON o.user_id = u.id ) tmp

陷阱5:分页插件与自定义SQL冲突

PageHelper不支持自定义SQL的分页时:

// 方案1:禁用插件 PageHelper.clearPage(); // 方案2:使用插件的countSql参数 PageHelper.startPage(currentPage, pageSize); List<User> list = userMapper.selectCustom();

陷阱6:分页结果未校验数据完整性

高并发场景下可能出现数据不一致:

// 检查实际返回数量是否小于pageSize if (list.size() < pageSize && currentPage < totalPages) { log.warn("分页数据异常:currentPage={}, size={}", currentPage, list.size()); }