spring boot集成mybatis(2) - 使用pagehelper实现分页（springboot集成mybatisplus分页）

25-03-19 6

本文将分享springboot集成mybatis(2)-使用pagehelper实现分页的详细内容，并且还将对springboot集成mybatisplus分页进行详尽解释，此外，我们还将为大家带来关

本文将分享spring boot集成mybatis(2) - 使用pagehelper实现分页的详细内容，并且还将对springboot集成mybatisplus分页进行详尽解释，此外，我们还将为大家带来关于6、SpringBoot-mybatis分页实现pagehelper、9.Spring Boot 集成 MyBatis (pagehelper 分页查询)、Mybatis (八) Mybatis整合PageHelper实现分页、mybatis 使用 pagehelper-spring-boot-starter 与 pagehelper 的区别的相关知识，希望对你有所帮助。

本文目录一览：

spring boot集成mybatis(2) - 使用pagehelper实现分页（springboot集成mybatisplus分页）
6、SpringBoot-mybatis分页实现pagehelper
9.Spring Boot 集成 MyBatis (pagehelper 分页查询)
Mybatis (八) Mybatis整合PageHelper实现分页
mybatis 使用 pagehelper-spring-boot-starter 与 pagehelper 的区别

spring boot集成mybatis(2) - 使用pagehelper实现分页（springboot集成mybatisplus分页）

概述

本文在前一篇教程的基础上，使用常用的pagehelper插件，添加分页功能。本文将实现一个列出所有用户的接口，分页返回结果

准备数据

数据库和数据表都使用前面章节 [spring boot集成mybatis(1)] 用过的，因为要分页，表里需要插入更多数据。

mysql命令行客户端连接数据库

mysql -h localhost -u root -p

插入数据的sql语句：

INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc3'', ''13512345603'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc4'', ''13512345604'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc5'', ''13512345605'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc6'', ''13512345606'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc7'', ''13512345607'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc8'', ''13512345608'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc9'', ''13512345609'', ''123'');
INSERT INTO `qikegu_demo`.`user` (`nickname`, `mobile`, `password`) VALUES (''abc10'', ''13512345610'', ''123'');

项目依赖

不创建新项目，重用章节 [spring boot集成mybatis(1)] 里的项目，没有项目请按该文创建。 Eclipse打开该项目，在pom.xml文件中，添加依赖：pagehelper-spring-boot-starter，引入pagehelper相关依赖包

添加依赖：pagehelper-spring-boot-starter

在pom.xml中添加依赖

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

完整的pom.xml文件

<?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 http://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.1.1.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.qikegu</groupId>
	<artifactId>springboot-mybatis-demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-mybatis-demo</name>
	<description>Demo project for Spring Boot</description>

	<properties>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-jdbc</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.mybatis.spring.boot</groupId>
			<artifactId>mybatis-spring-boot-starter</artifactId>
			<version>1.3.2</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		
		<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper-spring-boot-starter -->
		<dependency>
		    <groupId>com.github.pagehelper</groupId>
		    <artifactId>pagehelper-spring-boot-starter</artifactId>
		    <version>1.2.10</version>
		</dependency>
		
	</dependencies>

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

</project>

项目配置

添加pagehelper配置

在application.properties中添加pagehelper配置

pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

说明：

helperDialect：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。你也可以配置helperDialect属性来指定分页插件使用哪种方言。
reasonable：分页合理化参数，默认值为false。当该参数设置为 true 时，pageNum<=0 时会查询第一页， pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。
params：用于从对象中根据属性名取值，可以配置 pageNum,pageSize,count,pageSizeZero,reasonable，不配置映射的用默认值，默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero
supportMethodsArguments：默认值false，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。

更多信息参考pagehelper官网

application.properties完整内容

## 服务器端口，如果不配置默认是8080端口
server.port=8096 

## 数据库设置
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.0.99:3306/qikegu_demo?serverTimezone=UTC&useUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=qazwsx

## mybatis配置
#  指向映射类目录
mybatis.type-aliases-package=com.qikegu.demo.model
# 指向映射xml文件目录
mybatis.mapper-locations=classpath:mapper/*.xml

## pagehelper
pagehelper.helperDialect=mysql
pagehelper.reasonable=true
pagehelper.supportMethodsArguments=true
pagehelper.params=count=countSql

添加代码

pagehelper 使用方法

pagehelper使用方法有好几种，这里我们介绍最常用的2种：

//方法1，Mapper接口方式的调用，推荐这种使用方式。
PageHelper.startPage(1, 10); // pageNum=1, pageSize=10
List<Country> list = countryMapper.selectIf(1);

//方法2，参数方法调用
//存在以下 Mapper 接口方法，你不需要在 xml 处理后两个参数
public interface CountryMapper {
    List<Country> selectByPageNumSize(
            @Param("user") User user,
            @Param("pageNum") int pageNum,
            @Param("pageSize") int pageSize);
}
//配置supportMethodsArguments=true
//在代码中直接调用：
List<Country> list = countryMapper.selectByPageNumSize(user, 1, 10);

本文例子采取方法1，更多方法参考pagehelper官网

代码实现

添加我们要实现的功能：列出所有用户，分页返回结果。下面几个文件需要修改：

UserController.java - 控制层
UserService.java & UserServiceImpl.java - 服务层
UserMapper.java & UserMapper.xml - 数据访问层

如图：

UserController.java

新增一个函数

   @RequestMapping(value="", method = RequestMethod.GET, produces="application/json")
    public PageInfo<User> listUser(
    		@RequestParam(value="page", required=false, defaultValue="1") int page,
    		@RequestParam(value="page-size", required=false, defaultValue="5") int pageSize){
    	

        List<User> result = userService.listUser(page, pageSize);
        // PageInfo包装结果，返回更多分页相关信息
        PageInfo<User> pi = new PageInfo<User>(result);
        
        return pi;
    }

说明：

此函数是接口的控制层，其中

@RequestParam 注解获取url中的?page=1&page-size=5参数，value="page"是url中的参数名，required指参数是否必须，如果是必须URL却没有这个参数会报错，defaultValue="1"缺省值
PageInfo PageInfo包装结果，返回更多分页相关信息

完整代码：

package com.qikegu.demo.controller;

import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.qikegu.demo.model.User;
import com.qikegu.demo.service.UserService;

@RestController
@EnableAutoConfiguration
@RequestMapping("/user")
public class UserController {
	
	// 注入mapper类
    @Resource
    private UserService userService;
	
    @RequestMapping(value="{id}", method=RequestMethod.GET, produces="application/json")
    public User getUser(@PathVariable long id) throws Exception {
    	
        User user = this.userService.getUserById(id);
        
        return user;
    }
    
    @RequestMapping(value="", method = RequestMethod.GET, produces="application/json")
    public PageInfo<User> listUser(
    		@RequestParam(value="page", required=false, defaultValue="1") int page,
    		@RequestParam(value="page-size", required=false, defaultValue="5") int pageSize){
    	

        List<User> result = userService.listUser(page, pageSize);
        // PageInfo包装结果，返回更多分页相关信息
        PageInfo<User> pi = new PageInfo<User>(result);
        
        return pi;
    }

}

UserService.java & UserServiceImpl.java

UserService.java新增一个接口

public List<User> listUser(int page, int pageSize);

UserServiceImpl.java新增上面接口的实现

	@Override
	public List<User> listUser(int page, int pageSize) {
        List<User> result = null;
        try {
        	// 调用pagehelper分页，采用starPage方式。starPage应放在Mapper查询函数之前
            PageHelper.startPage(page, pageSize); //每页的大小为pageSize，查询第page页的结果
            PageHelper.orderBy("id ASC "); //进行分页结果的排序
        	result = userMapper.selectUser();
        } catch (Exception e) {
            e.printStackTrace();
        }

		return result;
	}

说明：

请看代码注释

完整代码：

UserService.java

package com.qikegu.demo.service;

import java.util.List;

import com.qikegu.demo.model.User;

public interface UserService {
	
    public User getUserById(long userId);
    
    public List<User> listUser(int page, int pageSize);
}

UserServiceImpl.java

package com.qikegu.demo.service.impl;

import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.github.pagehelper.PageHelper;
import com.qikegu.demo.model.User;
import com.qikegu.demo.repository.UserMapper;
import com.qikegu.demo.service.UserService;

@Service("userService")
public class UserServiceImpl implements UserService {

	//注入mybatis数据库查询类
    @Resource
    private UserMapper userMapper;
    
    @Override
    public User getUserById(long userId) {
        return userMapper.selectByPrimaryKey(userId);
    }
    
	@Override
	public List<User> listUser(int page, int pageSize) {
        List<User> result = null;
        try {
        	// 调用pagehelper分页，采用starPage方式。starPage应放在Mapper查询函数之前
            PageHelper.startPage(page, pageSize); //每页的大小为pageSize，查询第page页的结果
            PageHelper.orderBy("id ASC "); //进行分页结果的排序
        	result = userMapper.selectUser();
        } catch (Exception e) {
            e.printStackTrace();
        }

		return result;
	}
}

UserMapper.java & UserMapper.xml

UserMapper.java 新增接口

    // 列出用户，对应xml映射文件元素的ID
    List<User> selectUser();

UserMapper.xml 该接口新增mybatis xml实现

  <select id="selectUser" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from user
  </select>

说明

请看代码注释

完整代码

UserMapper.java

package com.qikegu.demo.repository;

import java.util.List;

import com.qikegu.demo.model.User;

public interface UserMapper {

	// 查询某个用户，对应xml映射文件元素的ID
    User selectByPrimaryKey(long id);
    
    // 列出用户，对应xml映射文件元素的ID
    List<User> selectUser();
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.qikegu.demo.repository.UserMapper">
  <resultMap id="BaseResultMap" type="com.qikegu.demo.model.User">
    <constructor>
      <idArg column="id" javaType="_long" jdbcType="BIGINT" />
      <arg column="nickname" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="mobile" javaType="java.lang.String" jdbcType="VARCHAR" />
      <arg column="password" javaType="java.lang.String" jdbcType="CHAR" />
      <arg column="role" javaType="java.lang.String" jdbcType="VARCHAR" />
    </constructor>
  </resultMap>
  
  <sql id="Base_Column_List">
	id, nickname, mobile, password, role
  </sql>
  <select id="selectByPrimaryKey" parameterType="_long" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from user
    where id = #{id,jdbcType=BIGINT}
  </select>
  
  <select id="selectUser" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from user
  </select>
  
</mapper>

运行

Eclipse左侧，在项目根目录上点击鼠标右键弹出菜单，选择：run as -> spring boot app 运行程序。我们使用Postman访问接口，Postman是一款很强大的接口测试工具，很常用称得上是“居家旅行必备”，推荐使用。安装很简单，去官网下载一个，按照步骤安装就可以了。运行结果如下：

总结

分页功能可以说是web开发中的必备功能，本文在前一篇教程的基础上，介绍了mybatis pagehelper插件的集成过程，pagehelper是一款常用的分页插件，具有和Mapper.xml完全解耦的优点，推荐在项目中使用。

完整代码

6、SpringBoot-mybatis分页实现pagehelper

系列导航

1、springboot工程新建（单模块）

2、springboot创建多模块工程

3、springboot连接数据库

4、SpringBoot连接数据库引入druid

5、SpringBoot连接数据库引入mybatis

6、SpringBoot-mybatis分页实现pagehelper

未完待续

SpringBoot连接数据库引入mybatis的分页插件

注：mybatisplus跟mybatis的分页插件一样

1、数据准备（oracle数据库）

Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1001', 'RabbitMQ');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1002', 'ZeroMQ');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1003', 'ActiveMQ');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1004', 'RocketMQ');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1005', 'Apollo');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('1', '后端开发');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('2', '前端开发');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('3', '前端框架');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('4', '后端框架');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('5', '数据库');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('6', 'Nosql');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('7', '对象存储');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('8', '大数据');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('9', '操作系统');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('10', '消息队列');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('100', 'Python');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('101', 'Java');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('102', 'PHP');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('103', 'C');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('104', 'C++');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('105', 'C#');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('106', 'PHP');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('107', 'go');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('108', 'Visual Basic');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('201', 'JavaScript');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('202', 'css');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('203', 'swift');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('204', 'html5');
Insert into XY_DIC_BLOCK_T   (BLOCK_ID, BLOCK_NAME) Values   ('300', 'Vue');
commit;

2、在上一个项目的基础上pom.xml增加mybatis分页的依赖

<?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>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.1.17.RELEASE</spring-boot.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.3</version>
        </dependency>

        <!-- 集成druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!-- 集成mybatis -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!-- 集成mybatis-pageHelper分页功能 -->
        <dependency>
            <groupId>com.github.pageHelper</groupId>
            <artifactId>pageHelper-spring-boot-starter</artifactId>
            <version>1.2.12</version>
        </dependency>


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.1.17.RELEASE</version>
                <configuration>
                    <mainClass>com.example.demo.DemoApplication</mainClass>
                </configuration>
                <executions>
                    <execution>
                        <id>repackage</id>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

3、application.properties配置

增加pageHelper的配置（如下红色部分）

spring.application.name=demo
# 应用服务 WEB 访问端口
server.port=8080

# 数据库设置
spring.datasource.driverClassName=oracle.jdbc.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@192.168.0.100:1521:orcl
spring.datasource.username=zy
spring.datasource.password=1

# druid配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# druid参数调优（可选）
# 初始化大小，最小，最大
spring.datasource.initialSize=5
spring.datasource.minIdle=5
spring.datasource.maxActive=20
# 配置获取连接等待超时的时间
spring.datasource.maxWait=60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
spring.datasource.timeBetweenevictionRunsMillis=60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
spring.datasource.minevictableIdleTimeMillis=300000
# 测试连接
spring.datasource.testWhileIdle=true
spring.datasource.testOnBorrow=false
spring.datasource.testOnReturn=false
# 打开PSCache，并且指定每个连接上PSCache的大小
spring.datasource.poolPreparedStatements=true
spring.datasource.maxPoolPreparedStatementPerConnectionSize=20
# 配置监控统计拦截的filters
spring.datasource.filters=stat
# asyncInit是1.1.4中新增加的配置，如果有initialSize数量较多时，打开会加快应用启动时间
spring.datasource.asyncInit=true

## mybatis配置
# 参数类型的包别名设置
mybatis.typeAliasesPackage=com.example.demo.domain
# 指向映射xml文件目录
mybatis.mapperLocations=classpath:mapper/*.xml

#分頁配置pageHelper
pageHelper.helperDialect=oracle
pageHelper.reasonable=true
pageHelper.supportMethodsArguments=true
pageHelper.params=count=countsql

4、工程目录

5、代码部分

druid配置类

package com.example.demo.config;

import java.sql.sqlException;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import com.alibaba.druid.pool.DruidDataSource;

@Configuration
public class DruidConfig {
    private Logger logger = LoggerFactory.getLogger(DruidConfig.class);

    @Value("${spring.datasource.url}")
    private String dbUrl;

    @Value("${spring.datasource.username}")
    private String username;

    @Value("${spring.datasource.password}")
    private String password;

    @Value("${spring.datasource.driver-class-name}")
    private String driverClassName;

    @Value("${spring.datasource.initial-size}")
    private int initialSize;

    @Value("${spring.datasource.min-idle}")
    private int minIdle;

    @Value("${spring.datasource.max-active}")
    private int maxActive;

    @Value("${spring.datasource.max-wait}")
    private int maxWait;

    @Value("${spring.datasource.time-between-eviction-runs-millis}")
    private int timeBetweenevictionRunsMillis;

    @Value("${spring.datasource.min-evictable-idle-time-millis}")
    private int minevictableIdleTimeMillis;

//    @Value("${spring.datasource.validation-query}")
//    private String validationQuery;

    @Value("${spring.datasource.test-while-idle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.test-on-borrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.test-on-return}")
    private boolean testOnReturn;

    @Value("${spring.datasource.pool-prepared-statements}")
    private boolean poolPreparedStatements;

    @Value("${spring.datasource.max-pool-prepared-statement-per-connection-size}")
    private int maxPoolPreparedStatementPerConnectionSize;

    @Value("${spring.datasource.filters}")
    private String filters;



    @Bean     //声明其为Bean实例
    @Primary  //在同样的DataSource中，首先使用被标注的DataSource
    public DataSource dataSource(){
        DruidDataSource datasource = new DruidDataSource();

        datasource.setUrl(this.dbUrl);
        datasource.setUsername(username);
        datasource.setPassword(password);
        datasource.setDriverClassName(driverClassName);

        //configuration
        datasource.setinitialSize(initialSize);
        datasource.setMinIdle(minIdle);
        datasource.setMaxActive(maxActive);
        datasource.setMaxWait(maxWait);
        datasource.setTimeBetweenevictionRunsMillis(timeBetweenevictionRunsMillis);
        datasource.setMinevictableIdleTimeMillis(minevictableIdleTimeMillis);
//      datasource.setValidationQuery(validationQuery);
        datasource.setTestWhileIdle(testWhileIdle);
        datasource.setTestOnBorrow(testOnBorrow);
        datasource.setTestOnReturn(testOnReturn);
        datasource.setPoolPreparedStatements(poolPreparedStatements);
        datasource.setMaxPoolPreparedStatementPerConnectionSize(maxPoolPreparedStatementPerConnectionSize);
        try {
            datasource.setFilters(filters);
        } catch (sqlException e) {
            logger.error("druid configuration initialization filter", e);
        }
//      datasource.setConnectionProperties(connectionProperties);

        return datasource;
    }
}

package com.example.demo.domain;


 
public class  Block   {


    private String blockId;
 
    private String blockName;

    public String getBlockId() {
        return blockId;
    }

    public void setBlockId(String blockId) {
        this.blockId = blockId;
    }

    public String getBlockName() {
        return blockName;
    }

    public void setBlockName(String blockName) {
        this.blockName = blockName;
    }

    @Override
    public String toString() {
        return "XyDicBlockT{" +
                "blockId='" + blockId + '\'' +
                ", blockName='" + blockName + '\'' +
                '}';
    }
}

package com.example.demo.mapper;

import com.example.demo.domain.Block;
import org.apache.ibatis.annotations.Mapper;


import java.util.List;

public interface  BlockMapper {
    // 对应xml映射文件元素的ID
    Block selectByPrimaryKey(String blockId);

    // 列出知识块，对应xml映射文件元素的ID
    List<Block> selectBlock();
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.BlockMapper">
    <resultMap id="BaseResultMap" type="com.example.demo.domain.Block">
        <result property="blockId" column="block_Id"/>
        <result property="blockName" column="block_Name"/>
    </resultMap>

    <sql id="Base_Column_List">
        block_id,block_name
    </sql>
    <select id="selectByPrimaryKey" parameterType="String"  resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from XY_DIC_BLOCK_T
        where block_Id = #{blockId,jdbcType=VARCHAR}
    </select>

    <select id="selectBlock" resultMap="BaseResultMap">
        select
        <include refid="Base_Column_List" />
        from XY_DIC_BLOCK_T
    </select>
</mapper>

package com.example.demo.service;

import com.example.demo.domain.Block;

import java.util.List;

public interface  BlockService {

      Block getUserById(String userId);

      List<Block> listBlock(int page, int pageSize);

}

package com.example.demo.service.impl;


import javax.annotation.Resource;

import com.example.demo.domain.Block;
import com.example.demo.mapper.BlockMapper;
import com.example.demo.service.BlockService;
import com.github.pageHelper.pageHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;


@Service
public class BlockServiceImpl implements BlockService {

    // 注入mapper类
    @Autowired
    private BlockMapper blockMapper;

    @Override
    public Block getUserById(String blockId) {
        return blockMapper.selectByPrimaryKey(blockId);
    }

    @Override
    public List<Block> listBlock(int page, int pageSize) {
        List<Block> result = null;
        try {
            // 调用pageHelper分页，采用starPage方式。starPage应放在Mapper查询函数之前
            pageHelper.startPage(page, pageSize); //每页的大小为pageSize，查询第page页的结果
            pageHelper.orderBy("block_id ASC "); //进行分页结果的排序
            result = blockMapper.selectBlock();
        } catch (Exception e) {
            e.printstacktrace();
        }

        return result;
    }
}

package com.example.demo;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;

@SpringBootApplication
//指定要扫描的mybatis映射类的路径
@MapperScan("com.example.demo.mapper")
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

package com.example.demo.controller;


import com.example.demo.domain.Block;
import com.example.demo.service.BlockService;

import com.github.pageHelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
 
import java.util.List;

@RestController
@RequestMapping("/hello")
public class HelloController {

    @Autowired
    private BlockService blockService;

    @GetMapping("/list")
    @ResponseBody
    public PageInfo<Block> index(
            @RequestParam(value="page", required=false, defaultValue="1") int page,
            @RequestParam(value="page-size", required=false, defaultValue="5") int pageSize) {

        List<Block> result = blockService.listBlock(page, pageSize);
        // PageInfo包装结果，返回更多分页相关信息
        PageInfo<Block> pi = new PageInfo<Block>(result);

        return pi;
    }

 
}

注：@RequestParam 注解获取url中的?page=1&page-size=5参数，value="page"是url中的参数名，required指参数是否必须，如果是必须URL却没有这个参数会报错，defaultValue="1"缺省值
PageInfo PageInfo包装结果，返回更多分页相关信息

7、启动项目访问项目

{
    "total": 54,
    "list": [
        {
            "blockId": "1",
            "blockName": "后端开发"
        },
        {
            "blockId": "100",
            "blockName": "Python"
        },
        {
            "blockId": "1000",
            "blockName": "Kafka"
        }
    ],
    "pageNum": 1,
    "pageSize": 3,
    "size": 3,
    "startRow": 1,
    "endRow": 3,
    "pages": 18,
    "prePage": 0,
    "nextPage": 2,
    "isFirstPage": true,
    "isLastPage": false,
    "hasPrevIoUsPage": false,
    "hasNextPage": true,
    "navigatePages": 8,
    "navigatepageNums": [
        1,
        2,
        3,
        4,
        5,
        6,
        7,
        8
    ],
    "navigateFirstPage": 1,
    "navigateLastPage": 8
}

8、使用druid的监控功能

9.Spring Boot 集成 MyBatis (pagehelper 分页查询)

1. 加依赖包

<!--分页拦截器-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.5</version>
</dependency>

2. 配置 application.yml

pagehelper:
    helperDialect: mysql
    reasonable: true
    supportMethodsArguments: true
    params: count=countSql
    rowBoundsWithCount: true
    offset-as-page-num: true

3. 编写 AdminController 类

    @RequestMapping(value = "/getAdminListMap/{account}")
    public List<Map<String, Object>> getAdminListMap(@PathVariable("account") String account) {
        /**
         * 第一个参数：第几页
         * 第二个参数：每页获取的条数
         */
        PageHelper.startPage(1,2);
        List<Map<String, Object>> adminListMap = adminService.getAdminListMap(account);
        PageInfo<Map<String, Object>> pageInfo = new PageInfo<>(adminListMap);
        System.out.println("总记录数：" + pageInfo.getTotal());
        System.out.println("总记页数：" + pageInfo.getPages());
        System.out.println("返回的记录数：" + adminListMap.size());

        return adminListMap;
    }

4. 测试

Mybatis (八) Mybatis整合PageHelper实现分页

整合PageHelper实现分页

[TOC]

由于为了后续使用SpringBoot，本人还是推荐使用Java配置类来操作，但是这里还是提一下XML配置。（本文项目基于第六节Mybatis集成Spring操作）

XML配置方式

使用XML文件来配置Mybatis的PageHelper分页插件：

mybatis-configuration:(mybatis的全局配置文件)

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <!--配置开启自动匹配驼峰-->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
	<!--配置PageHelper分页插件拦截器-->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <property name="offsetAsPageNum" value="true"/>
            <property name="helperDialect" value="mysql"/>
            <property name="rowBoundsWithCount" value="true"/>
            <property name="reasonable" value="true"/>
        </plugin>
    </plugins>
</configuration>

Java配置类方式

完整的配置类：

@Configuration //标注为一个配置类
@PropertySource(value = "classpath:application.properties") //加载属性文件
@ComponentScan(basePackages = "com.ooyhao.mybatis")  //组件扫描
@MapperScan(basePackages = {"com.ooyhao.mybatis.mapper"})  //mapper文件的扫描
@EnableTransactionManagement //开启事务管理
public class AppConfig {

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.driver}")
    private String driverClassName;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Value("${mybatis.configuration}")
    private String mybatisConfiguration;

    @Value("${mybatis.mapperLocations}")
    private String mybatisMapperLocations;

    @Value("${mybatis.typeAliasesPackage}")
    private String mybatisTypeAliasesPackage;

    /*配置数据源*/
    @Bean
    public DataSource dataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        druidDataSource.setUrl(url);
        druidDataSource.setDriverClassName(driverClassName);
        druidDataSource.setUsername(username);
        druidDataSource.setPassword(password);
        return druidDataSource;
    }

    @Bean
    public PageInterceptor pageInterceptor(){
        PageInterceptor pageInterceptor = new PageInterceptor();
        Properties properties = new Properties();
        /*4.0.0版本之后可以不用配置*/
        properties.setProperty("helperDialect","mysql");
        /*默认为false，会将RowBounds第一个参数offset当成pageNum页面使用
        * 和startPage中的pageNum效果一样*/
        properties.setProperty("offsetAsPageNum","true");
        /*RowBounds方式是否做count查询 默认false*/
        properties.setProperty("rowBoundsWithCount","true");
        /*分页合理化，true开启，如果分页参数不合理会自动修正。默认false不启用*/
        properties.setProperty("reasonable","true");
        /*是否允许接口方法参数来传递分页参数 默认false*/
        properties.setProperty("supportMethodsArguments","true");
        pageInterceptor.setProperties(properties);
        /*当设置为true的时候，如果pageSize设置为0（或RowBounds的limit=0），就不执行分页*/
        properties.setProperty("pageSizeZero","true");
        return pageInterceptor;
    }

    /*Mybatis的全局配置*/
    @Bean
    public SqlSessionFactoryBean sqlSessionFactoryBean(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        /*配置Mybatis的全局配置文件*/
        ClassPathResource resource = new ClassPathResource(mybatisConfiguration);
        sqlSessionFactoryBean.setConfigLocation(resource);
        /*配置Mapper.xml文件的路径*/
        PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        Resource[] resources = resolver.getResources(mybatisMapperLocations);
        sqlSessionFactoryBean.setMapperLocations(resources);
        /*配置别名包*/
        sqlSessionFactoryBean.setTypeAliasesPackage(mybatisTypeAliasesPackage);
        /*设置数据源，位置有要求，需要在下面几项之前*/
        sqlSessionFactoryBean.setDataSource(dataSource);
        /*将PageHelper分页插件以拦截器的形式配置*/
        sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageInterceptor()});
        /*配置驼峰命名*/
        sqlSessionFactoryBean.getObject().getConfiguration().setMapUnderscoreToCamelCase(true);
        /*配置日志类*/
        sqlSessionFactoryBean.getObject().getConfiguration().setLogImpl(StdOutImpl.class);
        /*设置开启缓存*/
        sqlSessionFactoryBean.getObject().getConfiguration().setCacheEnabled(true);
        return sqlSessionFactoryBean;
    }

    /*配置数据源事务管理器，需要将数据源注入*/
    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource){
        DataSourceTransactionManager transactionManager =
                new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }
}

提示：

添加了PageInterceptor 组件
通过 sqlSessionFactoryBean.setPlugins(new Interceptor[]{pageInterceptor()});设置到SqlSessionFactoryBean中

开启了这个properties.setProperty("supportMethodsArguments","true");则表示可以通过Mapper来进行参数传递，实现分页，如下：

List<Role> findByPage(@Param("pageNum") int pageNum,@Param("pageSize") int pageSize);

xml文件不需要修改，只需要在参数上添加形参即可。

PageHelper的PageInterceptor的参数说明：一下是PageParams类中的setProperties方法的源码：

public void setProperties(Properties properties) {
    //offset作为PageNum使用
    String offsetAsPageNum = properties.getProperty("offsetAsPageNum");
    this.offsetAsPageNum = Boolean.parseBoolean(offsetAsPageNum);
    //RowBounds方式是否做count查询
    String rowBoundsWithCount = properties.getProperty("rowBoundsWithCount");
    this.rowBoundsWithCount = Boolean.parseBoolean(rowBoundsWithCount);
    //当设置为true的时候，如果pagesize设置为0（或RowBounds的limit=0），就不执行分页
    String pageSizeZero = properties.getProperty("pageSizeZero");
    this.pageSizeZero = Boolean.parseBoolean(pageSizeZero);
    //分页合理化，true开启，如果分页参数不合理会自动修正。默认false不启用
    String reasonable = properties.getProperty("reasonable");
    this.reasonable = Boolean.parseBoolean(reasonable);
    //是否支持接口参数来传递分页参数，默认false
    String supportMethodsArguments = properties.getProperty("supportMethodsArguments");
    this.supportMethodsArguments = Boolean.parseBoolean(supportMethodsArguments);
    //默认count列
    String countColumn = properties.getProperty("countColumn");
    if(StringUtil.isNotEmpty(countColumn)){
      this.countColumn = countColumn;
    }
    //当offsetAsPageNum=false的时候，不能
    //参数映射
    PageObjectUtil.setParams(properties.getProperty("params"));
}

测试：

下面是测试结果，以及获取PageInfo中的各个参数。

public class AppTest {
    AnnotationConfigApplicationContext context = null;
    @Before
    public void init(){
        context = new AnnotationConfigApplicationContext(AppConfig.class);
    }

    @Test
    public void testFindByPage(){

        RoleService bean = context.getBean(RoleService.class);
        /*是否需要计算总条数*/
        List<Role> page = bean.findByPage(2, 2, true);
        PageInfo<Role> pageInfo = new PageInfo<>(page);
        //返回的是Page对象，Page是ArrayList的子类。由于Page重写了toString方法
        List<Role> list = pageInfo.getList();
        System.out.println(JSONObject.toJSONString(list));
        System.out.println(JSONObject.toJSON(list));
        //SQL查询的数据总条数
        System.out.println("total:"+pageInfo.getTotal());//22
        //总分页数
        System.out.println("pages:"+pageInfo.getPages());//8
        //自动生成一个分页导航，大小为8（如果满足）[1, 2, 3, 4, 5, 6, 7, 8]
        System.out.println("navigatepageNums:"+Arrays.toString(pageInfo.getNavigatepageNums()));
        //分页导航的第一页
        System.out.println("navigateFirstPage:"+pageInfo.getNavigateFirstPage());//1
        //分页导航的最后一页
        System.out.println("navigateLastPage:"+pageInfo.getNavigateLastPage());//8
        //分页导航的总页数
        System.out.println("navigatePages:"+pageInfo.getNavigatePages());//8
        //当前页
        System.out.println("pageNum:"+pageInfo.getPageNum());//2
        //当前页的上一页
        System.out.println("prePage:"+pageInfo.getPrePage());//1
        //当前页的下一页
        System.out.println("nextPage:"+pageInfo.getNextPage());//3
        //每页的数据条数
        System.out.println("pageSize:"+pageInfo.getPageSize());//3
        //当前页的开始行号
        System.out.println("startRow:"+pageInfo.getStartRow());//4
        //当前页的结束行号
        System.out.println("endRow:"+pageInfo.getEndRow());//6
    }
}

提示:

List<Role> list = pageInfo.getList();我们通过打印这个list对象是无法正常打印出Role对象的数据，是因为Page对象继承自ArrayList，并且重写了toString方法。我们可以通过迭代循环打印出来。如下图:

这里由于循环打印才能看到Role对象的真实面部，个人觉得麻烦，所以使用了fastJson格式化为Json，但是发现一个之前没有留意的问题：

通过上面打印出的结果可以发现，list既然是Page对象，但是我们可以看到Page类中有诸多属性，为何通过JSON格式化工具之后，就没有了呢？通过查询fastJson的toJson源码就可以发现奥秘了，如下：

public static Object toJSON(Object javaObject, SerializeConfig config) {
        ......
        if (javaObject instanceof Collection) {
            Collection<Object> collection = (Collection<Object>) javaObject;
            JSONArray array = new JSONArray(collection.size());
            for (Object item : collection) {
                Object jsonValue = toJSON(item, config);
                array.add(jsonValue);
            }
            return array;
        }
      	......
        String text = JSON.toJSONString(javaObject);
        return JSON.parse(text);
}

里面有这样一个判断，如果对象是Collection或其子类，则强转为Collection，所以我们会发现，在使用JSONObject.toJson或是toJsonString的时候，不管是ArrayList还是Page中的属性都没有了，这是因为取的是Collection。对于数据存储，需要进一步研究Collection系列集合，暂不涉及。

Page对象源码

下面我们看一下Page对象源码：

public class Page<E> extends ArrayList<E> implements Closeable {
    private static final long serialVersionUID = 1L;

    /**
     * 页码，从1开始
     */
    private int pageNum;
    /**
     * 页面大小
     */
    private int pageSize;
    /**
     * 起始行
     */
    private int startRow;
    /**
     * 末行
     */
    private int endRow;
    /**
     * 总数
     */
    private long total;
    /**
     * 总页数
     */
    private int pages;
    /**
     * 包含count查询
     */
    private boolean count = true;
    /**
     * 分页合理化
     */
    private Boolean reasonable;
    /**
     * 当设置为true的时候，如果pagesize设置为0（或RowBounds的limit=0），就不执行分页，返回全部结果
     */
    private Boolean pageSizeZero;
    /**
     * 进行count查询的列名
     */
    private String countColumn;
    /**
     * 排序
     */
    private String orderBy;
    /**
     * 只增加排序
     */
    private boolean orderByOnly;

    public Page() {
        super();
    }

    public Page(int pageNum, int pageSize) {
        this(pageNum, pageSize, true, null);
    }

    public Page(int pageNum, int pageSize, boolean count) {
        this(pageNum, pageSize, count, null);
    }

    private Page(int pageNum, int pageSize, boolean count, Boolean reasonable) {
        super(0);
        if (pageNum == 1 && pageSize == Integer.MAX_VALUE) {
            pageSizeZero = true;
            pageSize = 0;
        }
        this.pageNum = pageNum;
        this.pageSize = pageSize;
        this.count = count;
        calculateStartAndEndRow();
        setReasonable(reasonable);
    }

    /**
     * int[] rowBounds
     * 0 : offset
     * 1 : limit
     */
    public Page(int[] rowBounds, boolean count) {
        super(0);
        if (rowBounds[0] == 0 && rowBounds[1] == Integer.MAX_VALUE) {
            pageSizeZero = true;
            this.pageSize = 0;
        } else {
            this.pageSize = rowBounds[1];
            this.pageNum = rowBounds[1] != 0 
              ? (int) (Math.ceil(((double) rowBounds[0] + rowBounds[1]) / rowBounds[1])) : 0;
        }
        this.startRow = rowBounds[0];
        this.count = count;
        this.endRow = this.startRow + rowBounds[1];
    }

    public List<E> getResult() {
        return this;
    }

    public int getPages() {
        return pages;
    }

    public Page<E> setPages(int pages) {
        this.pages = pages;
        return this;
    }

    public int getEndRow() {
        return endRow;
    }

    public Page<E> setEndRow(int endRow) {
        this.endRow = endRow;
        return this;
    }

    public int getPageNum() {
        return pageNum;
    }

    public Page<E> setPageNum(int pageNum) {
        //分页合理化，针对不合理的页码自动处理
        this.pageNum = ((reasonable != null && reasonable) && pageNum <= 0) ? 1 : pageNum;
        return this;
    }

    public int getPageSize() {
        return pageSize;
    }

    public Page<E> setPageSize(int pageSize) {
        this.pageSize = pageSize;
        return this;
    }

    public int getStartRow() {
        return startRow;
    }

    public Page<E> setStartRow(int startRow) {
        this.startRow = startRow;
        return this;
    }

    public long getTotal() {
        return total;
    }

    public void setTotal(long total) {
        this.total = total;
        if (total == -1) {
            pages = 1;
            return;
        }
        if (pageSize > 0) {
            pages = (int) (total / pageSize + ((total % pageSize == 0) ? 0 : 1));
        } else {
            pages = 0;
        }
        //分页合理化，针对不合理的页码自动处理
        if ((reasonable != null && reasonable) && pageNum > pages) {
            pageNum = pages;
            calculateStartAndEndRow();
        }
    }

    public Boolean getReasonable() {
        return reasonable;
    }

    public Page<E> setReasonable(Boolean reasonable) {
        if (reasonable == null) {
            return this;
        }
        this.reasonable = reasonable;
        //分页合理化，针对不合理的页码自动处理
        if (this.reasonable && this.pageNum <= 0) {
            this.pageNum = 1;
            calculateStartAndEndRow();
        }
        return this;
    }

    public Boolean getPageSizeZero() {
        return pageSizeZero;
    }

    public Page<E> setPageSizeZero(Boolean pageSizeZero) {
        if (pageSizeZero != null) {
            this.pageSizeZero = pageSizeZero;
        }
        return this;
    }
    public String getOrderBy() {
        return orderBy;
    }

    public <E> Page<E> setOrderBy(String orderBy) {
        this.orderBy = orderBy;
        return (Page<E>) this;
    }

    public boolean isOrderByOnly() {
        return orderByOnly;
    }

    public void setOrderByOnly(boolean orderByOnly) {
        this.orderByOnly = orderByOnly;
    }

    /**
     * 计算起止行号
     */
    private void calculateStartAndEndRow() {
        this.startRow = this.pageNum > 0 ? (this.pageNum - 1) * this.pageSize : 0;
        this.endRow = this.startRow + this.pageSize * (this.pageNum > 0 ? 1 : 0);
    }

    public boolean isCount() {
        return this.count;
    }

    public Page<E> setCount(boolean count) {
        this.count = count;
        return this;
    }

    /**
     * 设置页码
     *
     * @param pageNum
     * @return
     */
    public Page<E> pageNum(int pageNum) {
        //分页合理化，针对不合理的页码自动处理
        this.pageNum = ((reasonable != null && reasonable) && pageNum <= 0) ? 1 : pageNum;
        return this;
    }

    /**
     * 设置页面大小
     *
     * @param pageSize
     * @return
     */
    public Page<E> pageSize(int pageSize) {
        this.pageSize = pageSize;
        calculateStartAndEndRow();
        return this;
    }

    /**
     * 是否执行count查询
     *
     * @param count
     * @return
     */
    public Page<E> count(Boolean count) {
        this.count = count;
        return this;
    }

    /**
     * 设置合理化
     *
     * @param reasonable
     * @return
     */
    public Page<E> reasonable(Boolean reasonable) {
        setReasonable(reasonable);
        return this;
    }

    /**
     * 当设置为true的时候，如果pagesize设置为0（或RowBounds的limit=0），就不执行分页，返回全部结果
     *
     * @param pageSizeZero
     * @return
     */
    public Page<E> pageSizeZero(Boolean pageSizeZero) {
        setPageSizeZero(pageSizeZero);
        return this;
    }

    /**
     * 指定 count 查询列
     *
     * @param columnName
     * @return
     */
    public Page<E> countColumn(String columnName) {
        this.countColumn = columnName;
        return this;
    }


    /**
     * 转换为PageInfo
     *
     * @return
     */
    public PageInfo<E> toPageInfo() {
        PageInfo<E> pageInfo = new PageInfo<E>(this);
        return pageInfo;
    }

    public <E> Page<E> doSelectPage(ISelect select) {
        select.doSelect();
        return (Page<E>) this;
    }

    public <E> PageInfo<E> doSelectPageInfo(ISelect select) {
        select.doSelect();
        return (PageInfo<E>) this.toPageInfo();
    }

    public long doCount(ISelect select) {
        this.pageSizeZero = true;
        this.pageSize = 0;
        select.doSelect();
        return this.total;
    }

    public String getCountColumn() {
        return countColumn;
    }

    public void setCountColumn(String countColumn) {
        this.countColumn = countColumn;
    }

    @Override
    public String toString() {
        return "Page{" +
                "count=" + count +
                ", pageNum=" + pageNum +
                ", pageSize=" + pageSize +
                ", startRow=" + startRow +
                ", endRow=" + endRow +
                ", total=" + total +
                ", pages=" + pages +
                ", reasonable=" + reasonable +
                ", pageSizeZero=" + pageSizeZero +
                ''}'';
    }

    @Override
    public void close() {
        PageHelper.clearPage();
    }
}

最后

如果觉得不错的话，那就关注一下小编哦！一起交流，一起学习

mybatis 使用 pagehelper-spring-boot-starter 与 pagehelper 的区别

一、在使用

pagehelper-spring-boot-starter时

在 pom.xml 引入

<!-- mybatis 分页 -->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>1.2.5</version>
</dependency>

在 application.yml 配置分页插件信息

#mybatis 分页
pagehelper:
  helperDialect: oracle
  reasonable: true
  supportMethodsArguments: true
  params: count=countSql

新建一个分页封装工具

public class PageUtils {

    /**
     * 将分页信息封装到统一的接口
     * @param pageRequest
     * @param pageInfo
     * @return
     */
    public static PageResult getPageResult(QueryParams pageRequest, PageInfo<?> pageInfo) {
        PageResult pageResult = new PageResult();
        pageResult.setPageNum(pageInfo.getPageNum());
        pageResult.setPageSize(pageInfo.getPageSize());
        pageResult.setTotalSize(pageInfo.getTotal());
        pageResult.setTotalPages(pageInfo.getPages());
        pageResult.setContent(pageInfo.getList());
        return pageResult;
    }
}

在 service 使用分页插件

//queryParams.getPage() 页数,queryParams.getRows() 行数 
PageHelper.startPage(queryParams.getPage(),queryParams.getRows());
List<SysUser> list = sysUserMapper.listPage();
PageInfo<SysUser> pageInfo = new PageInfo<SysUser>(list);
PageResult pageResult = PageUtils.getPageResult(queryParams,pageInfo);

二、在使用 pagehelper 时

在 pom.xml 引入

<!-- mybatis分页-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>5.1.4</version>
</dependency>

在 mybatisConfig.xml 加上

<!-- spring和MyBatis完美整合，不需要mybatis的配置映射文件 -->
<bean id="sqlSessionFactory"
      class="org.mybatis.spring.SqlSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <!-- 自动扫描mapping.xml文件 -->
    <property name="mapperLocations" value="classpath:mapper/*.xml"></property>
    <property name="typeAliasesPackage" value="com.xxx.xxx.common.model"></property>
    <property name="plugins">
        <array>
            <bean class="com.github.pagehelper.PageInterceptor">
                <!-- 这里的几个配置主要演示如何使用，如果不理解，一定要去掉下面的配置 -->
                <property name="properties">
                    <value>
                        helperDialect=oracle
                        reasonable=true
                        supportMethodsArguments=true
                        params=count=countSql
                        autoRuntimeDialect=true
                    </value>
                </property>
            </bean>
        </array>
    </property>
    <!-- 配置mybatis配置文件的位置 -->
    <!--<property name="configLocation" value="classpath:mybatis-config.xml"/>-->
</bean>

工具类新建一个也是一样的就可以，调用方式一样，就是在不同的地方配置，一个是使用 spring boot 的自动配置，

一个是我们自己在 mybatisConfig.xm 自己配置。

关于spring boot集成mybatis(2) - 使用pagehelper实现分页和springboot集成mybatisplus分页的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于6、SpringBoot-mybatis分页实现pagehelper、9.Spring Boot 集成 MyBatis (pagehelper 分页查询)、Mybatis (八) Mybatis整合PageHelper实现分页、mybatis 使用 pagehelper-spring-boot-starter 与 pagehelper 的区别的相关知识，请在本站寻找。

本文标签：