mybatis框架分页实现，有几种方式，最简单的就是利用原生的sql关键字limit来实现，还有一种就是利用interceptor来拼接sql，实现和limit一样的功能，再一个就是利用PageHelper来实现。这里讲解这三种常见的实现方式：
 
无论哪种实现方式，我们返回的结果，不能再使用List了，需要一个自定义对象Pager。
 
package com.xxx.mybatis.bean;
import java.util.List;
public class Pager<T> {
	private int page;//分页起始页
	private int size;//每页记录数
	private List<T> rows;//返回的记录集合
	private long total;//总记录条数
	public int getPage() {
		return page;
	}
	public void setPage(int page) {
		this.page = page;
	}
	public int getSize() {
		return size;
	}
	public void setSize(int size) {
		this.size = size;
	}
	public List<T> getRows() {
		return rows;
	}
	public void setRows(List<T> rows) {
		this.rows = rows;
	}
	public long getTotal() {
		return total;
	}
	public void setTotal(long total) {
		this.total = total;
	}
}
 
limit关键字实现：
 
UserDao.java增加两个方法
 
public List<User> findByPager(Map<String, Object> params);
public long count();
 
UserMapper.xml中增加两个查询
 
<select id="findByPager" resultType="com.xxx.mybatis.domain.User">
	select * from xx_user limit #{page},#{size}
</select>
<select id="count" resultType="long">
	select count(1) from xx_user
</select>
 
 UserService.java中增加分页方法
 
public Pager<User> findByPager(int page,int size){
	Map<String, Object> params = new HashMap<String, Object>();
	params.put("page", (page-1)*size);
	params.put("size", size);
	Pager<User> pager = new Pager<User>();
	List<User> list = userDao.findByPager(params);
	pager.setRows(list);
	pager.setTotal(userDao.count());
	return pager;
}
 
这是最直观的实现方式，也是最简单的，不用任何插件或者工具就能够很方便的实现的方法。 
 
interceptor plugin实现：
 
需要定义一个类实现Interceptor接口
 
MyPageInterceptor.java
 
package com.xxx.mybatis.bean;
import java.sql.Connection;
import java.util.Map;
import java.util.Properties;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Plugin;
import org.apache.ibatis.plugin.Signature;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.SystemMetaObject;
@Intercepts({@Signature(type=StatementHandler.class,method="prepare",args={Connection.class,Integer.class})})
public class MyPageInterceptor implements Interceptor {
	
	private int page;
	private int size;
	@SuppressWarnings("unused")
	private String dbType;

	@SuppressWarnings("unchecked")
	@Override
	public Object intercept(Invocation invocation) throws Throwable {
		System.out.println("plugin is running...");
		StatementHandler statementHandler = (StatementHandler)invocation.getTarget();
		MetaObject metaObject = SystemMetaObject.forObject(statementHandler);
		while(metaObject.hasGetter("h")){
			Object object = metaObject.getValue("h");
			metaObject = SystemMetaObject.forObject(object);
		}
		while(metaObject.hasGetter("target")){
			Object object = metaObject.getValue("target");
			metaObject = SystemMetaObject.forObject(object);
		}
		MappedStatement mappedStatement = (MappedStatement)metaObject.getValue("delegate.mappedStatement");
		String mapId = mappedStatement.getId();
		if(mapId.matches(".+ByPager$")){
			ParameterHandler parameterHandler = (ParameterHandler)metaObject.getValue("delegate.parameterHandler");
			Map<String, Object> params = (Map<String, Object>)parameterHandler.getParameterObject();
			page = (int)params.get("page");
			size = (int)params.get("size");
			String sql = (String) metaObject.getValue("delegate.boundSql.sql");
			sql += " limit "+(page-1)*size +","+size;
			metaObject.setValue("delegate.boundSql.sql", sql);
		}
		return invocation.proceed();
	}

	@Override
	public Object plugin(Object target) {
		return Plugin.wrap(target, this);
	}

	@Override
	public void setProperties(Properties properties) {
		String limit = properties.getProperty("limit","10");
		this.page = Integer.parseInt(limit);
		this.dbType = properties.getProperty("dbType", "mysql");
	}

}
 
我们之前在service的findByPager方法里面，为了给limit传入两个参数，其中page做了计算，这里使用拦截器的方式就无需计算了：
 
 
public Pager<User> findByPager(int page,int size){
	Map<String, Object> params = new HashMap<String, Object>();
	params.put("page", page);
	params.put("size", size);
	Pager<User> pager = new Pager<User>();
	List<User> list = userDao.findByPager(params);
	pager.setRows(list);
	pager.setTotal(userDao.count());
	return pager;
}
 
spring配置中，增加plugin设置:
 
 
到这里，你也许也猜到了MyPageInterceptor实际上是以一种拦截器的方式在程序执行findByPager方法的时候，对语句会增加limit page,size的拼接，还是和第一种原生实现思路一样，所以这里需要对UserMapper.xml配置文件中的findByPager这个查询对应的语句中的limit #{page},#{size}这部分去掉，变为如下的样子：
 
 
至此，通过拦截器插件的方式也实现了分页功能了。 
 
PageHelper实现：
 
这种方式实现需要我们引入maven依赖。
 
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>4.2.1</version>
 </dependency>
 
spring.xml配置文件做一下修改：
 
 <bean id="pageInterceptor" class="com.github.pagehelper.PageHelper">
	<property name="properties">
		<props>
			<prop key="helperDialect">mysql</prop>
			<prop key="reasonable">true</prop>
			<prop key="supportMethodsArguments">true</prop>
			<prop key="params">count=countSql</prop>
		</props>
	</property>
 </bean>

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="mapperLocations"  value="classpath:com/xxx/mybatis/dao/*Mapper.xml"/>
	<property name="plugins" ref="pageInterceptor"></property>
</bean> 
 
service层的方法，做一些修改：
 
public Pager<User> findByPager(int page,int size){
	Pager<User> pager = new Pager<User>();
	Page<User> res = PageHelper.startPage(page,size);
	userDao.findAll();
	pager.setRows(res.getResult());
	pager.setTotal(res.getTotal());
	return pager;
}
 
至此，PageHelper工具方法实现分页也实现了。其实PageHelper方法也是第二种使用Interceptor拦截器方式的一种三方实现，它内部帮助我们实现了Interceptor的功能。所以我们不用自定义MyPageInterceptor这个类了。实际上也是在运行查询方法的时候，进行拦截，然后设置分页参数。所以PageHelper.startPage(page,size)这一句需要显示调用，然后再执行userDao.findAll()，在查询所有用户信息的时候，会进行一个分页参数设置，让放回的结果只是分页的结果，而不是全部集合。

需求背景：
 
在实际项目开发中，有时候需要对从数据库查出的数据进行添加、修改、拼接等一系列处理，处理完成后再对数据进行分页。这时候pageHelper就不再适用了，因为pageHelper是对查询sql的修改，添加分页语句实现的分页。这时候，就需要自己手动分页。
 
代码：
 
		Integer page = pageBean.getPage();
        Integer size = pageBean.getSize();
        List<HistoryOrderVO> responseList = new ArrayList<>();
        Integer listSize = historyOrderVOList.size();
        responseList = historyOrderVOList.subList((page-1)*size > listSize ? listSize: (page-1)*size, page*size > listSize ? listSize: page*size);
        return new PageResponseVO(MessageCode.SUCCESS.getStatus(),MessageCode.SUCCESS.getMsg(),responseList,Long.valueOf(listSize));
 
说明：
 
historyOrderVOList为所有的数据集合，responseList 为要返回给前端的分页的集合，利用分页参数用subList()方法将集合拆分。page为页码，size为每页容量。
 
使用时需要判断传入的page和size是否超过数据集合的大小，否则会出现arraysOutOfIndexException。

1.支持limit n,m语法的hive版本
 
#!/bin/bash
cnt=$(set hive.cli.print.header=false;hive -e "select count(*) from exam.userbehavior;")
echo "总记录数:   $cnt 条"
#每页10条
pageSize=10
pageNum=`expr $(($cnt + $pageSize - 1))  / $pageSize`
echo "总页数:   $pageNum 页"
for((a=0;a<=$pageNum;a++))
do
        x=`expr $a + 1`
        echo "***********第$x页记录**********"
        hive -e "select * from exam.userbehavior limit $a,$pageSize;"
done
 
2.不支持limit n,m使用row_number实现
 
这种方式使用row_number最好写一个临时表,不然每次都排序很耗性能
 
#!/bin/bash
cnt=$(set hive.cli.print.header=false;hive -e "select count(*) from exam.userbehavior;")
echo "总记录数:   $cnt 条"
for((a=1;a<=$cnt;a+=10))
do
	x=`expr $a + 9`
	hive -e "
	select *
	from
	(select *,row_number() over(order by user_id) as rn from exam.userbehavior) a
	where a.rn between $a and $x
	"
done

什么是分页技术
 
分页,是一种将所有数据分段展示给用户的技术.用户每次看到的不是全部数据,而是其中的一部分,如果在其中没有找到自习自己想要的内容,用户可以通过制定页码或是翻页的方式转换可见内容,直到找到自己想要的内容为止.其实这和我们阅读书籍很类似
 
分页的意义
 
分页确实有效,但它一定会加大系统的复杂度,但可否不分页呢?如果数据量少的话当然可以.但是对于企业信息系统来说数据量不会限制在一个小范围内.如果不顾一切的Select * from某个表,再将返回的数据一古脑的扔给客户,即使客户能够忍受成千上万足够让人眼花缭乱的表格式数据,繁忙的网络,紧张的服务器也会提出它们无声的抗议,甚至有时会以彻底的罢工作为终结
 
从请求发起到返回数据的整个过程
 
现在你已经下定决心想要分页了,在动手书写代码之前,先让我们回想一下,在典型的三层架构中,从请求发起到返回数据的整个过程.如下所示:
 
 
分页的实现
 
用户发起请求，后他查询数据库返回所有的条数，并且返回用户所需要的数据，比方说用户请求的是第一页(page = 1)，用户设置的第一页的数据显示条数为50条(limit=50)，那么后台查询满足条件的数据，并且返回前50条给用户显示，此时用户看到的就是第一页的50条数据，加入用户请求的是第二页的数据，那么传给后台page为2，显示条数limit为50后台查询的就是符合条件的51-100条数据返回给用户