Spring Mybatis PageHelper

1.依赖的导入

<!-- 添加Mybatis依赖 -->  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis</artifactId>  
            <version></version>  
        </dependency>  
        <dependency>  
            <groupId>org.mybatis</groupId>  
            <artifactId>mybatis-spring</artifactId>  
            <version></version>  
        </dependency>  
<!-- pageHelper -->  
        <dependency>  
            <groupId>com.github.pagehelper</groupId>  
            <artifactId>pagehelper</artifactId>  
            <version></version>  
        </dependency>  

版本号需要对应：可直接去 https://mvnrepository.com/ 找出对应版本

2.Mybatis-config,xml 引入插件

<?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>  
    <plugins>  
        <plugin interceptor="com.github.pagehelper.PageHelper">  
            <!--指明数据库 4.0.0以后不需要设置此属性-->  
            <property name="dialect" value="mysql"/>  
            <!-- 该参数默认为false -->  
            <!-- 设置为true时，会将RowBounds第一个参数offset当成pageNum页码使用 -->  
            <!-- 和startPage中的pageNum效果一样-->  
            <property name="offsetAsPageNum" value="true"/>  
            <!-- 该参数默认为false -->  
            <!-- 设置为true时，使用RowBounds分页会进行count查询 -->  
            <property name="rowBoundsWithCount" value="true"/>  
            <!-- 设置为true时，如果pageSize=0或者RowBounds.limit = 0就会查询出全部的结果 -->  
            <!-- （相当于没有执行分页查询，但是返回结果仍然是Page类型）-->  
            <property name="pageSizeZero" value="true"/>  
            <!-- 3.3.0版本可用 - 分页参数合理化，默认false禁用 -->  
            <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->  
            <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->  
            <property name="reasonable" value="true"/>  
            <!-- 3.5.0版本可用 - 为了支持startPage(Object params)方法 -->  
            <!-- 增加了一个`params`参数来配置参数映射，用于从Map或ServletRequest中取值 -->  
            <!-- 可以配置pageNum,pageSize,count,pageSizeZero,reasonable,orderBy,不配置映射的用默认值 -->  
            <!-- 不理解该含义的前提下，不要随便复制该配置 -->  
            <property name="params" value="pageNum=start;pageSize=limit;"/>  
            <!-- 支持通过Mapper接口参数来传递分页参数 -->  
            <property name="supportMethodsArguments" value="true"/>  
            <!-- always总是返回PageInfo类型,check检查返回类型是否为PageInfo,none返回Page -->  
            <property name="returnPageInfo" value="check"/>  
        </plugin>  
    </plugins>  
</configuration>  

3.Spring配置文件

配置Mybatis的SqlSessionFactory，将mybatis-config.xml添加到属性中

<!-- SqlSessionFactory -->  
    <bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">  
        <!--设置数据源-->  
        <property name="dataSource" ref="dataSource"></property>  
        <!--设置映射文件-->  
        <property name="mapperLocations" value="classpath:mybatis/sqlmap/mapper/*.xml"></property>  
        <!--设置pageHelper-->  
        <property name="configLocation" value="classpath:mybatis/mybatis-config.xml"></property>  
    </bean> 

4.实现方式

使用Mybatis的mapper接口进行查询，在查询时，需要使用PageHelper.startPage方法。

public PageInfo getBooksBypagehelper(int page,Book book) {    
    PageHelper.startPage(page, 2);    
    List books=bookDAO.getBookByCondition(book);//按条件查询数据!    
    PageInfo pageInfo = new PageInfo<>(books);//返回PageInfo对象    
    return pageInfo;    
}   

一般使用PageInfo封装Page，PageInfo中有更多的分页属性，例如isFirstPage是否为首页、isLastPage是否为末尾、hasNextPage是否存在下一页等

5.PageInfo源码分析

查看PageInfo源码可以看到其实现了Serializable接口，开启可序列化操作。

package com.github.pagehelper;  
  
import java.io.Serializable;  
import java.util.Collection;  
import java.util.List;  
  
/** 
 * 对Page结果进行包装 
 * 
 * 新增分页的多项属性，主要参考:http://bbs.csdn.net/topics/360010907 
 * 
 * 项目地址 : http://git.oschina.net/free/Mybatis_PageHelper 
 */  
@SuppressWarnings({"rawtypes", "unchecked"})  
public class PageInfo implements Serializable {  
    private static final long serialVersionUID = 1L;  
    //当前页  
    private int pageNum;  
    //每页的数量  
    private int pageSize;  
    //当前页的数量  
    private int size;  
    //排序  
    private String orderBy;  
  
    //由于startRow和endRow不常用，这里说个具体的用法  
    //可以在页面中"显示startRow到endRow 共size条数据"  
  
    //当前页面第一个元素在数据库中的行号  
    private int startRow;  
    //当前页面最后一个元素在数据库中的行号  
    private int endRow;  
    //总记录数  
    private long total;  
    //总页数  
    private int pages;  
    //结果集  
    private List list;  
  
    //前一页  
    private int prePage;  
    //下一页  
    private int nextPage;  
  
    //是否为第一页  
    private boolean isFirstPage = false;  
    //是否为最后一页  
    private boolean isLastPage = false;  
    //是否有前一页  
    private boolean hasPreviousPage = false;  
    //是否有下一页  
    private boolean hasNextPage = false;  
    //导航页码数  
    private int navigatePages;  
    //所有导航页号  
    private int[] navigatepageNums;  
    //导航条上的第一页  
    private int navigateFirstPage;  
    //导航条上的最后一页  
    private int navigateLastPage;  
  
    public PageInfo() {  
    }  
  
    /** 
     * 包装Page对象 
     * 
     * @param list 
     */  
    public PageInfo(List list) {  
        this(list, 8);  
    }  
  
    /** 
     * 包装Page对象 
     * 
     * @param list          page结果 
     * @param navigatePages 页码数量 
     */  
    public PageInfo(List list, int navigatePages) {  
        if (list instanceof Page) {  
            Page page = (Page) list;  
            this.pageNum = page.getPageNum();  
            this.pageSize = page.getPageSize();  
            this.orderBy = page.getOrderBy();  
  
            this.pages = page.getPages();  
            this.list = page;  
            this.size = page.size();  
            this.total = page.getTotal();  
            //由于结果是>startRow的，所以实际的需要+1  
            if (this.size == 0) {  
                this.startRow = 0;  
                this.endRow = 0;  
            } else {  
                this.startRow = page.getStartRow() + 1;  
                //计算实际的endRow（最后一页的时候特殊）  
                this.endRow = this.startRow - 1 + this.size;  
            }  
        } else if (list instanceof Collection) {  
            this.pageNum = 1;  
            this.pageSize = list.size();  
  
            this.pages = 1;  
            this.list = list;  
            this.size = list.size();  
            this.total = list.size();  
            this.startRow = 0;  
            this.endRow = list.size() > 0 ? list.size() - 1 : 0;  
        }  
        if (list instanceof Collection) {  
            this.navigatePages = navigatePages;  
            //计算导航页  
            calcNavigatepageNums();  
            //计算前后页，第一页，最后一页  
            calcPage();  
            //判断页面边界  
            judgePageBoudary();  
        }  
    }  
  
    /** 
     * 计算导航页 
     */  
    private void calcNavigatepageNums() {  
        //当总页数小于或等于导航页码数时  
        if (pages <= navigatePages) {  
            navigatepageNums = new int[pages];  
            for (int i = 0; i < pages; i++) {  
                navigatepageNums[i] = i + 1;  
            }  
        } else { //当总页数大于导航页码数时  
            navigatepageNums = new int[navigatePages];  
            int startNum = pageNum - navigatePages / 2;  
            int endNum = pageNum + navigatePages / 2;  
  
            if (startNum < 1) {  
                startNum = 1;  
                //(最前navigatePages页  
                for (int i = 0; i < navigatePages; i++) {  
                    navigatepageNums[i] = startNum++;  
                }  
            } else if (endNum > pages) {  
                endNum = pages;  
                //最后navigatePages页  
                for (int i = navigatePages - 1; i >= 0; i--) {  
                    navigatepageNums[i] = endNum--;  
                }  
            } else {  
                //所有中间页  
                for (int i = 0; i < navigatePages; i++) {  
                    navigatepageNums[i] = startNum++;  
                }  
            }  
        }  
    }  
  
    /** 
     * 计算前后页，第一页，最后一页 
     */  
    private void calcPage() {  
        if (navigatepageNums != null && navigatepageNums.length > 0) {  
            navigateFirstPage = navigatepageNums[0];  
            navigateLastPage = navigatepageNums[navigatepageNums.length - 1];  
            if (pageNum > 1) {  
                prePage = pageNum - 1;  
            }  
            if (pageNum < pages) {  
                nextPage = pageNum + 1;  
            }  
        }  
    }  
  
    /** 
     * 判定页面边界 
     */  
    private void judgePageBoudary() {  
        isFirstPage = pageNum == 1;  
        isLastPage = pageNum == pages;  
        hasPreviousPage = pageNum > 1;  
        hasNextPage = pageNum < pages;  
    }  
  ......
}  

而PageHelper则继承自BasePageHelper抽象类

package com.github.pagehelper;  
import com.github.pagehelper.util.SqlUtil;  
import org.apache.ibatis.executor.Executor;  
import org.apache.ibatis.mapping.MappedStatement;  
import org.apache.ibatis.plugin.*;  
import org.apache.ibatis.session.ResultHandler;  
import org.apache.ibatis.session.RowBounds;  
  
import java.util.Properties;  
  
/** 
 * Mybatis - 通用分页拦截器
 * 项目地址 : http://git.oschina.net/free/Mybatis_PageHelper 
 * 
 */  
@SuppressWarnings("rawtypes")  
@Intercepts(@Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}))  
public class PageHelper extends BasePageHelper implements Interceptor {  
    private final SqlUtil sqlUtil = new SqlUtil();  
  
    @Override  
    public Object intercept(Invocation invocation) throws Throwable {  
        return sqlUtil.intercept(invocation);  
    }  
  
    @Override  
    public Object plugin(Object target) {  
        return Plugin.wrap(target, this);  
    }  
  
    @Override  
    public void setProperties(Properties properties) {  
        sqlUtil.setProperties(properties);  
    }  
}  

BasePageHelper中则是封装了正对数据进行分页的系列操作：

6.BasePageHelper源码方法

package com.github.pagehelper;  
import com.github.pagehelper.util.SqlUtil;  
  
public abstract class BasePageHelper {  
    /** 
     * 获取任意查询方法的count总数 
     * 
     * @param select 
     * @return 
     */  
    public static long count(ISelect select) {  
        Page page = startPage(1, -1, true);  
        select.doSelect();  
        return page.getTotal();  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param pageNum  页码 
     * @param pageSize 每页显示数量 
     */  
    public static  Page startPage(int pageNum, int pageSize) {  
        return startPage(pageNum, pageSize, true);  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param pageNum  页码 
     * @param pageSize 每页显示数量 
     * @param count    是否进行count查询 
     */  
    public static  Page startPage(int pageNum, int pageSize, boolean count) {  
        return startPage(pageNum, pageSize, count, null);  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param pageNum  页码 
     * @param pageSize 每页显示数量 
     * @param orderBy  排序 
     */  
    public static  Page startPage(int pageNum, int pageSize, String orderBy) {  
        Page page = startPage(pageNum, pageSize);  
        page.setOrderBy(orderBy);  
        return page;  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param offset 页码 
     * @param limit  每页显示数量 
     */  
    public static  Page offsetPage(int offset, int limit) {  
        return offsetPage(offset, limit, true);  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param offset 页码 
     * @param limit  每页显示数量 
     * @param count  是否进行count查询 
     */  
    public static  Page offsetPage(int offset, int limit, boolean count) {  
        Page page = new Page(new int[]{offset, limit}, count);  
        //当已经执行过orderBy的时候  
        Page oldPage = SqlUtil.getLocalPage();  
        if (oldPage != null && oldPage.isOrderByOnly()) {  
            page.setOrderBy(oldPage.getOrderBy());  
        }  
        SqlUtil.setLocalPage(page);  
        return page;  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param offset  页码 
     * @param limit   每页显示数量 
     * @param orderBy 排序 
     */  
    public static  Page offsetPage(int offset, int limit, String orderBy) {  
        Page page = offsetPage(offset, limit);  
        page.setOrderBy(orderBy);  
        return page;  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param pageNum    页码 
     * @param pageSize   每页显示数量 
     * @param count      是否进行count查询 
     * @param reasonable 分页合理化,null时用默认配置 
     */  
    public static  Page startPage(int pageNum, int pageSize, boolean count, Boolean reasonable) {  
        return startPage(pageNum, pageSize, count, reasonable, null);  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param pageNum      页码 
     * @param pageSize     每页显示数量 
     * @param count        是否进行count查询 
     * @param reasonable   分页合理化,null时用默认配置 
     * @param pageSizeZero true且pageSize=0时返回全部结果，false时分页,null时用默认配置 
     */  
    public static  Page startPage(int pageNum, int pageSize, boolean count, Boolean reasonable, Boolean pageSizeZero) {  
        Page page = new Page(pageNum, pageSize, count);  
        page.setReasonable(reasonable);  
        page.setPageSizeZero(pageSizeZero);  
        //当已经执行过orderBy的时候  
        Page oldPage = SqlUtil.getLocalPage();  
        if (oldPage != null && oldPage.isOrderByOnly()) {  
            page.setOrderBy(oldPage.getOrderBy());  
        }  
        SqlUtil.setLocalPage(page);  
        return page;  
    }  
  
    /** 
     * 开始分页 
     * 
     * @param params 
     */  
    public static  Page startPage(Object params) {  
        Page page = SqlUtil.getPageFromObject(params);  
        //当已经执行过orderBy的时候  
        Page oldPage = SqlUtil.getLocalPage();  
        if (oldPage != null && oldPage.isOrderByOnly()) {  
            page.setOrderBy(oldPage.getOrderBy());  
        }  
        SqlUtil.setLocalPage(page);  
        return page;  
    }  
  
    /** 
     * 排序 
     * 
     * @param orderBy 
     */  
    public static void orderBy(String orderBy) {  
        Page page = SqlUtil.getLocalPage();  
        if (page != null) {  
            page.setOrderBy(orderBy);  
        } else {  
            page = new Page();  
            page.setOrderBy(orderBy);  
            page.setOrderByOnly(true);  
            SqlUtil.setLocalPage(page);  
        }  
    }  
  
    /** 
     * 手动清空分页数据 
     */  
    public static void clearPage(){  
        SqlUtil.clearLocalPage();  
    }  
}