Java-常用实现分页查询

一.MyBatis-Plus 分页查询

1.介绍

BaseMapper 接口提供了如下分页查询接口：

• selectPage：根据 entity 条件，查询全部记录
• selectMapsPage：根据 Wrapper 条件，查询全部记录

注意：在使用上面两个方法进行分页查询时，我们需要配置分页插件。这只是在介绍SpringBoot的使用。

2.版本问题：确认mybatis-plus-boot-starter版本

3.4.0版本对此部分有更新，如果是旧版本升级，会出现分页失效问题，同时idea会提示PaginationInterceptor过时，新版本改用了MybatisPlusInterceptor

3.springboot方式-完整配置类（主要实现代码）

/**
 * 分页插件。如果你不配置，分页插件将不生效
 */
@Configuration
public class MybatisPlusConfig {
    /**
     * 旧版 -按需分配
     */
  	/*@Bean
	public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }*/

    /**
     * 新版
     */
    @Bean
    public MybatisPlusInterceptor paginationInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        // 指定数据库方言为 MYSQL
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

分页查询

//pageNum 当前页数、pageSize 每页的显示数；relatedinformationMapper-mapper层；null-实体对象封装操作类（可为空）
Page<实体类> urf = relatedinformationMapper.selectPage(new Page<>(pageNum, pageSize), null);
System.out.println("数据为：" + urf.getRecords());
System.out.println("总数为：" + urf.getTotal() + ",总页数为：" + urf.getPages());
System.out.println("当前页为：" + urf.getCurrent() + ",每页限制：" + urf.getSize());

4.示例代码（实战-完整代码）

表user_relatedinformation 创建

DROP TABLE IF EXISTS `user_relatedinformation`;
CREATE TABLE `user_relatedinformation`  (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `user_name` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户姓名',
  `user_phone` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户手机号',
  `user_address` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户地址',
  `user_detailed_address` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '用户详细地址',
  `status` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '状态：0默认地址',
  `flag` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '是否有效 0无效 1有效',
  `userid` bigint(20) NULL DEFAULT NULL COMMENT '用户id',
  `add_time` datetime NULL DEFAULT NULL COMMENT '创建时间',
  `upd_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 36 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

SET FOREIGN_KEY_CHECKS = 1;

pom包

<?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:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.3</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.hn.yuan</groupId>
    <artifactId>test_pages</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>test_pages</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.21</version>
        </dependency>

        <!--spring项目启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--通过注解消除实际开发中的样板式代码-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <!--spring项目测试启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
        <!--mybatis-plus启动器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <!--mysql数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.35</version>
        </dependency>
        <!--代码生成器-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--模板引擎-->
        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity-engine-core</artifactId>
            <version>2.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

server:
  port: 8081

spring:
    datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/yuan_productlist?useUnicode=true&characterEncoding=UTF-8&useSSL=false
        username: root
        password: root

entity层代码

package com.hn.yuan.productList.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.time.LocalDateTime;
import java.io.Serializable;
import java.util.Date;

import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author XIAOCAO
 * @since 2022-09-20
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class UserRelatedinformation implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 主键
     */
    @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 用户姓名
     */
    private String userName;

    /**
     * 用户手机号
     */
    private String userPhone;

    /**
     * 用户地址
     */
    private String userAddress;

    /**
     * 用户详细地址
     */
    private String userDetailedAddress;

    /**
     * 状态：0默认地址
     */
    private String status;

    /**
     * 是否有效 0无效 1有效
     */
    private String flag;

    /**
     * 用户id
     */
    private Long userid;

    /**
     * 创建时间
     */
    private Date addTime;

    /**
     * 更新时间
     */
    private Date updTime;


}

controller层代码

package com.hn.yuan.productList.controller;


import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hn.yuan.productList.common.ResultMsg;
import com.hn.yuan.productList.entity.UserRelatedinformation;
import com.hn.yuan.productList.service.UserRelatedinformationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author XIAOCAO
 * @since 2022-09-20
 */
@CrossOrigin
@RestController
@RequestMapping("/userRelatedinformation")
public class UserRelatedinformationController {

    @Autowired
    private UserRelatedinformationService userRelatedinformationService;


    @PostMapping("/pageUser")
    public ResultMsg pageUser(@RequestBody JSONObject jsonObject) {

        Page<UserRelatedinformation> page = userRelatedinformationService.pageUser(jsonObject);

        return new ResultMsg(200, page, "成功查询");

    }

}

serviceiml层代码

package com.hn.yuan.productList.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hn.yuan.common.bean.PageBean;
import com.hn.yuan.productList.entity.UserRelatedinformation;
import com.hn.yuan.productList.mapper.UserRelatedinformationMapper;
import com.hn.yuan.productList.service.UserRelatedinformationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author XIAOCAO
 * @since 2022-09-19
 */
@Service
public class UserRelatedinformationServiceImpl extends ServiceImpl<UserRelatedinformationMapper, UserRelatedinformation> implements UserRelatedinformationService {

    @Autowired
    private UserRelatedinformationMapper relatedinformationMapper;

    @Override
    public Page<UserRelatedinformation> pageUser(JSONObject jsonObject) {
        //当前页数
        Long pageNum = Long.valueOf(String.valueOf(jsonObject.get("pageNum")));
        //每页显示数
        Long pageSize = Long.valueOf(String.valueOf(jsonObject.get("pageSize")));
        //进行分页查询-可跟条件
        Page<UserRelatedinformation> urf = relatedinformationMapper.selectPage(new Page<>(pageNum, pageSize), null);
        System.out.println("数据为：" + urf.getRecords());
        System.out.println("总数为：" + urf.getTotal() + ",总页数为：" + urf.getPages());
        System.out.println("当前页为：" + urf.getCurrent() + ",每页限制：" + urf.getSize());
        return urf;

    }
}

vuejs-前端代码

  <template>
  <div>
    <el-row>
      <el-col :span="12">
        <el-input
          placeholder="请输入用户名称"
          v-model="userName"
          clearable
        ></el-input
      ></el-col>
      <el-col :span="12">
        <el-button type="success">搜索</el-button>
      </el-col>
    </el-row>

    <el-row>
      <el-col :span="24">
        <el-main>
          <el-table :data="tableData" style="width: 100%">
            <el-table-column prop="id" label="id" width="180">
            </el-table-column>
            <el-table-column prop="userName" label="用户名称" width="180">
            </el-table-column>
            <el-table-column prop="userPhone" label="手机号" width="180">
            </el-table-column>
            <el-table-column prop="userAddress" label="地址"> </el-table-column>
            <el-table-column prop="userDetailedAddress" label="详细地址">
            </el-table-column>
          </el-table> </el-main
      ></el-col>
    </el-row>

    <el-row>
      <el-col :span="24">
        <div class="block">
          <el-pagination
            @size-change="handleSizeChange"
            @current-change="handleCurrentChange"
            :current-page="pageNum"
            :page-sizes="[10, 20, 30, 40]"
            :page-size="pageSize"
            layout="total, sizes, prev, pager, next, jumper"
            :total="total"
          >
          </el-pagination>
        </div>
      </el-col>
    </el-row>
  </div>
</template>

  <script>
import Axios from "axios";
export default {
  data() {
    return {
      userName: "",
      pageNum: 1, //当前页
      pageSize: 10, //每页显示数
      total: null, //总的记录数
      tableData: [],
    };
  },
  methods: {
    handleSizeChange(val) {
      this.pageSize=val;
      this.pageUser();
      console.log(`每页 ${val} 条`);
    },
    handleCurrentChange(val) {
      this.pageNum=val;
      this.pageUser();
      console.log(`当前页: ${val}`);
    },
    pageUser() {
      var that = this;
      Axios({
        method: "post",
        url: "http://localhost:8081/userRelatedinformation/pageUser",
        data: {
          pageNum: that.pageNum,
          pageSize: that.pageSize,
          userName: that.userName,
        },
      }).then((res) => {
        console.log(res.data.code)
        if (res.data.code == 200) {
          that.tableData = res.data.data.records;
          that.pageNum = res.data.data.current;
          that.pageSize = res.data.data.size;
          that.total = res.data.data.total;
        } else {
          console.log("接口调用失败！");
        }
      });
    },
  },
  created() {
    this.pageUser();
  },
};
</script>
<style scoped>
.el-row {
  margin-bottom: 20px;
}
.el-col {
  border-radius: 4px;
}
</style>

效果图：

二.手动分页（不使用插件）

首先创建一个通用的PageBean类

package com.hn.yuan.common.bean;

import lombok.Data;

import java.io.Serializable;
import java.util.List;

@Data
public class PageBean<T> implements Serializable {

    private int pageNum; //当前页数
    private int pageSize; //每页显示数
    private int totalPage; //总页数
    private int totalRecord; //总的记录数
    private List<T> data; //当前页面的数据集合
    private int start;
    private int end;

    public PageBean() {
    }

    public PageBean(int pageNum, int pageSize, int totalRecord) {
        this.pageNum = pageNum;
        this.pageSize = pageSize;

        //计算总页数
        this.totalPage=totalRecord%pageSize==0?(totalRecord/pageSize):(totalRecord/pageSize+1);

        //计算每页的起始下标
        this.start=(pageNum-1)*pageSize;
        this.end=this.start+pageSize;
    }
}

实现层代码

package com.hn.yuan.productList.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.hn.yuan.common.bean.PageBean;
import com.hn.yuan.productList.entity.UserRelatedinformation;
import com.hn.yuan.productList.mapper.UserRelatedinformationMapper;
import com.hn.yuan.productList.service.UserRelatedinformationService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author XIAOCAO
 * @since 2022-09-19
 */
@Service
public class UserRelatedinformationServiceImpl extends ServiceImpl<UserRelatedinformationMapper, UserRelatedinformation> implements UserRelatedinformationService {

    @Autowired
    private UserRelatedinformationMapper relatedinformationMapper;

    @Override
    public PageBean<UserRelatedinformation> pageUser(JSONObject jsonObject) {

        List<UserRelatedinformation> urf = relatedinformationMapper.selectList(null);

        int totalRecord = 0;
        if (!CollectionUtils.isEmpty(urf)) {
            totalRecord = urf.size();
        }
        PageBean<UserRelatedinformation> pageBean = new PageBean<>(Integer.valueOf(String.valueOf(jsonObject.get("pageNum"))), Integer.valueOf(String.valueOf(jsonObject.get("pageSize"))), totalRecord);
        List<UserRelatedinformation> data = new ArrayList<>();
        for (int i = pageBean.getStart(); i < pageBean.getEnd(); i++) {
            data.add(urf.get(i));
        }
        pageBean.setData(data);
        pageBean.setTotalRecord(totalRecord);

        return pageBean;

    }
}

三.分页查询-基础原理

分页查询

客户端通过传递 start(页码)，pageSize(每页显示的条数) 两个参数去分页查询数据库表中的数据。MySql 数据库提供的分页函数 limit m,n 用法和实际需求不切合，所以就需要根据实际情况去改写适合分页的语句。

❶ 查询第1条到第10条的数据 select * from table limit 0,10;
—>对应需求就是查询第一页的数据：select * from table limit (1-1)*10,10;

❷ 查询第11条到第20条的数据 select * from table limit 10,10;
—>对应需求就是查询第二页的数据：select * from table limit (2-1)*10,10;

❸ 查询第21条到第30条的数据 select * from table limit 20,10;
—>对应需求就是查询第三页的数据：select * from table limit (3-1)*10,10;

由此，得出符合需求的分页 sql 格式是：select * from table limit (start-1)*pageSize,pageSize;其中 start 是页码，pageSize是每页显示的条数。

性能问题

对于小的偏移量，直接用 limit 查询没有什么问题。随着数据量的增大，越往后分页，limit 语句的偏移量越大，速度也会明显变慢。
Ⅰ 优化思想：
避免数据量大时扫描过多的记录
Ⅱ 解决：
子查询的分页方式或者 JOIN 分页方式。JOIN 分页和子查询分页的效率基本在一个等级上，消耗的时间也基本一致。
一般 MySQL 的主键是自增的数字类型，该情况可以使用下面的方式进行优化。以真实的生产环境的 6 万条数据的一张表为例，比较一下优化前后的查询耗时：

-- 传统 limit，文件扫描
select * from table order by id limit 50000,2;
受影响的行: 0
时间:  0.171s

-- 子查询方式，索引扫描
select * from table
where id >= (select id from table order by id limit 50000 , 1)
limit 2;
受影响的行: 0
时间: 0.035s

-- JOIN 分页方式
select * from table as t1
join (select id from table order by id limit 50000, 1) as t2
where t1.id <= t2.id 
order by t1.id limit 2;
受影响的行: 0
时间: 0.036s

优化原理：
子查询是在索引上完成的，而普通的查询是在数据文件上完成的。通常来说，索引文件要比数据文件小得多，所以操作起来也会更有效率。因为要取出所有字段内容，普通查询需要跨越大量数据块并取出，而另一种方式直接根据索引字段定位后，才取出相应内容，效率自然大大提升。因此，对 limit 的优化，是避免直接使用 limit，而是首先获取到 offset 的 id，然后直接使用 limit size 来获取数据。
在实际项目使用，可以利用类似策略模式的方式去处理分页。例如，每页 100 条数据，判断如果是 100 页以内，就使用最基本的分页方式；如果大于 100，则使用子查询的分页方式。

使用合理的分页方式以提高分页的效率

• 使用 limit 实现分页逻辑。不仅提高了性能，同时减少了不必要的数据库和应用间的网络传输。
• 查询结果只有一条或者只要最大/最小一条记录，建议用 limit 1。这是为了使explain中 type 列达到 const 类型。“limit 1”可以避免全表扫面，只要找到了对应的一条记录，就不会继续向下扫描了，效率将会大大提高。当然，如果查询字段是唯一索引的话，没必要加 limit 1，因为 limit 的存在主要就是为了防止全表扫描，从而提高性能，如果一个语句本身可以预知不用全表扫描，有没有 limit，性能的差别并不大。
• 使用如下语句做分页的时候，随着表数据量的增加，直接使用 limit 分页查询会越来越慢。

select id,name from product limit 89757, 20

优化如下：可以取前一页的最大行数的 id，然后根据这个最大的 id 来限制下一页的起点。此例中上一页最大的 id 是 89756。SQL 可以采用如下的写法：

//方案一 ：返回上次查询的最大记录(偏移量)
select id,name from product where id> 89756 limit 20
//方案二：order by + 索引
select id,name from product order by id  limit 10000，10
//方案三：在业务允许的情况下限制页数

理由如下：
• 当偏移量最大的时候，查询效率就会越低，因为 MySQL 并非是跳过偏移量直接去取后面的数据，而是先把偏移量+要取的条数，然后再把前面偏移量这一段的数据抛弃掉再返回的。
• 如果使用优化方案一，返回上次最大查询记录(偏移量)，这样可以跳过偏移量，效率提升不少。
• 方案二使用 order by+索引，也是可以提高查询效率的。
• 方案三的话，建议跟业务讨论，有没有必要查这么多的分页。因为绝大多数用户都不会往后翻太多页。
【强制】在代码中写分页查询逻辑时，若 count 为 0 应直接返回，避免执行后面的分页语句。
转载原文链接：https://blog.csdn.net/ChineseSoftware/article/details/123521438

各位看官》创作不易，点个赞！！！
诸君共勉：万事开头难，只愿肯放弃。

免责声明：本文章仅用于学习参考