分页神器：PageHelper的使用教程

忘是亡心i 2023-05-28 05:25 2阅读 0赞

# 一、什么是PageHelper? #

## 1.PageHelper简介 ##

PageHelper是国内非常优秀的一款开源的mybatis分页插件，它支持基本的主流与常用的数据库。例如mysql、oracle、mariaDB、DB2、Hsqldb等。

## 2.PageHelper官网 ##

官网链接：(https://PageHelper.github.io)
      对于该开源项目刚兴趣的同学可以点进去阅读以下其官方文档，加深一下印象。

# 二、如何使用PageHelper? #

## 1.导入jar包（本案例使用maven导入） ##

在maven中导入依赖

<dependency>
       <groupId>com.github.pagehelper</groupId>
       <artifactId>pagehelper</artifactId>
       <version>5.1.2</version>
    </dependency>

## 2.配置 ##

特别注意，新版拦截器是 com.github.pagehelper.PageInterceptor 。 com.github.pagehelper.PageHelper 现在是一个特殊的 dialect 实现类，
    是分页插件的默认实现类，提供了和以前相同的用法。

### 2.1 mybatis里配置拦截器 ###

<plugins>
    
    <plugin interceptor="com.github.pagehelper.PageInterceptor">
    
    <property name="param1" value="value1"/>
    </plugin>
    </plugins>

### 2.2 spring里配置 ###

一般在使用时，我们的项目一般都是用spring集成了mybatis，所以配置在spring中会比较常见。

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    
    	<property name="plugins">
    		<array>
    			<bean class="com.github.pagehelper.PageInterceptor">
    				<property name="properties">
    				
    					<props>
    						
    						<prop key="helpDialect">mysql</prop>
    						<prop key="reasonable">true</prop>
    					</props>
    				</property>
    			</bean>
    		</array>
    	</property>
    </bean>

## 3、具体使用方法 ##

### 3.1分页插件参数介绍 ###

1.  helperDialect ：分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置helperDialect 属性来指定分页插件使用哪种方言。配置时，可以使用下面的缩写值：  
    oracle , mysql , mariadb , sqlite , hsqldb , postgresql , db2 , sqlserver , informix , h2 , sqlserver2012 , derby  
    特别注意：使用 SqlServer2012 数据库时，需要手动指定为 sqlserver2012 ，否则会使用 SqlServer2005 的方式进行分页。你也可以实现 AbstractHelperDialect ，然后配置该属性为实现类的全限定名称即可使用自定义的实现方法。
2.  offsetAsPageNum ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。 当该参数设置为  
    true 时，会将 RowBounds 中的 offset 参数当成 pageNum 使用，可以用页码和页面大小两个参数进行分页。
3.  rowBoundsWithCount ：默认值为 false ，该参数对使用 RowBounds 作为分页参数时有效。 当该参数设置为 true 时，使用 RowBounds 分页会进行 count 查询。
4.  pageSizeZero ：默认值为 false ，当该参数设置为 true 时，如果 pageSize=0 或者 RowBounds.limit =0 就会查询出全部的结果（相当于没有执行分页查询，但是返回结果仍然是 Page 类型）。
5.  reasonable ：分页合理化参数，默认值为 false 。当该参数设置为 true 时， pageNum<=0 时会查询第一页， pageNum>pages （超过总数时），会查询最后一页。默认 false 时，直接根据参数进行查询。
6.  params ：为了支持 startPage(Object params) 方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值， 可以配置 pageNum,pageSize,count,pageSizeZero,reasonable ，不配置映射的用默认值， 默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero  
    。
7.  supportMethodsArguments ：支持通过 Mapper 接口参数来传递分页参数，默认值 false ，分页插件会从查询方法的参数值中，自动根据上面 params 配置的字段中取值，查找到合适的值时就会自动分页。 使用方法  
    可以参考测试代码中的 com.github.pagehelper.test.basic 包下的ArgumentsMapTest 和ArgumentsObjTest 。
8.  autoRuntimeDialect ：默认值为 false 。设置为 true 时，允许在运行时根据多数据源自动识别对应方言的分页 （不支持自动选择 sqlserver2012 ，只能使用 sqlserver ），用法和注意事项参考下面的场景五。
9.  closeConn ：默认值为 true 。当使用运行时动态数据源或没有设置 helperDialect 属性自动获取数据库类型时，会自动获取一个数据库连接， 通过该属性来设置是否关闭获取的这个连接，默认 true 关闭，设置为false 后，不会关闭获取的连接，这个参数的设置要根据自己选择的数据源来决定。

### 3.2分页插件基本使用（最常用方法） ###

静态调用：  
特别注意：在查询语句前使用

//service层：
    //page:当前页码
    //size：每页行数
    PageHelper.startPage(page,size);
    dao.findALL();
    
    //controller层
    List<T> list = service.findAll(page,size);
    //pageInfo是一个分页bean
    PageInfo pageInfo = new (list);
    //把pageInfo数据传入到前端
    ModelAndView m = new ModelAndView();
    m.addObject("pageInfo",pageInfo);
    m.setViewName("orders-list");
    return m;

关于一些pageInfo的参数定义和使用，可以参考具体PageInfo类

/*
     * The MIT License (MIT)
     *
     * Copyright (c) 2014 abel533@gmail.com
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     * THE SOFTWARE.
     */
    
    package com.github.pagehelper;
    
    import java.io.Serializable;
    import java.util.List;
    
    /**
     * 对Page<E>结果进行包装
     * <p/>
     * 新增分页的多项属性，主要参考:http://bbs.csdn.net/topics/360010907
     *
     * @author liuzh/abel533/isea533
     * @version 3.3.0
     * @since 3.2.2
     * 项目地址 : http://git.oschina.net/free/Mybatis_PageHelper
     */
    @SuppressWarnings({
        "rawtypes", "unchecked"})
    public class PageInfo<T> implements Serializable {
        
        private static final long serialVersionUID = 1L;
        //当前页
        private int pageNum;
        //每页的数量
        private int pageSize;
        //当前页的数量
        private int size;
        //由于startRow和endRow不常用，这里说个具体的用法
        //可以在页面中"显示startRow到endRow 共size条数据"
    
        //当前页面第一个元素在数据库中的行号
        private int startRow;
        //当前页面最后一个元素在数据库中的行号
        private int endRow;
        //总记录数
        private long total;
        //总页数
        private int pages;
        //结果集
        private List<T> list;
    
        //第一页
        private int firstPage;
        //前一页
        private int prePage;
        //下一页
        private int nextPage;
        //最后一页
        private int lastPage;
    
        //是否为第一页
        private boolean isFirstPage = false;
        //是否为最后一页
        private boolean isLastPage = false;
        //是否有前一页
        private boolean hasPreviousPage = false;
        //是否有下一页
        private boolean hasNextPage = false;
        //导航页码数
        private int navigatePages;
        //所有导航页号
        private int[] navigatepageNums;
    
        public PageInfo() {
        
        }
    
        /**
         * 包装Page对象
         *
         * @param list
         */
        public PageInfo(List<T> list) {
        
            this(list, 8);
        }
    
        /**
         * 包装Page对象
         *
         * @param list          page结果
         * @param navigatePages 页码数量
         */
        public PageInfo(List<T> list, int navigatePages) {
        
            if (list instanceof Page) {
        
                Page page = (Page) list;
                this.pageNum = page.getPageNum();
                this.pageSize = page.getPageSize();
    
                this.total = page.getTotal();
                this.pages = page.getPages();
                this.list = page;
                this.size = page.size();
                //由于结果是>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;
                }
                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) {
        
                firstPage = navigatepageNums[0];
                lastPage = 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;
        }
    
        public int getPageNum() {
        
            return pageNum;
        }
    
        public void setPageNum(int pageNum) {
        
            this.pageNum = pageNum;
        }
    
        public int getPageSize() {
        
            return pageSize;
        }
    
        public void setPageSize(int pageSize) {
        
            this.pageSize = pageSize;
        }
    
        public int getSize() {
        
            return size;
        }
    
        public void setSize(int size) {
        
            this.size = size;
        }
    
        public int getStartRow() {
        
            return startRow;
        }
    
        public void setStartRow(int startRow) {
        
            this.startRow = startRow;
        }
    
        public int getEndRow() {
        
            return endRow;
        }
    
        public void setEndRow(int endRow) {
        
            this.endRow = endRow;
        }
    
        public long getTotal() {
        
            return total;
        }
    
        public void setTotal(long total) {
        
            this.total = total;
        }
    
        public int getPages() {
        
            return pages;
        }
    
        public void setPages(int pages) {
        
            this.pages = pages;
        }
    
        public List<T> getList() {
        
            return list;
        }
    
        public void setList(List<T> list) {
        
            this.list = list;
        }
    
        public int getFirstPage() {
        
            return firstPage;
        }
    
        public void setFirstPage(int firstPage) {
        
            this.firstPage = firstPage;
        }
    
        public int getPrePage() {
        
            return prePage;
        }
    
        public void setPrePage(int prePage) {
        
            this.prePage = prePage;
        }
    
        public int getNextPage() {
        
            return nextPage;
        }
    
        public void setNextPage(int nextPage) {
        
            this.nextPage = nextPage;
        }
    
        public int getLastPage() {
        
            return lastPage;
        }
    
        public void setLastPage(int lastPage) {
        
            this.lastPage = lastPage;
        }
    
        public boolean isIsFirstPage() {
        
            return isFirstPage;
        }
    
        public void setIsFirstPage(boolean isFirstPage) {
        
            this.isFirstPage = isFirstPage;
        }
    
        public boolean isIsLastPage() {
        
            return isLastPage;
        }
    
        public void setIsLastPage(boolean isLastPage) {
        
            this.isLastPage = isLastPage;
        }
    
        public boolean isHasPreviousPage() {
        
            return hasPreviousPage;
        }
    
        public void setHasPreviousPage(boolean hasPreviousPage) {
        
            this.hasPreviousPage = hasPreviousPage;
        }
    
        public boolean isHasNextPage() {
        
            return hasNextPage;
        }
    
        public void setHasNextPage(boolean hasNextPage) {
        
            this.hasNextPage = hasNextPage;
        }
    
        public int getNavigatePages() {
        
            return navigatePages;
        }
    
        public void setNavigatePages(int navigatePages) {
        
            this.navigatePages = navigatePages;
        }
    
        public int[] getNavigatepageNums() {
        
            return navigatepageNums;
        }
    
        public void setNavigatepageNums(int[] navigatepageNums) {
        
            this.navigatepageNums = navigatepageNums;
        }
    
        @Override
        public String toString() {
        
            final StringBuffer sb = new StringBuffer("PageInfo{");
            sb.append("pageNum=").append(pageNum);
            sb.append(", pageSize=").append(pageSize);
            sb.append(", size=").append(size);
            sb.append(", startRow=").append(startRow);
            sb.append(", endRow=").append(endRow);
            sb.append(", total=").append(total);
            sb.append(", pages=").append(pages);
            sb.append(", list=").append(list);
            sb.append(", firstPage=").append(firstPage);
            sb.append(", prePage=").append(prePage);
            sb.append(", nextPage=").append(nextPage);
            sb.append(", lastPage=").append(lastPage);
            sb.append(", isFirstPage=").append(isFirstPage);
            sb.append(", isLastPage=").append(isLastPage);
            sb.append(", hasPreviousPage=").append(hasPreviousPage);
            sb.append(", hasNextPage=").append(hasNextPage);
            sb.append(", navigatePages=").append(navigatePages);
            sb.append(", navigatepageNums=");
            if (navigatepageNums == null) sb.append("null");
            else {
        
                sb.append('[');
                for (int i = 0; i < navigatepageNums.length; ++i)
                    sb.append(i == 0 ? "" : ", ").append(navigatepageNums[i]);
                sb.append(']');
            }
            sb.append('}');
            return sb.toString();
        }
    }

通过类里的参数和方法来实现分页，前端内容就不详细讲述了。