分页组件

    一个通用的分页组件，低耦合、可重用、可扩展、样式可更改，与业务无关，与数据库无关，使用简单，本分页组件的页面基于jsp（可根据需要自行修改为其他），自定义tld分页标签。在此记录下来备用。

参考内容：
http://www.iteye.com/topic/676906
http://www.iteye.com/topic/677469
http://qingfeng-101.iteye.com/blog/797379

分页效果：


组件实现了页面展示功能，对分页进行了封装，但是底层分页的代码或分页sql语句需要自己实现。详细说明参考以上链接文章。以下三段java代码直接复制粘贴即可。
Page类

import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Externalizable;

/**
 * 分页工具类。
 * 页面序号从1开始，第一页:pageIndex=1，第二页：pageIndex=2 ...
 * @version 1.00 2010-4-24
 * @since 1.5
 * @author ZhangShixi
 */
public class Page implements Externalizable, Cloneable {

    private static final long serialVersionUID = -6192319941595582550L;

    // 当前页面的页数
    private int pageIndex;
    // 页面显示行数
    private int pageSize;
    // 数据总量
    private int totalData = -1;
    // 剩余数据量
    private int surplusData;
    // 页面总量
    private int totalPage;
    // 是否仅取第一页
    private boolean firstPage;
    // 是否可以工作。默认为false，只有设置了数据总量才为true。
    private boolean ready = false;

    // 默认当前页面页数为第一页
    private static final int DEFAULT_PAGE_INDEX = 1;
    // 默认页面大小为10
    private static final int DEFAULT_PAGE_SIZE = 10;

    /**
     * 以默认当前页面和页面大小构造一个分页对象。
     * 其中，默认当前页数为1，默认页面大小为10。
     */
    public Page() {
        this.pageIndex = DEFAULT_PAGE_INDEX;
        this.pageSize = DEFAULT_PAGE_SIZE;
    }

    /**
     * 以指定的当前页面页数和页面大小构造一个分页对象。
     * @param pageIndex 当前页数，若参数值不大于0，则使用默认值1。
     * @param pageSize 页面大小，若参数值不大于0，则使用默认值10。
     */
    public Page(int pageIndex, int pageSize) {
        this.pageIndex = pageIndex > 0 ? pageIndex : DEFAULT_PAGE_INDEX;
        this.pageSize = pageSize > 0 ? pageSize : DEFAULT_PAGE_SIZE;
    }

    /**
     * 以指定的页面大小构造一个表示第一页的分页对象。
     * @param pageSize 页面大小，若参数值不大于0，则使用默认值10。
     * @return 构造好的第一页分页对象。
     */
    public static Page newFirstPage(int pageSize) {
        Page page = new Page(1, pageSize);
        page.setFirstPage(true);
        page.setTotalData(pageSize);

        return page;
    }

    /**
     * 获取数据总量。
     * @return 数据总量。未设置时，会返回初始值-1。
     */
    public int getTotalData() {
        return totalData;
    }

    /**
     * 设置数据总量。在使用时，需提前调用此方法进行设置。
     * 当数据总量设置好之后，会计算页面总量、修正当前页面页数、计算剩余数据量，
     * 并设置该分页对象已经准备好，可以正常工作。
     * @param totalData 数据总量。
     */
    public void setTotalData(int totalData) {
        this.totalData = totalData;

        this.totalPage = this.totalData / pageSize +
                (this.totalData % pageSize == 0 ? 0 : 1);

        if (this.pageIndex > this.totalPage) {
            this.pageIndex = this.totalPage;
        }

        this.surplusData = this.totalData - (this.pageIndex - 1) * this.pageSize;

        this.ready = true;
    }

    /**
     * 获取当前分页对象的页面范围，包含当前页面的起始行和结束行。
     * 如果未先调用setTotalData()方法设置数据总量，则会抛出运行时异常。
     * @return 当前分页对象的页面范围。
     * @throws java.lang.IllegalArgumentException 异常。
     */
    public PageScope getPageScope() throws IllegalArgumentException {
        if (!ready) {
            throw new IllegalArgumentException("Page has not seted data amount.");
        }

        if (this.pageIndex > this.totalPage) {
            return null;
        }

        PageScope scope = new PageScope();
        int startLine = (this.pageIndex - 1) * this.pageSize;
        int endLine;
        if (this.surplusData < this.pageSize) {
            endLine = startLine + this.surplusData - 1;
        } else {
            endLine = startLine + this.pageSize - 1;
        }
        if (startLine < 0) {
            startLine = 0;
        }
        if (endLine < 0) {
            endLine = 0;
        }
        scope.setStartLine(startLine);
        scope.setEndLine(endLine);

        return scope;
    }

    /**
     * 获取当前页面页数。
     * @return 当前页面页数。
     */
    public int getPageIndex() {
        return pageIndex;
    }

    /**
     * 设置当前页面页数。
     * @param pageIndex 当前页面页数。
     */
    public void setPageIndex(int pageIndex) {
        this.pageIndex = pageIndex;
    }

    /**
     * 获取页面大小。
     * @return 页面大小。
     */
    public int getPageSize() {
        return pageSize;
    }

    /**
     * 设置页面大小。
     * @param pageSize 页面大小。
     */
    public void setPageSize(int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * 获取总页数。
     * @return 总页数。
     */
    public int getTotalPage() {
        return totalPage;
    }

    /**
     * 判断当前分页对象是否代表第一页。
     * @return <code>true</code>代表是第一页，<code>false</code>不是第一页。
     */
    public boolean isFirstPage() {
        return firstPage;
    }

    /**
     * 设置当前分页对象是否为第一页。
     * @param firstPage 是否是第一页。
     *  <code>true</code>代表是第一页，<code>false</code>不是第一页。
     */
    public void setFirstPage(boolean firstPage) {
        this.firstPage = firstPage;
    }

    /**
     * 重写父类的clone()方法。
     * @return 新的分页对象。
     * @throws java.lang.CloneNotSupportedException 不支持克隆异常。
     *  如果对象的类不支持Cloneable接口，则重写clone方法的子类也会抛出此异常，
     *  以指示无法复制某个实例。
     */
//    protected Page clone() throws CloneNotSupportedException {
//        return (Page) super.clone();
//    }

    /**
     * 重写父类的equals()方法，根据当前页面序号和页面大小比较两个分页对象是否相等。
     * @param obj 比较对象，如果不是Page实例，将返回<code>false</code>。
     * @return 两个对象是否相等。
     */
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (!(obj instanceof Page)) {
            return false;
        }
        final Page page = (Page) obj;
        if (page.getPageIndex() == this.pageIndex &&
                page.getPageSize() == this.pageSize) {
            return true;
        }
        return false;
    }

    /**
     * 重写父类的hashCode()方法，根据当前页面序号和页面大小生成一个唯一的哈希吗。
     * @return 根据当前页面序号和页面大小生成一个唯一的哈希吗。
     */
    public int hashCode() {
        int result = 17;
        result = 37 * result + (this.pageIndex ^ (this.pageIndex >>> 32));
        result = 37 * result + (this.pageSize ^ (this.pageSize >>> 32));

        return result;
    }

    /**
     * 重写父类的toString()方法，返回分页信息的字符串表示。
     * @return 分页信息的字符串表示。
     *  该字符串由当前页面序号、页面大小、数据总量和是否准备好组成。
     */
    public String toString() {
        StringBuffer pageInfo = new StringBuffer();
        pageInfo.append(this.getClass());
        pageInfo.append("[");
        pageInfo.append("pageIndex=");
        pageInfo.append(this.pageIndex);
        pageInfo.append(", ");
        pageInfo.append("pageSize=");
        pageInfo.append(this.pageSize);
        pageInfo.append(", ");
        pageInfo.append("totalData=");
        pageInfo.append(this.totalData);
        pageInfo.append(", ");
        pageInfo.append("ready=");
        pageInfo.append(this.ready);
        pageInfo.append("]");

        return pageInfo.toString();
    }

    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeInt(this.pageIndex);
        out.writeInt(this.pageSize);
        out.writeInt(this.totalData);
        out.writeInt(this.surplusData);
        out.writeInt(this.totalPage);
        out.writeBoolean(this.firstPage);
        out.writeBoolean(this.ready);
    }

    public void readExternal(ObjectInput in)
            throws IOException, ClassNotFoundException {
        this.pageIndex = in.readInt();
        this.pageSize = in.readInt();
        this.totalData = in.readInt();
        this.surplusData = in.readInt();
        this.totalPage = in.readInt();
        this.firstPage = in.readBoolean();
        this.ready = in.readBoolean();
    }
}

PageScope类

import java.io.Serializable;

/**
 * 页面范围，记录了对应页面的起始行号和结束行号。
 * @version 1.00 2010-4-25
 * @since 1.5
 * @author ZhangShixi
 */
public class PageScope implements Serializable {

    private static final long serialVersionUID = 7480833511913154644L;
    // 起始行号
    private int startLine;
    // 结束行号
    private int endLine;

    /**
     * 默认无参构造器。
     */
    public PageScope() {
    }

    /**
     * 以起始行号和结束行号构造一个页面范围对象。
     * @param startLine 起始行号。
     * @param endLine 结束行号。
     */
    public PageScope(int startLine, int endLine) {
        this.startLine = startLine;
        this.endLine = endLine;
    }

    /**
     * 获取当前页面的开始行号。
     * @return 开始行号。
     */
    public int getStartLine() {
        return startLine;
    }

    /**
     * 设置当前页面的开始行号。
     * @param startLine 开始行号。
     */
    public void setStartLine(int startLine) {
        this.startLine = startLine;
    }

    /**
     * 获取当前页面的结束行号。
     * @return 结束行号。
     */
    public int getEndLine() {
        return endLine;
    }

    /**
     * 设置当前页面的结束行号。
     * @param endLine 结束行号。
     */
    public void setEndLine(int endLine) {
        this.endLine = endLine;
    }

    /**
     * 重写父类的toString()方法，返回页面范围信息的字符串表示。
     * @return 页面范围信息的字符串表示。该字符串由当前页面的开始行号和结束行号信息组成。
     */
    public String toString() {
    	StringBuffer scopeInfo = new StringBuffer();
        scopeInfo.append("Scope information of the page is: ");
        scopeInfo.append(this.startLine);
        scopeInfo.append(" to ");
        scopeInfo.append(this.endLine);

        return scopeInfo.toString();
    }
}

PageTag类

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

/**
 * 分页标签处理类。
 * @version 1.00 2010-5-25, 15:40:02
 * @since 1.5
 * @author ZhangShixi
 */
public class PageTag extends TagSupport {

    private static final long serialVersionUID = 3441235160861303080L;
    // 字符串缓冲区
    private StringBuffer buff;
    // 首页
    private String homePage;
    // 末页
    private String lastPage;
    // 上一页
    private String previousPage;
    // 当前页之前的页数，默认为4。
    private int beforeNum =4;
    // 当前页之后的页数，默认为5。
    private int afterNum =5;
    // 分页对象
    private Page page;
    // 链接地址
    private String url;
    // 下一页
    private String nextPage;
    // 当前页码
    private String pageIndex;
    // 页面大小
    private String pageSize;
    // 外层div样式
    private String divClass;
    // 是否进行动态补足，默认为true。
    private boolean supplement = true;
    //总计条数
    private String totalData;
    // Html标签
    private static final String LABEL_START = "<label>";
    private static final String LABEL_END = "</label>";
    private static final String SPAN_START = "<span>";
    private static final String SPAN_END = "</span>";
    // 日志记录器
    private static Log log = LogFactory.getLog(PageTag.class);

    /**
     * 标签处理开始，构造一个存放分页信息的字符串缓冲区。
     * @return SKIP_BODY，忽略标签之间的内容。
     * @throws javax.servlet.jsp.JspException Jsp异常。
     */
    public int doStartTag() throws JspException {
        buff = new StringBuffer();
        return SKIP_BODY;
    }

    /**
     * 标签实际分页处理逻辑。
     * @return EVAL_PAGE，按正常的流程继续执行Jsp页面。
     * @throws javax.servlet.jsp.JspException Jsp异常。
     */
    public int doEndTag() throws JspException {
        if (page == null) {
            log.info("page is null.");
            return EVAL_PAGE;
        }

        // 写入开始DIV
        writeBeginDiv();
        // 写入分页信息
        writePageInfo();
        // 写入结束DIV
        writeEndDiv();
        // 记录日志
        writeDebugLog();
        // 输出到页面
        printToPage();

        return EVAL_PAGE;
    }

    /**
     * 写入实际的分页信息。
     * 调用者可自行设定是否显示首页、末页、上一页、下一页
     * 以及当前页面之前和之后的页数、是否进行动态补足等。
     */
    private void writePageInfo() {
        int beforeCount = countBefore();
        int afterCount = countAfter();

        // 如果定义了动态补足，则对当前页之前和之后的页数进行动态补足。
        if (supplement) {
            beforeCount = fixBeforeCount(beforeCount, afterCount);
            afterCount = fixAfterCount(beforeCount, afterCount);
        }

        int index = page.getPageIndex();
        // 首页
        writeHomePage(index);
        // 上一页
        writePreviousPage(index);
        // 当前页之前的页码
        writeBeforePageIndex(index, beforeCount);
        // 当前页
        writeCurrentPageIndex(index);
        // 当前页之后的页码
        writeAfterPageIndex(index, afterCount);
        // 下一页
        writeNextPage(index);
        // 末页
        writeLastPage(index);
        //共计多少条记录
        writeTotalData();
    }

    /**
     * 计算当前页之前的页数。
     * @return 当前页之前的页数。
     */
    private int countBefore() {
        int beforeCount = 0;
        if (page.getPageIndex() - 1 > beforeNum) {
            beforeCount = beforeNum;
        } else {
            beforeCount = page.getPageIndex() - 1;
        }

        return beforeCount;
    }

    /**
     * 计算当前页之后的页数。
     * @return 当前页之后的页数。
     */
    private int countAfter() {
        int afterCount = 0;
        if (page.getTotalPage() - page.getPageIndex() > afterNum) {
            afterCount = afterNum;
        } else {
            afterCount = page.getTotalPage() - page.getPageIndex();
        }

        return afterCount;
    }

    /**
     * 动态补足当前页之前的页数。
     * @param beforeCount 当前页之前的页数。
     * @param afterCount 当前页之后的页数。
     * @return 修正后的当前页之前的页数。
     */
    private int fixBeforeCount(int beforeCount, int afterCount) {
        int totalNum = beforeNum + afterNum + 1;
        int useNum = beforeCount + afterCount + 1;

        if (useNum < totalNum) {
            int befores = page.getPageIndex() - 1;
            int margin = befores - beforeCount;
            if (margin > 0) {
                int needNum = totalNum - useNum;
                beforeCount += margin > needNum ? needNum : margin;
            }
        }

        return beforeCount;
    }

    /**
     * 动态补足当前页之后的页数。
     * @param beforeCount 当前页之前的页数。
     * @param afterCount 当前页之后的页数。
     * @return 修正后的当前页之后的页数。
     */
    private int fixAfterCount(int beforeCount, int afterCount) {
        int totalNum = beforeNum + afterNum + 1;
        int useNum = beforeCount + afterCount + 1;

        if (useNum < totalNum) {
            int afters = page.getTotalPage() - page.getPageIndex();
            int margin = afters - afterCount;
            if (margin > 0) {
                int needNum = totalNum - useNum;
                afterCount += margin > needNum ? needNum : margin;
            }
        }

        return afterCount;
    }

    /**
     * 写入首页信息，如果设定了显示首页。
     * @param index 当前页码。
     */
    private void writeHomePage(int index) {
        if (homePage == null || "".equals(homePage)) {
            return;
        }

        buff.append(LABEL_START);
        int homeIndex = 1;
        if (index > homeIndex) {
            writeUrlPageIndex(homeIndex, page.getPageSize(), homePage);
        } else {
            buff.append(homePage);
        }
        buff.append(LABEL_END);
    }

    /**
     * 写入末页信息，如果设定了显示末页。
     * @param index 当前页码。
     */
    private void writeLastPage(int index) {
        if (lastPage == null || "".equals(lastPage)) {
            return;
        }

        buff.append(LABEL_START);
        int lastIndex = page.getTotalPage();
        if (index < lastIndex) {
            writeUrlPageIndex(lastIndex, page.getPageSize(), lastPage);
        } else {
            buff.append(lastPage);
        }
        buff.append(LABEL_END);
    }
    
    
    /**
     * 总计条数
     */
    private void writeTotalData() {
    	buff.append(LABEL_START);
        buff.append(totalData);
        buff.append(LABEL_END);
        buff.append("：");
        buff.append(page.getTotalData());
    }
    /**
     * 写入上一页信息，如果设定了显示上一页。
     * @param index 当前页码。
     */
    private void writePreviousPage(int index) {
        if (previousPage == null || "".equals(previousPage)) {
            return;
        }

        buff.append(LABEL_START);
        if (index > 1) {
            writeUrlPageIndex(index - 1, page.getPageSize(), previousPage);
        } else {
            buff.append(previousPage);
        }
        buff.append(LABEL_END);
    }

    /**
     * 写入下一页信息，如果设定了显示下一页。
     * @param index 当前页码。
     */
    private void writeNextPage(int index) {
        if (nextPage == null || "".equals(nextPage)) {
            return;
        }

        buff.append(LABEL_START);
        if (index < page.getTotalPage()) {
            writeUrlPageIndex(index + 1, page.getPageSize(), nextPage);
        } else {
            buff.append(nextPage);
        }
        buff.append(LABEL_END);
    }

    /**
     * 写入当前页之前的页码。
     * @param index 当前页码。
     * @param beforeCount 前页之前的页数。
     */
    private void writeBeforePageIndex(int index, int beforeCount) {
        int beginIndex = index - beforeCount < 0 ? 1 : index - beforeCount;
        for (int i = beginIndex; i < index; i++) {
            buff.append(LABEL_START);
            writeUrlPageIndex(i, page.getPageSize(), String.valueOf(i));
            buff.append(LABEL_END);
        }
    }

    /**
     * 写入当前页之后的页码。
     * @param index 当前页码。
     * @param afterCount 前页之后的页数。
     */
    private void writeAfterPageIndex(int index, int afterCount) {
        int endIndex = index + afterCount > page.getTotalPage()
                ? page.getTotalPage() : index + afterCount;
        for (int i = index + 1; i <= endIndex; i++) {
            buff.append(LABEL_START);
            writeUrlPageIndex(i, page.getPageSize(), String.valueOf(i));
            buff.append(LABEL_END);
        }
    }

    /**
     * 写入当前页的页码。
     * @param index 当前页码。
     */
    private void writeCurrentPageIndex(int index) {
        buff.append(SPAN_START);
        buff.append("[").append(index).append("] ");
        buff.append(SPAN_END);
    }

    /**
     * 写入开始div，如果指定样式divClass，那么样式也将被写入。
     */
    private void writeBeginDiv() {
        buff.append("<div");
        if (divClass != null && !"".equals(divClass)) {
            buff.append(" class=\"");
            buff.append(divClass);
            buff.append("\"");
        }
        buff.append(">");
    }

    /**
     * 写入结束div。
     */
    private void writeEndDiv() {
        buff.append("</div>");
    }

    /**
     * 将分页信息输入到页面上。
     */
    private void printToPage() {
        try {
            pageContext.getOut().write(buff.toString());
//        	System.out.println(buff.toString());
        } catch (Exception ex) {
            log.error(ex.getMessage(), ex);
        }
    }

    /**
     * 写入添加链接地址url后的指定内容，并在链接地址url后添加pageIndex参数，
     * 如果指定了pageSize参数，也会将此参数添加到链接地址url中。
     * @param index 当前页码。
     * @param size 页面大小。
     * @param body 写入内容。
     */
    private void writeUrlPageIndex(int index, int size, String body) {
        buff.append("<a href=\"");
        buff.append(url);
        if (url.lastIndexOf("?") > 0) {
            buff.append("&");
        } else {
            buff.append("?");
        }
        buff.append(pageIndex);
        buff.append("=");
        buff.append(index);
        if (pageSize != null && !"".equals(pageSize)) {
            buff.append("&");
            buff.append(pageSize);
            buff.append("=");
            buff.append(size);
        }
        buff.append("\">");
        buff.append(body).append(" ");
        buff.append("</a>");
    }

    /**
     * 将构造好的分页信息以debug级别记录到日志中。
     */
    private void writeDebugLog() {
        if (log.isDebugEnabled()) {
            log.debug(buff.toString());
        }
    }

    /**
     * 设置首页的显示内容。
     * @param homePage 首页。
     */
    public void setHomePage(String homePage) {
        this.homePage = homePage;
    }

    /**
     * 设置末页的显示内容。
     * @param lastPage 末页。
     */
    public void setLastPage(String lastPage) {
        this.lastPage = lastPage;
    }

    /**
     * 设置上一页的显示内容。
     * @param previousPage 上一页。
     */
    public void setPreviousPage(String previousPage) {
        this.previousPage = previousPage;
    }

    /**
     * 设置下一页的显示内容。
     * @param nextPage 下一页。
     */
    public void setNextPage(String nextPage) {
        this.nextPage = nextPage;
    }

    /**
     * 设置当前页之前显示的页数。
     * @param beforeNum 当前页之前显示的页数。
     */
    public void setBeforeNum(int beforeNum) {
        this.beforeNum = beforeNum;
    }

    /**
     * 设置当前页之后显示的页数。
     * @param afterNum 当前页之后显示的页数。
     */
    public void setAfterNum(int afterNum) {
        this.afterNum = afterNum;
    }

    /**
     * 设置分页信息。
     * @param page 分页信息。
     */
    public void setPage(Page page) {
        this.page = page;
    }

    /**
     * 设置点击页码转向的url链接地址。
     * @param url 链接地址。
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * 设置当前页码参数名称。
     * @param pageIndex 当前页码参数名称。
     */
    public void setPageIndex(String pageIndex) {
        this.pageIndex = pageIndex;
    }

    /**
     * 设置页面大小参数名称。
     * @param pageSize 页面大小参数名称。
     */
    public void setPageSize(String pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * 设置外层div样式。
     * @param divClass 样式名称。
     */
    public void setDivClass(String divClass) {
        this.divClass = divClass;
    }

    /**
     * 设置是否对当前页面之前和之后的页数进行动态补足。
     * @param supplement 是否进行动态补足。
     *      <tt>true</tt>进行动态补足，<tt>false</tt>不进行动态补足。
     */
    public void setSupplement(boolean supplement) {
        this.supplement = supplement;
    }

	public String getTotalData() {
		return totalData;
	}

	public void setTotalData(String totalData) {
		this.totalData = totalData;
	}


    
//    public static void main(String[] args){
//    	PageTag instance = new PageTag();
//
//        Page page = new Page(2, 5);
//        page.setTotalData(12);
//
//        instance.setPage(page);
//        instance.setDivClass("divClass");
//        instance.setHomePage("首页");
//        instance.setLastPage("末页");
//        instance.setPreviousPage("上一页");
//        instance.setNextPage("下一页");
//        instance.setPageIndex("pageIndex");
//        instance.setPageSize("pageSize");
//        instance.setBeforeNum(1);
//        instance.setAfterNum(3);
//        instance.setSupplement(false);
//        instance.setUrl("findUsers.action");
//
//        try {
//			instance.doStartTag();
//			instance.doEndTag();
//		} catch (Exception e) {
//		}
//    }
}

jsp-tag.tld代码
该文件放在WEB-INF下与web.xml同一目录

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

    <tlib-version>1.0</tlib-version>
    <short-name>util</short-name>
    <uri>http://www.codingfarmer.com/tags</uri>

    <tag>
        <description>分页标签</description>
        <name>page</name>
        <tag-class>com.aisino.util.PageTag</tag-class>
        <body-content>empty</body-content>
        <attribute>
            <description>首页</description>
            <name>homePage</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>末页</description>
            <name>lastPage</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>上一页</description>
            <name>previousPage</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>下一页</description>
            <name>nextPage</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>总计条数</description>
            <name>totalData</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>分页对象</description>
            <name>page</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>com.aisino.util.Page</type>
        </attribute>
        <attribute>
            <description>当前页码的URL参数名称</description>
            <name>pageIndex</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>当前分页大小的URL参数名称</description>
            <name>pageSize</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>链接地址</description>
            <name>url</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>外层div容器样式</description>
            <name>divClass</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <description>当前页之前显示的页码数量</description>
            <name>beforeNum</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>当前页之后显示的页码数量</description>
            <name>afterNum</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>int</type>
        </attribute>
        <attribute>
            <description>是否进行前后页序号动态补足</description>
            <name>supplement</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>boolean</type>
        </attribute>
    </tag>

</taglib>

web.xml需添加设置

<!-- 分页配置 -->
    <jsp-config>   
	    <taglib>   
	     <taglib-uri>pagerTag</taglib-uri>   
	     <taglib-location>/WEB-INF/jsp-tags.tld</taglib-location>   
	    </taglib>   
	</jsp-config> 

在Action中

//分页
		page = new Page(pageIndex,3);
		//数据总数
		page.setTotalData(total);

其中3代表每页显示3行，total是数据总数（select count(*) ...）

工具类里的分页sql（oracle为例）

/**
	 * 分页sql
	 * @param sql
	 * @param page
	 * @return
	 */
	public static String pageSql(String sql, Page page){
		int pageIndex = page.getPageIndex();
		int pageSize = page.getPageSize();
		int startNum = (pageIndex-1)*pageSize+1;
		int endNum = pageIndex*pageSize;
		StringBuffer temp = new StringBuffer();
		temp.append("select * from (");
		temp.append("	select a.*,rownum row_num from(");
		temp.append(sql);
		temp.append("	) a where rownum<=").append(endNum);
		temp.append(") b where b.row_num >= ").append(startNum);
		
		return temp.toString();
	}

sql是查询语句，方法返回的sql是最终的sql语句，执行后得出当前页的list数据。

在jsp页面

引用<%@ taglib prefix="util" uri="http://www.codingfarmer.com/tags" %>
在body里的表格下面引用自定义标签，其中page为Action里的page
<util:page url="users/findUsers.action"    
           page="${page}"      
           pageIndex="pageIndex"    
           homePage="首页 "    
           lastPage="末页 "      
           previousPage="上一页 "    
           nextPage="下一页 "    
           totalData="总计条数 "
           divClass="divClass" />

使用总结：
1、可以把page开头的3个文件打成jar包，放到工程里；也可以直接使用java文件
2、把page-tag.tld文件放到WEB-INF文件夹下
3、配置web.xml
4、页面引入标签，添加自定义标签到<body></body>合适的位置（如：table下面）