JSP标签实现分页功能（ORM-mybatis）

分页对象

package com.pcitc.modules.pagination;

import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
/**
* 通用分页类
* @author mi
*
* @param <T>
*/
public class Pagination<T> implements Serializable{

private static final long serialVersionUID = 1L;
public static final int DEF_PAGE_SIZE = 3; //默认显示10条数据
public static final int DEF_DISLAY_PAGENUM = 10; //默认显示十个页码

protected int displayPageNum = DEF_DISLAY_PAGENUM; //默认显示10个页码
protected int totalCount = 0; //总记录条数
protected int pageSize = DEF_PAGE_SIZE; //页面中显示的数据多少
protected int pageNo = 1; //当前页码
protected List<T> pageData; //分页中显示的数据的集合

protected int startRow = 0;//起始行
protected int totalPageNo; //总的页码数
protected int[] pageNums; //页面显示的页码集

private String pageSizeName;
private String pageNoName;
private String totalCountName;

public Pagination() {
}

/**
* 构造器
*
* @param pageNo
*            页码
* @param pageSize
*            每页几条数据
* @param totalCount
*            总共几条数据
*/
public Pagination(int pageNo, int pageSize, int totalCount) {

setPageSize(pageSize);
setTotalCount(totalCount);
setPageNo(pageNo);

calculateTotalPageNo(); //计算总的页码数
adjustPageNo(); //调整页码
caculateStartRow(); //进行startRow的计算
calculateDisNum(); //进行页码显示计算

}

/**
* 进行总的参数的调整，适合setter所有参数后，进行参数的调整
*/
public void adjustAllProcess(){
calculateTotalPageNo(); //计算总的页码数
adjustPageNo(); //调整页码
caculateStartRow(); //进行startRow的计算
calculateDisNum(); //进行页码显示计算
}

/**
* 调整传入的请求页码
*/
public void adjustPageNo() {

if(this.totalPageNo < this.pageNo && this.totalPageNo > 0){
this.pageNo = this.totalPageNo;
}
}

/**
* 进行startRow的计算
*/
public void caculateStartRow() {
this.startRow = (this.pageNo -1) * this.pageSize;
}

/**
* 计算总的页码数，注意这样一定要先注入pageSize和totalCount
*/
public void calculateTotalPageNo() {
this.totalPageNo = this.totalCount%this.pageSize == 0?this.totalCount/this.pageSize:this.totalCount/this.pageSize+1;
}

/**
* 获得页码
*/
public int getPageNo() {
return pageNo;
}

/**
* 每页几条数据
*/
public int getPageSize() {
return pageSize;
}

/**
* 总共几条数据
*/
public int getTotalCount() {
return totalCount;
}

/**
* 是否第一页
*/
public boolean isFirstPage() {
return pageNo <= 1;
}

/**
* 是否最后一页
*/
public boolean isLastPage() {
return pageNo >= this.totalPageNo;
}

/**
* 下一页页码
*/
public int getNextPage() {
if (isLastPage()) {
return pageNo;
} else {
return pageNo + 1;
}
}

/**
* 上一页页码
*/
public int getPrePage() {
if (isFirstPage()) {
return pageNo;
} else {
return pageNo - 1;
}
}

/**
* if totalCount<0 then totalCount=0
*
* @param totalCount
*/
public void setTotalCount(int totalCount) {
if (totalCount < 0) {
this.totalCount = 0;
} else {
this.totalCount = totalCount;
}
}

/**
* if pageSize< 1 then pageSize=DEF_COUNT
*
* @param pageSize
*/
public void setPageSize(int pageSize) {
if (pageSize < 1) {
this.pageSize = DEF_PAGE_SIZE;
} else {
this.pageSize = pageSize;
}
}

/**
* if pageNo < 1 then pageNo=1
*
* @param pageNo
*/
public void setPageNo(int pageNo) {
if (pageNo < 1) {
this.pageNo = 1;
} else {
this.pageNo = pageNo;
}
}

/**
* 进行显示页码的计算
*/
public void calculateDisNum(){

if(this.totalPageNo > this.displayPageNum){
this.pageNums = new int[this.displayPageNum];

int bet = (this.displayPageNum % 2 == 0 ? this.displayPageNum /2 : (this.displayPageNum /2+1));
if(this.pageNo <= bet){

for(int i=1;i<=this.displayPageNum;i++){
pageNums[i-1] = i;
}

}else{
//后面没有那么多
if((this.pageNo + bet) > this.totalPageNo){

for(int i=(this.totalPageNo-this.displayPageNum+1),j=0;i<=this.totalPageNo;i++,j++){
this.pageNums[j] = i;
}

}else{
//偶数
if(this.displayPageNum % 2 == 0){

for(int i=(this.pageNo-bet),j=0;i<=(this.pageNo+bet-1);i++){

this.pageNums[j] = i;
j++;
}
}else{
for(int i=(this.pageNo-bet+1),j=0;i<=(this.pageNo+bet-1);i++){
System.out.println(i);
this.pageNums[j] = i;
j++;
}
}
}
}

}else{
this.pageNums = new int[this.totalPageNo];
for(int i=1;i<=this.totalPageNo;i++){
this.pageNums[i-1] = i;
}
}

}
public List<T> getPageData() {
return pageData;
}

public void setPageData(List<T> pageData) {
this.pageData = pageData;
}

public int getStartRow() {

return startRow;
}

public void setStartRow(int startRow) {
this.startRow = startRow;
}

public int getTotalPageNo() {
return totalPageNo;
}

public void setTotalPageNo(int totalPageNo) {
this.totalPageNo = totalPageNo;
}

public int getDisplayPageNum() {
return displayPageNum;
}

public void setDisplayPageNum(int displayPageNum) {

if(displayPageNum <= 1){
this.displayPageNum = DEF_DISLAY_PAGENUM;
}else{
this.displayPageNum = displayPageNum;
}
}

@Override
public String toString() {
return "Pagination [displayPageNum=" + displayPageNum + ", totalCount="
+ totalCount + ", pageSize=" + pageSize + ", pageNo=" + pageNo
+ ", pageData=" + pageData + ", startRow=" + startRow
+ ", totalPageNo=" + totalPageNo + ", pageNums="
+ Arrays.toString(pageNums) + "]";
}

public int[] getPageNums() {
return pageNums;
}

public String getPageSizeName() {
return pageSizeName;
}

public void setPageSizeName(String pageSizeName) {
this.pageSizeName = pageSizeName;
}

public String getPageNoName() {
return pageNoName;
}

public void setPageNoName(String pageNoName) {
this.pageNoName = pageNoName;
}

public String getTotalCountName() {
return totalCountName;
}

public void setTotalCountName(String totalCountName) {
this.totalCountName = totalCountName;
}
}

Mybatis的plugin的实现

我这里选择拦截StatementHandler的prepare方法，也就是基本的JDBC中在发出SQL语句之的拦截，这里我们使用根据用户的SQL语句来查出相应的记录的总条数，因为在分页对象中这个参数是很必不可少的。

然后，进行分页（Pagination）参数的计算，当然这些计算已经封装在Pagination对象中。然后，根据计算的结果来进行重构Mybatis发出的SQL语句，也就是分页查询的最终SQL语句，对于Mysql和Orcale对于分页查询的语句是不同的，当然，这需要我们在配置插件的时候，进行指导数据库方言的属性。

对于用户来讲，这一切都是透明的。对于插件，我们都知道，这是在搭建框架的时候，我们总是用抽象的接口来组织逻辑，然后通过配置的方式来增加接口的实现，从而达到了插件的效果。这里进行配置是至关重要的，这里似乎用到AOP的思想，Advice为通知接口为我们自定义接口实现的逻辑方法，配置就相当于Advisor，Pointcut就是切入点。

package com.pcitc.modules.pagination;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;

import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.executor.statement.StatementHandler;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;
import org.apache.ibatis.mapping.BoundSql;
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.DefaultReflectorFactory;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.ReflectorFactory;
import org.apache.ibatis.reflection.factory.DefaultObjectFactory;
import org.apache.ibatis.reflection.factory.ObjectFactory;
import org.apache.ibatis.reflection.wrapper.DefaultObjectWrapperFactory;
import org.apache.ibatis.reflection.wrapper.ObjectWrapperFactory;
import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.RowBounds;

/**
* 通过拦截<code>StatementHandler</code>的<code>prepare</code>方法，重写sql语句实现物理分页。
* 老规矩，签名里要拦截的类型只能是接口。
*
* @author 湖畔微风
*
*/
@Intercepts({@Signature(type = StatementHandler.class, method = "prepare", args = {Connection.class})})
public class PageInterceptor implements Interceptor {

private static final Log logger = LogFactory.getLog(PageInterceptor.class);
private static final ObjectFactory DEFAULT_OBJECT_FACTORY = new DefaultObjectFactory();
private static final ObjectWrapperFactory DEFAULT_OBJECT_WRAPPER_FACTORY = new DefaultObjectWrapperFactory();
private static final ReflectorFactory DEFAULT_OBJECT_REFLECT_FACTORY = new DefaultReflectorFactory();

private static String defaultDialect = "mysql"; // 数据库类型(默认为mysql)
private static String dialect = ""; // 数据库类型(默认为mysql)

@Override
public Object intercept(Invocation invocation) throws Throwable {

//只重写需要分页的sql语句。通过MappedStatement的ID匹配，默认重写以Page结尾的MappedStatement的sql
//进行Threadlocal进行分页参数的提取
Pagination<Object> page  =  PaginationManager.getPagination();
//若不存在分页参数
if(null == page){
//将执行权交给下一个拦截器

14a40
PaginationManager.remove();
return invocation.proceed();
}
StatementHandler statementHandler = (StatementHandler) invocation.getTarget();
MetaObject metaStatementHandler = MetaObject.forObject(statementHandler, DEFAULT_OBJECT_FACTORY,
DEFAULT_OBJECT_WRAPPER_FACTORY, DEFAULT_OBJECT_REFLECT_FACTORY);
// 分离代理对象链(由于目标类可能被多个拦截器拦截，从而形成多次代理，通过下面的两次循环可以分离出最原始的的目标类)
while (metaStatementHandler.hasGetter("h")) {
Object object = metaStatementHandler.getValue("h");
metaStatementHandler = MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY, DEFAULT_OBJECT_REFLECT_FACTORY);
}
// 分离最后一个代理对象的目标类
while (metaStatementHandler.hasGetter("target")) {
Object object = metaStatementHandler.getValue("target");
metaStatementHandler = MetaObject.forObject(object, DEFAULT_OBJECT_FACTORY, DEFAULT_OBJECT_WRAPPER_FACTORY, DEFAULT_OBJECT_REFLECT_FACTORY);
}
Configuration configuration = (Configuration) metaStatementHandler.getValue("delegate.configuration");
if(null != configuration.getVariables()){
dialect = configuration.getVariables().getProperty("dialect"); //设置数据库方言，默认为mysql
}

if (null == dialect || "".equals(dialect)) {
logger.warn("Property dialect is not setted,use default 'mysql' ");
dialect = defaultDialect;
}

MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement");
BoundSql boundSql = (BoundSql) metaStatementHandler.getValue("delegate.boundSql");
String sql = boundSql.getSql();
// 采用物理分页后，就不需要mybatis的内存分页了，所以重置下面的两个参数
Connection connection = (Connection) invocation.getArgs()[0];
// 重设分页参数里的总页数等，若没有totalCount的数值
if(page.getTotalCount() <= 0){
setPagination(sql, connection, mappedStatement, boundSql, page);
}
page.adjustAllProcess(); //进行参数的调整
// 重写sql
String pageSql = buildPageSql(sql, page);
metaStatementHandler.setValue("delegate.boundSql.sql", pageSql);
metaStatementHandler.setValue("delegate.rowBounds.offset", RowBounds.NO_ROW_OFFSET);
metaStatementHandler.setValue("delegate.rowBounds.limit", RowBounds.NO_ROW_LIMIT);

// 将执行权交给下一个拦截器
return invocation.proceed();
}

/**
* 从数据库里查询总的记录数并计算总页数，回写进分页参数<code>Pagination</code>,这样调用者就可用通过 分页参数
* <code>Pagination</code>获得相关信息。
*
* @param sql
* @param connection
* @param mappedStatement
* @param boundSql
* @param page
*/
private void setPagination(String sql, Connection connection, MappedStatement mappedStatement,
BoundSql boundSql, Pagination<Object> page) {
// 记录总记录数
String countSql = "select count(0) from (" + sql + ") as total";
PreparedStatement countStmt = null;
ResultSet rs = null;
try {
countStmt = connection.prepareStatement(countSql);
BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql,
boundSql.getParameterMappings(), boundSql.getParameterObject());
setParameters(countStmt, mappedStatement, countBS, boundSql.getParameterObject());
rs = countStmt.executeQuery();
int totalCount = 0;
if (rs.next()) {
totalCount = rs.getInt(1);
}

page.setTotalCount(totalCount);

} catch (SQLException e) {
logger.error("Ignore this exception", e);
} finally {
try {
rs.close();
} catch (SQLException e) {
logger.error("Ignore this exception", e);
}
try {
countStmt.close();
} catch (SQLException e) {
logger.error("Ignore this exception", e);
}
}

}

/**
* 对SQL参数(?)设值
*
* @param ps
* @param mappedStatement
* @param boundSql
* @param parameterObject
* @throws SQLException
*/
private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql,
Object parameterObject) throws SQLException {
ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);
parameterHandler.setParameters(ps);
}

/**
* 根据数据库类型，生成特定的分页sql
*
* @param sql
* @param page
* @return
*/
private String buildPageSql(String sql, Pagination<Object> page) {
if (page != null) {
StringBuilder pageSql = new StringBuilder();
if ("mysql".equals(dialect)) {
pageSql = buildPageSqlForMysql(sql, page);
} else if ("oracle".equals(dialect)) {
pageSql = buildPageSqlForOracle(sql, page);
} else {
return sql;
}
return pageSql.toString();
} else {
return sql;
}
}

/**
* mysql的分页语句
*
* @param sql
* @param page
* @return String
*/
public StringBuilder buildPageSqlForMysql(String sql, Pagination<Object> page) {
StringBuilder pageSql = new StringBuilder(100);
String beginrow = String.valueOf(page.getStartRow());
pageSql.append(sql);
pageSql.append(" limit " + beginrow + "," + page.getPageSize());
return pageSql;
}

/**
* 参考hibernate的实现完成oracle的分页
*
* @param sql
* @param page
* @return String
*/
public StringBuilder buildPageSqlForOracle(String sql, Pagination<Object> page) {
StringBuilder pageSql = new StringBuilder(100);
pageSql.append("select * from ( select temp.*, rownum row_id from ( ");
pageSql.append(sql);
pageSql.append(" ) temp where rownum <= ").append(page.getPageNo() * page.getPageSize());
pageSql.append(") where row_id > ").append(page.getStartRow());
return pageSql;
}

@Override
public Object plugin(Object target) {
// 当目标类是StatementHandler类型时，才包装目标类，否者直接返回目标本身,减少目标被代理的次数
if (target instanceof StatementHandler) {
return Plugin.wrap(target, this);
} else {
return target;
}
}

@Override
public void setProperties(Properties properties) {
}

}

Filter的实现

这里通过Filter的配置来进行，需要分页的URL的定位，因为对于分页来讲我们需要进入同一个URL来进行取出数据库中不同位置的数据而已，只是需要传递不同的参数，如页码。

在Filter方法中，我们首先进行分页对象的初建立，并将其放入到ThreadLocal中，这样是为了mybatis中分页插件，能够拿到分页的部分参数，通过判断是否是用户第一次进入分页页码，来判断是否需要发出来统计分页总的记录数的语句。如需要发出总记录数相应的SQL语句，然后进行重构分页对象。

而且在doFilterChain方法后面需要释放，ThreadLocal中的线程变量，这里是至关重要的。

为什么要释放线程变量？（大坑）

因为我们知道Tomcat的架构，对于不同的请求是不同的线程来进行处理的，会给我们一个实现的接口servlet或者Filter来进行业务的处理。这里，tomcat的线程不是进行new出来的，因为对于new的操作需要耗费资源，这里采用的是线程池的方式，同样的思想体现于Datasource中。假如，一个线程池中有20个线程（这里可通过tomcat配置文件进行配置），时间上不同的请求可能用的是同一个线程池中某一个线程。那么，上一个线程存放的线程变量就可能被下一个线程取到相应的数据，所以我们需要在一个线程结束的时候，进行线程变量的清楚。

package com.pcitc.modules.pagination;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class PaginationFilter implements Filter {

public static String PAGE_SIZE = "pageSize";
public static String PAGE_NO = "pageNo";
public static String TOTAL_COUNT = "totalCount";

private String pageSizeName = PAGE_SIZE;
private String pageNoName = PAGE_NO;
private String totalCountName = TOTAL_COUNT;

@Override
public void init(FilterConfig filterConfig) throws ServletException {

}

@Override
public void destroy() {

}

@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain filterChain) throws IOException, ServletException {
System.out.println("分页插件，过滤器开始");
Integer pageSize = Integer.valueOf((request.getParameter(pageSizeName) == null)?"0":request.getParameter(pageSizeName));
Integer pageNo = Integer.valueOf(request.getParameter(pageNoName) == null?"0":request.getParameter(pageNoName));
Integer totalCount = Integer.valueOf(request.getParameter(totalCountName)== null?"0":request.getParameter(totalCountName));

Pagination<Object> pagination = new Pagination<Object>();
pagination.setPageNoName(pageNoName);
pagination.setPageSizeName(pageSizeName);
pagination.setTotalCountName(totalCountName);
pagination.setPageSize(pageSize);
pagination.setPageNo(pageNo);
pagination.setTotalCount(totalCount);
PaginationManager.setPagination(pagination);
filterChain.doFilter(request, response);
System.out.println("释放ThreadLoca中的值");
PaginationManager.remove();
}

}

自定义JSP标签的实现

因为分页的HTML和CSS我们不能控制，为了减少代码侵入性，我们采用给标签中提供相应的分页信息，来让前端人员来自己对样式和dom结构的定义。

package com.pcitc.modules.pagination;

import java.io.IOException;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.SimpleTagSupport;

public class PaginationTag extends SimpleTagSupport{

public static String COMMON = "common"; //页码组信息
public static String PREPAGE = "prePage"; //前一页信息
public static String POSTPAGE = "postPage"; //后一页信息

private String searchUrl;
private String pageType = COMMON; //判断是否是首页或者尾页

@Override
public void doTag() throws JspException, IOException{

//循环遍历页面显示页码数
Pagination<Object> pagination = PaginationManager.getPagination();

if(pagination != null){
int[] pageNums = pagination.getPageNums();
if("common".equals(pageType)){

for(int i=0;i<pageNums.length;i++){

String url = this.searchUrl;
if(!searchUrl.contains("?")){
url = url + "?";
}

url = url + "&" + pagination.getPageSizeName() + "=" + pagination.getPageSize()
+ "&" + pagination.getPageNoName() + "=" + pageNums[i]
+ "&" + pagination.getTotalCountName() + "=" + pagination.getTotalCount();

//将分页的URL和pageNum设置到page 范围
getJspContext().setAttribute("pageUrl",url);
getJspContext().setAttribute("pageNum", pageNums[i]);
getJspContext().setAttribute("pageInfo", pagination);
//输出标签体

getJspBody().invoke(null);

}
}else{
if(pageNums.length > 1){
if(PREPAGE.equals(pageType)){
String url = this.searchUrl;
if(!searchUrl.contains("?")){
url = url + "?";
}

url = url + "&" + pagination.getPageSizeName() + "=" + pagination.getPageSize()
+ "&" + pagination.getPageNoName() + "=" + pagination.getPrePage()
+ "&" + pagination.getTotalCountName() + "=" + pagination.getTotalCount();
//将分页的URL和pageNum设置到page 范围
getJspContext().setAttribute("pageUrl",url);
getJspContext().setAttribute("pageNum", pagination.getPrePage());
getJspContext().setAttribute("pageInfo", pagination);
//输出标签体

getJspBody().invoke(null);

}else if(POSTPAGE.equals(pageType)){
String url = this.searchUrl;
if(!searchUrl.contains("?")){
url = url + "?";
}

url = url + "&" + pagination.getPageSizeName() + "=" + pagination.getPageSize()
+ "&" + pagination.getPageNoName() + "=" + pagination.getNextPage()
+ "&" + pagination.getTotalCountName() + "=" + pagination.getTotalCount();
//将分页的URL和pageNum设置到page 范围
getJspContext().setAttribute("pageUrl",url);
getJspContext().setAttribute("pageNum", pagination.getNextPage());
getJspContext().setAttribute("pageInfo", pagination);
//输出标签体

getJspBody().invoke(null);
}else{
String url = this.searchUrl;
if(!searchUrl.contains("?")){
url = url + "?";
}

url = url + "&" + pagination.getPageSizeName() + "=" + pagination.getPageSize()
+ "&" + pagination.getTotalCountName() + "=" + pagination.getTotalCount()
+ "&" + pagination.getPageNoName() + "=";
//将分页的URL的元素设置到page 范围
getJspContext().setAttribute("pageUrl",url);
getJspContext().setAttribute("pageInfo", pagination);
//输出标签体
getJspBody().invoke(null);
}

}
}

}

}

public String getSearchUrl() {
return searchUrl;
}

public void setSearchUrl(String searchUrl) {
this.searchUrl = searchUrl;
}

public String getPageType() {
return pageType;
}

public void setPageType(String pageType) {
this.pageType = pageType;
}

}

tld文件：

<?xml version="1.0" encoding="UTF-8" ?>
<taglib xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd" version="2.1">

<description>JSTL 1.1 core library</description>
<display-name>JSTL core</display-name>
<tlib-version>1.1</tlib-version>
<short-name>util</short-name>
<uri>http://ctbu.com/liumi</uri>
<!-- 标签展示通用类 -->
<tag>
<name>page</name>
<tag-class>com.pcitc.web.controller.common.PaginationTag</tag-class>
<body-content>scriptless</body-content>
<!-- 标签体中可以取出pageUrl，pageNum，pageInfo对象用来页面的展示和判断 -->
<attribute>
<name>searchUrl</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
<type>java.lang.String</type>
</attribute>
<attribute>
<name>pageType</name>
<required>false</required>
<rtexprvalue>true</rtexprvalue>
<type>java.lang.String</type>
<description>common--代表显示的页码，prePage代表上一页信息，postPage代表下一页信息</description>
</attribute>
</tag>
</taglib>

JSP使用标签的简单实例：

<!--这里需要web.xml文件中引入相应utl文件位置-->
<%@ taglib  uri="http://ctbu.com/liumi" prefix="util"%>
<util:page searchUrl="${ctx}/news/list" pageType="other">
这里相当于通过pageType属性来获取相应的分页的信息：
other：则是获取分页的信息
common：会进行所有显示在页面页码的迭代出不同URL，
通过${pageUrl}来获取
prePage和postPage：进行前页和后页信息的获取
显示第 ${pageInfo.startRow+1} 至
${pageInfo.startRow+listSize} 项结果，共
${pageInfo.totalCount} 项
</util:page>
<--上一页-->
<util:page searchUrl="${ctx}/news/list" pageType="prePage">
<c:if test="${pageInfo.totalCount > pageInfo.pageSize}">
<li id="" class="paginate_button previous">
<a href="${pageUrl}">上页</a>
</li>
</c:if>
</util:page>

<!--所有页码-->
<util:page searchUrl="${ctx}/news/list" pageType="common">
<c:if test="${pageInfo.totalCount > pageInfo.pageSize}">
<li class="paginate_button <c:if test='${pageInfo.pageNo == pageNum}'>active</c:if>">
<a href="${pageUrl}">${pageNum}</a>
</li>
</c:if>
</util:page>

<!--后一页-->
<util:page searchUrl="${ctx}/news/list" pageType="postPage">
<c:if test="${pageInfo.totalCount > pageInfo.pageSize}">
<li id="" class="paginate_button next">
<a tabindex="0" data-dt-idx="8" aria-controls="userTabel" href="${pageUrl}">下页</a>
</li>
</c:if>
</util:page>

ThreadLocal来进行Filter到JSP中分页对象传递

package com.pcitc.modules.pagination;

/**
* 将分页数据进行线程级别传递
* @author mi
*
*/
public class PaginationManager {

//使用ThreadLocal保存Connection变量
private static final ThreadLocal<Pagination<Object>> pageHolder = new ThreadLocal<Pagination<Object>>();

public static Pagination<Object> getPagination(){
//ThreadLocal取得当前线程的分页数据
return pageHolder.get();
}

public static void setPagination(Pagination<Object> pagination){
pageHolder.set(pagination);
}

public static void remove(){
pageHolder.remove();
}

}

使用说明

在web.xml中进行对Filter的配置，主要是对那个URL进行分页的

拦截，和对tld文件的引入（jar包中meta文件中tld文件不用引入）：

<filter>
<filter-name>paginationFilter</filter-name>
<filter-class>
com.pcitc.modules.pagination.PaginationFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>paginationFilter</filter-name>
<url-pattern>/news/list</url-pattern>
<dispatcher>REQUEST</dispatcher>
<dispatcher>FORWARD</dispatcher>
</filter-mapping>
<jsp-config>
<taglib>
<taglib-uri>http://ctbu.com/liumi</taglib-uri>
<taglib-location>/WEB-INF/util.tld</taglib-location>
</taglib>
</jsp-config>

配置mybatis拦截器

<plugins>
<plugin interceptor="com.pcitc.modules.pagination.PageInterceptor">
<!-- 或者mysql -->
<property name="dialect" value="oracle"/>
</plugin>
</plugins>

在JSP表中引入：

<%@ taglib  uri="http://ctbu.com/liumi" prefix="util"%>