你所不知道的JSP自定义分页标签

都是寂寞惹的祸，闲着没事干，就随便写写，上次用FreeMaker写了个分页组件，可惜只能用于前端试图层使用FreeMaker的情况，适用性不强，于是今天又动手写了个分页组件。
      我们都知道，在JSP1.1规范中新增了自定义标签库规范，自定义标签库是一种非常优秀的表现层组件技术，通过使用自定义标签库，可以在简单的标签中实现复杂的功能。或许你会问，为什么要使用自定义标签，或者使用自定义标签有什么好处？主要是为了取代丑陋的JSP脚本。因为直接在页面插入JSP脚本有如下几个坏处：
      1. JSP脚本非常丑陋，可阅读性不强；
      2. JSP脚本如果和页面元素代码杂糅在一起，后期代码维护难度大；
      3. HTML与JSP脚本混杂，不利于程序员和美工并行协助工作。
      鉴于以上3点理由，我们迫切需要一种技术，能代替JSP脚本并能支持JSP脚本所能完成的功能，而且具有和HTML类似的语法，JSP自定义标签库技术就在这样的环境下，诞生了。
     随着时间的推移，JSP2.0规范简化了自定义标签库开发的难度，实际开发过程中只需3个步骤即可完成自定义标签库的开发：
     1. 编写自定义标签处理类，继承TagSuport类或者BodyTagSuport类
     2. 编写*.tld标签库自描述性文件
     3.页面上通过taglib指令导入标签库即可
     那下面就开始动手实现吧，首先需要对页面上显示的分页部分信息进行对象范畴的抽象，经过分析，由此我们可以抽象出一个分页器对象,暂且我命名它为PageData:下面是我抽象出来的PageData类源码：
package com.yida.common.page;
import java.util.ArrayList;
import java.util.Collection;
/**
 * 一页数据封装对象
 * @author       Lanxiaowei
 * @createTime   2011-11-29 上午08:35:41
 */
@SuppressWarnings("unchecked")
public class PageData {
 /**
  * 默认每页显示记录条数15
  */
 public static final int DEFAULT_PAGE_SIZE = 15;
 /**
  * 默认当前页码1
  */
 public static final int DEFAULT_CURRENT_PAGE = 1;
 /**
  * 默认页面范围大小10
  */
 public static final int DEFAULT_PAGE_RANGE_SIZE = 10;
 
    /**
     * 数据集合
     */
 private Collection items;
 /**
  * 总记录数
  */
 private int totalRows;
 /**
  * 每页显示记录条数
  */
 private int pageSize = DEFAULT_PAGE_SIZE;
 /**
  * 当前页码
  */
    private int currentPage = DEFAULT_CURRENT_PAGE;
    /**
     * 总页数
     */
    private int totalPage;
    /**
     * 偏移量，用于计算该页起始行(从0开始计算)
     */
    private int offset;
    /**
     * 区域大小,用于类似于论坛分页效果，如：3 4 5 6 7 8 ... 20 21 22 23
     */
    private int pageRangeSize = DEFAULT_PAGE_RANGE_SIZE;
    /**
     * 区域总数
     */
    private int totalPageRange;
    /**
     * 当前区域包含的页码
     */
    private int[] currentRangePages;
    /**
     * 是否还有下一页
     */
    private boolean hasNextPage;
   
 public Collection getItems() {
  return items;
 }
 public void setItems(Collection items) {
  if(null == items){
   items = new ArrayList();
  }
  this.items = items;
 }
 public int getTotalRows() {
  return totalRows;
 }
 public void setTotalRows(int totalRows) {
  if(totalRows <= 0){
   totalRows = 0;
  }
  this.totalRows = totalRows;
 }
 public int getPageSize() {
  if(pageSize <= 0){
   pageSize = DEFAULT_PAGE_SIZE;
  }
  return pageSize;
 }
 public void setPageSize(int pageSize) {
  if(pageSize <= 0){
   pageSize = DEFAULT_PAGE_SIZE;
  }
  this.pageSize = pageSize;
 }
 public int getCurrentPage() {
  if(currentPage <= 0){
   return DEFAULT_CURRENT_PAGE;
  }
  if(getTotalPage() > 0 && currentPage > getTotalPage()){
   return getTotalPage();
  }
  return currentPage;
 }
 public void setCurrentPage(int currentPage) {
  if(currentPage <= 0){
   currentPage = DEFAULT_CURRENT_PAGE;
  }
  this.currentPage = currentPage;
 }
 public int getTotalPage() {
  totalPage = totalRows / pageSize;
  if(totalRows % pageSize != 0){
   totalPage ++;
  }
  return totalPage;
 }
 public void setTotalPage(int totalPage) {
  if(totalPage <= 0){
   totalPage = 0;
  }
  this.totalPage = totalPage;
 }
 public int getOffset() {
  offset = getStartOfPage();
  return offset;
 }
 public void setOffset(int offset) {
  this.offset = offset;
 }
 public int getPageRangeSize() {
  return pageRangeSize;
 }
 public void setPageRangeSize(int pageRangeSize) {
  if(pageRangeSize <= 0){
   pageRangeSize = DEFAULT_PAGE_RANGE_SIZE;
  }
  this.pageRangeSize = pageRangeSize;
 }
 public int getTotalPageRange() {
  return totalPageRange;
 }
 public void setTotalPageRange(int totalPageRange) {
  this.totalPageRange = totalPageRange;
 }
 public boolean isHasNextPage() {
  hasNextPage = (getCurrentPage() < getTotalPage());
  return hasNextPage;
 }
 public void setHasNextPage(boolean hasNextPage) {
  this.hasNextPage = hasNextPage;
 }
 
 /**
  * 默认的构造函数
  */
 public PageData() {
  setPageSize(DEFAULT_PAGE_SIZE);
  setCurrentPage(DEFAULT_CURRENT_PAGE);
  setPageRangeSize(DEFAULT_PAGE_RANGE_SIZE);
 }
 
 /**
  * 带页面显示大小的构造函数
  */
 public PageData(int pageSize) {
  setPageSize(pageSize);
  setCurrentPage(DEFAULT_CURRENT_PAGE);
  setPageRangeSize(DEFAULT_PAGE_RANGE_SIZE);
 }
 /**
  * 带当前页码和页面显示大小的构造函数
  */
 public PageData(int currentPage,int pageSize) {
  setPageSize(pageSize);
  setCurrentPage(currentPage);
  setPageRangeSize(DEFAULT_PAGE_RANGE_SIZE);
 }
 /**
  * 带当前页码和页面显示大小及页面范围大小的构造函数
  */
 public PageData(int currentPage,int pageSize,int pageRangeSize) {
  setPageSize(pageSize);
  setCurrentPage(currentPage);
  setPageRangeSize(pageRangeSize);
 }
 
 /**
  * 带总记录数和数据集合的构造函数
  */
 public PageData(int totalRows, Collection items) {
  this();
  this.totalRows = totalRows;
  this.items = items;
 }
 
 /**
  * 带数据集合、总记录数、当前页码、每页显示大小的构造函数
  */
 public PageData(Collection items, int totalRows, int currentPage, int pageSize) {
  this(currentPage,pageSize);
  this.items = items;
  this.totalRows = totalRows;
 }
 
 /**
  * 计算当前页记录的开始行号(从1开始计算)
  */
 protected int getStartOfPage(){
  int num = (currentPage - 1) * pageSize + 1;
  if(num > totalRows){
   num = totalRows;
  }
  return num;
 }
 
 /**
  * 计算当前页记录的结束行号(从1开始计算)
  */
 protected int getEndOfPage(){
  int num = getStartOfPage() + pageSize; 
  if(num >= totalRows){
   return totalRows;
  }
  return num - 1;
 }
 
 /**
  * 计算当前页面区域包含的页码
  */
 public int[] getCurrentRangePages() {
  if (totalPage > pageRangeSize) {
   int center = pageRangeSize / 2;
   if (currentPage > (center + 1)) {
    int y = totalPage - currentPage;
    if (y > center) {
     currentRangePages = new int[pageRangeSize];
     for (int i = 0; i < currentRangePages.length; i++) {
      currentRangePages[i] = currentPage - center + i;
     }
    } else {
     currentRangePages = new int[center + 1 + y];
     for (int i = 0; i < currentRangePages.length; i++) {
      currentRangePages[i] = currentPage - center + i;
     }
    }
   } else {
    currentRangePages = new int[pageRangeSize];
    for (int i = 0; i < currentRangePages.length; i++) {
     currentRangePages[i] = i + 1;
    }
   }
  } else {
   // 剩余的页数
   currentRangePages = new int[totalPage];
   for (int i = 0; i < currentRangePages.length; i++) {
    currentRangePages[i] = i + 1;
   }
  }
  return currentRangePages;
 }
}
接下来就是编写我们自己的自定义标签处理类PageTag类：源码如下：
package com.yida.common.page;

import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

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

/**
 * 自定义分页标签
 * @author       Lanxiaowei
 * @createTime   2011-11-22 下午09:12:35
 */
@SuppressWarnings("unchecked")
public class PageTag extends TagSupport{
 /**
  * 页面表单name
  */
 private String formName;
 /**
  * 尾页
  */
 private static final String LAST_PAGE_KEY = "LAST_PAGE_KEY";
 /**
  * 下一页
  */
 private static final String NEXT_PAGE_KEY = "NEXT_PAGE_KEY";
 /**
  * 上一页
  */
 private static final String PRE_PAGE_KEY = "PRE_PAGE_KEY";
 /**
  * 首页
  */
 private static final String FIRST_PAGE_KEY = "FIRST_PAGE_KEY";
 /**
  * 总记录数
  */
 private static final String TOTAL_RECORD_KEY = "TOTAL_RECORD_KEY";
 /**
  * 第
  */
 private static final String NO_KEY = "NO_KEY";
 /**
  * 页
  */
 private static final String PAGE_KEY = "PAGE_KEY";
 /**
  * 没有记录
  */
 private static final String NO_RESULT_KEY = "NO_ROW_KEY";
 
 public String getFormName() {
  if(null == formName){
   formName = "";
  }
  return formName.trim();
 }

 public void setFormName(String formName) {
  this.formName = formName;
 }

 /**
  * 根据本地环境获取资源Map(暂只支持中英文)
  */
 private Map getResourceMap(Locale locale){
  Map map = new HashMap();
 
  //for Chinese
  if (locale.equals(Locale.CHINESE) || locale.equals(Locale.CHINA)){
   map.put(LAST_PAGE_KEY, "尾页");
   map.put(NEXT_PAGE_KEY, "下一页");
   map.put(PRE_PAGE_KEY, "上一页");
   map.put(FIRST_PAGE_KEY, "首页");
   map.put(TOTAL_RECORD_KEY, "总记录数");
   map.put(NO_KEY, "第");
   map.put(PAGE_KEY, "页");
   map.put(NO_RESULT_KEY, "没有找到任何记录");
   return map;
  }
  //default for English
  map.put(LAST_PAGE_KEY, "last");
  map.put(NEXT_PAGE_KEY, "next");
  map.put(PRE_PAGE_KEY, "prev");
  map.put(FIRST_PAGE_KEY, "frist|");
  map.put(TOTAL_RECORD_KEY, "totalRows:");
  map.put(NO_KEY, "page:");
  map.put(PAGE_KEY, "");
  map.put(NO_RESULT_KEY, "No result");
  return map;
 }
 
 @Override
 public int doStartTag() throws JspException {
  //适用于Struts1
  /*FormTag formTag = (FormTag) findAncestorWithClass(this, FormTag.class);
  String formName = formTag.getBeanName();
  //取出Form里的pageData分页对象
  PaginActionForm form = (PaginActionForm) TagUtils.getInstance().lookup(pageContext, formName, "request");
  if (form == null) {
   form = (PaginActionForm) TagUtils.getInstance().lookup(pageContext, formName, "session");
  }
  PageData pageData = form.getPaginator();
  */
  //适用于Struts1 end
 
 
  //适用于Struts2，Servlet
  PageData pageData = (PageData)TagUtils.getInstance().lookup(pageContext, "pageData", "request");
  if(null == pageData){
   pageData = (PageData)TagUtils.getInstance().lookup(pageContext, "pageData", "session");
      if(null == pageData){
       pageData = new PageData();
      }
  }
  //适用于Struts2 Servlet end
 
  //获取request的Locale, 装载资源MAP
  Locale locale= pageContext.getRequest().getLocale();
  Map resourceMap = getResourceMap(locale);

  //判断是否显示
  if(null == pageData){
   pageContextWrite((String)resourceMap.get(NO_RESULT_KEY));
  } else{
   if (pageData.getPageSize() > 0) {
    if (pageData.getTotalRows() > 0) {
     printNavigation(pageData, resourceMap);
    } else {
     pageContextWrite((String)resourceMap.get(NO_RESULT_KEY));
    }
   }
  }
 
  //打印隐藏翻页字段及翻页JavaScript函数
  printTurnPageJavaScript(pageData,getFormName());
  return EVAL_BODY_INCLUDE;
 }
 
 /**
  * 获取当前页码和总页数字符串，效果类似于：第2/16页
  */
 private String getCurrentPage(PageData pageData, Map resourceMap) {
  StringBuffer buf = new StringBuffer();
  buf.append(
   resourceMap.get(NO_KEY)).append(pageData.getCurrentPage())
   .append("/").append(pageData.getTotalPage())
   .append(resourceMap.get(PAGE_KEY));
  return buf.toString();
 }
 
 /**
  * 获取总记录数字符串，效果类似于：总记录数：999
  */
 private String getTotalPages(PageData pageData, Map resourceMap) {
  StringBuffer buf = new StringBuffer();
  buf.append(resourceMap.get(TOTAL_RECORD_KEY)).append(pageData.getTotalRows());
  return buf.toString();
 }
 
 /**
  * 获取分页导航部分，效果类似于：首页 上一页 下一页 尾页
  */
 private String getNavigations(PageData pageData, Map resourceMap) {
  StringBuffer buf = new StringBuffer();
  //首页
  buf.append(getHref(pageData, 1, (String)resourceMap.get(FIRST_PAGE_KEY)));
  buf.append("&nbsp;");
  //上一页
  buf.append(getHref(pageData, pageData.getCurrentPage() - 1, (String)resourceMap.get(PRE_PAGE_KEY)));
  buf.append("&nbsp;");
  //下一页
  buf.append(getHref(pageData, pageData.getCurrentPage() + 1, (String)resourceMap.get(NEXT_PAGE_KEY)));
  buf.append("&nbsp;");
  //尾页
  buf.append(getHref(pageData, pageData.getTotalPage(), (String)resourceMap.get(LAST_PAGE_KEY)));
  buf.append("&nbsp;");
  return buf.toString();
 }
 
 /**
  * 页码跳转选择框
  * @param    pageData 分页器对象
  */
 private String getJumpControl(PageData pageData) {
 
  String turnPageNum = pageData.getCurrentPage()+"";
  int turnPage = -1;
  if (turnPageNum != null && turnPageNum.trim().length() != 0) {
   turnPage = Integer.parseInt(turnPageNum);
  }

  StringBuffer buf = new StringBuffer();
  buf.append("\n<select onChange=\"javascript:goPage(this.value)\" >\n");
  for (int i = 1; i <= pageData.getTotalPage(); i++) {
   buf.append("<option value=").append(i);
   // 如果翻页参数等于当前页则选择该选项
   if (turnPage == i) {
    buf.append(" selected");
   }
   buf.append(">").append(i).append("</option>\n");
  }
  buf.append("</select>\n");
  return buf.toString();
 }

 
 /**
  * 获取当前页的超链接
  * @param      pageData  分页器对象
  * @param      pageNum   当前页码
  * @param      textBody  当前页的文字显示部分
  */
 private String getHref(PageData pageData, int pageNum, String textBody) {
  if (pageNum < 1 || pageNum > pageData.getTotalPage()
    || pageNum == pageData.getCurrentPage()) {
   return textBody;
  } else {
   StringBuffer buf = new StringBuffer();
   buf.append("<a href=\"");
   buf.append("javascript:goPage(").append(pageNum).append(");");
   buf.append("\">");
   buf.append(textBody);
   buf.append("</a>");
   return buf.toString();
  }
 }
 
    /**
     * 打印隐藏翻页字段及翻页JavaScript函数
     * @param pageData   分页器对戏
     * @param formName   表单名
     */
 private void printTurnPageJavaScript(PageData pageData,String formName) {
  StringBuffer buffer = new StringBuffer();
  buffer.append("\n<input type=\"hidden\" name=\"pageData.currentPage\" id=\"pageData.currentPage\" value=\""+pageData.getCurrentPage()+"\">\n")
        .append("<script type=\"text/javascript\">\n")
        .append("function goPage(pageNum) {\n");
  if(!formName.equals("")){
   buffer.append("document.").append(formName).append(".elements[\"pageData.currentPage\"].value=pageNum;\n");
   buffer.append("document.").append(formName).append(".submit();\n");
  } else{
   buffer.append("document.forms[0]").append(".elements[\"pageData.currentPage\"].value=pageNum;\n");
   buffer.append("document.forms[0]").append(".submit();\n");
  }
  buffer.append("}\n")
     .append("</script>\n");
  //隐藏设置每页行数
  buffer.append("\n<input type='hidden' name='pageData.pageSize' value='"+pageData.getPageSize()+"'>\n");
  pageContextWrite(buffer.toString());
 }
 
 /**
  * 打印输出到前端页面
  * @param html 待输出的HTML片段
  */
 private void pageContextWrite(String html) {
  try {
   TagUtils.getInstance().write(pageContext, html);
  } catch (Exception e) {
   throw new RuntimeException("pageContext write IO exception");
  }
 }
 
 /**
  * 打印整个分页导航条
  * @param    pageData      分页器对象
  * @param    resourceMap   存放分页组件显示字符的容器
  */
 private void printNavigation(PageData pageData, Map resourceMap) {
  StringBuffer html_body = new StringBuffer();
  //当前页码
  html_body.append(getCurrentPage(pageData, resourceMap));
  html_body.append("&nbsp;&nbsp;");
  //总记录数
  html_body.append(getTotalPages(pageData, resourceMap));
  html_body.append("&nbsp;&nbsp;");
  //分页导航部分
  html_body.append(getNavigations(pageData, resourceMap));
  html_body.append("&nbsp;&nbsp;");
  //页码选择框部分
  html_body.append(getJumpControl(pageData));
  pageContextWrite(html_body.toString()); 
 }
 
 /*
  * 获取表单名称
  * @param  formTag      页面表单标签UI对象
  * @param  pageContext  页面上下文对象
  * @return string       表单的name
 
 private String getFormName(PageContext pageContext,FormTag formTag){  
  HttpServletRequest request = (HttpServletRequest)pageContext.getResponse();
  HttpServletResponse response = (HttpServletResponse)pageContext.getResponse();
  String actionClassName = formTag.action;//action属性被protected修饰，只能子类或者同包才能访问
  return toLowerCaseInitial(actionClassName,false);
 }
  */
 
 /**
     * 将一个字符串的首字母改为大写或者小写
     *
     * @param srcString      源字符串
     * @param flag           大小写标识，ture小写，false大写
     * @return 改写后的新字符串
     */
    private String toLowerCaseInitial(String srcString, boolean flag) {
        StringBuilder sb = new StringBuilder();
        if (flag) {
            sb.append(Character.toLowerCase(srcString.charAt(0)));
        } else {
            sb.append(Character.toUpperCase(srcString.charAt(0)));
        }
        sb.append(srcString.substring(1));
        return sb.toString();
    }
}

 PageTag里引用了Tagutil工具类的方法，下面是Tagutil工具类的源码：
package com.yida.common.page;

import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;

import org.apache.commons.beanutils.PropertyUtils;

/**
 * 自定义标签工具类
 * @author       Lanxiaowei
 * @createTime   2011-11-29 上午11:55:39
 */
public class TagUtils {
 private static final TagUtils instance = new TagUtils();
    private static final Map scopes;
   
 protected TagUtils(){}
 
 public static TagUtils getInstance(){
        return instance;
    }
 static{
        scopes = new HashMap();
        scopes.put("page", new Integer(1));
        scopes.put("request", new Integer(2));
        scopes.put("session", new Integer(3));
        scopes.put("application", new Integer(4));
    }
 
 /**
  * 获取作用域对象的代号
  */
 public int getScope(String scopeName) throws JspException{
  Integer scope = (Integer)scopes.get(scopeName.toLowerCase());
  if(scope == null){
   throw new JspException("lookup scopeName exception");
  }
  else{
   return scope.intValue();
  }
 }
 
 /**
  * 查找指定作用域内的对象
  * @param pageContext   页面上下文
  * @param name          对象名
  * @param scopeName     作用域名称
  */
 public Object lookup(PageContext pageContext, String name, String scopeName){
     if(scopeName == null){
         return pageContext.findAttribute(name);
     }
     try{
         return pageContext.getAttribute(name, instance.getScope(scopeName));
     }
     catch(JspException e){
         throw new RuntimeException("Don't find "+ name + "in the" + scopeName);
     }
 }
 
 /**
  * 查找指定作用域内bean的属性值
  * @param pageContext   页面上下文
  * @param name          对象名
  * @param name          对象属性名
  * @param scope         作用域名称
  */
 public Object lookup(PageContext pageContext, String name, String property, String scope){
  Object bean = lookup(pageContext, name, scope);
  if(bean == null){
         if(scope == null){
          throw new RuntimeException("Scope not found!");
         }
         else{
          throw new RuntimeException(name + "bean not found " + "in the " + scope);
         }
  }
     if(property == null){
         return bean;
     }
     try
     {
         return PropertyUtils.getProperty(bean, property);
     } catch(IllegalAccessException e)
     {
      throw new RuntimeException("IllegalAccessException when find the property of bean!");
     } catch(IllegalArgumentException e)
     {
      throw new RuntimeException("IllegalArgumentException when find the property of bean!");
     } catch(InvocationTargetException e)
     {
      throw new RuntimeException("InvocationTargetException when find the property of bean!");
     } catch(NoSuchMethodException e)
     {
      throw new RuntimeException("NoSuchMethodException when find the property of bean!");
     }
 }
 /**
  * 获取用户本地语言环境
  * @param  pageContext   页面上下文
  * @param  locale        本地语言环境key
  *
  */
 public Locale getUserLocale(PageContext pageContext, String locale){
  Locale userLocale = null;
  HttpServletRequest request = (HttpServletRequest)pageContext.getRequest();
        HttpSession session = request.getSession(false);
        if(locale == null || locale.length() == 0){
         throw new RuntimeException("The param of local can't be null!");
        }
        if(session != null){
            userLocale = (Locale)session.getAttribute(locale);
        }
        if(userLocale == null){
            userLocale = request.getLocale();
        }
        return userLocale;
    }
 
 /**
  * 输出内容到页面
  * @param pageContext  页面上下文
  * @param text         输出内容
  */
 public void write(PageContext pageContext, String text){
     JspWriter writer = pageContext.getOut();
     try{
         writer.print(text);
     } catch(IOException e){
      throw new RuntimeException("Write IO Exception");
     }
 }
}
然后就是PageModel对象，这个类只有你项目是基于Struts2的模型驱动方式开发的，才需要它，然后实际应用中，让你自己的Model继承PageModel即可，如果你不是基于Struts2的模型驱动方式开发项目的，那你只需在你自己的Action添加一个PageData pageData的属性并提供get set,其中pageData属性名是固定的，因为我PageTag标签处理类就是根据pageData.currentPage这种方式传参的，这个属性名固定应该没什么大的问题，最后我说明下如何在你自己的项目中应用了我这个分页组件，你只需把PageData类，PageTag类，TagUtil类copy到你的项目中，更改下包名即可，然后就是把page.tld文件copy到在web-inf下，当然也不一定非要copy到web-inf，放到任意路径都可以，至于路径问题暂且不讨论,下面是page.tld文件的全部内容：
      <?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
                        "">
<taglib>
 <tlib-version>1.0</tlib-version>
  <jsp-version>1.2</jsp-version>
  <short-name>pager</short-name>
  <uri>/page-tag</uri>
  <description>Paging taglib</description>
  <tag>
    <name>page</name>
    <tag-class>com.yida.common.page.PageTag</tag-class>
    <body-content>empty</body-content>
    <attribute>
        <name>formName</name>
        <!-- 属性值是否必须指定 -->
        <required>false</required>
        <!-- 是否支持jsp脚本 -->
        <fragment>true</fragment>
        <!-- 是否支持动态赋值，如EL表达式 -->
      <rtexprvalue>true</rtexprvalue>
    </attribute>
  </tag>
</taglib>
然后在你web项目的web.xml里注册下你的自定义标签库，加上如下配置：
<jsp-config>
         <taglib>
      <taglib-uri>/page-tag</taglib-uri>
      <taglib-location>/WEB-INF/page.tld</taglib-location>
    </taglib>
 </jsp-config>
最后在你的jsp页面导入这个自定义标签库，如：
     <%@taglib prefix="p" uri="/page-tag"%>
页面上只需这样即可应用：<p:page formName="studentForm"/>，注意这里的formName属性不是必须指定的，formName指的是form表单的name属性值，如果标签里不指定，则标签处理类默认是取document.forms[0]即docuement里的第一个form,还有一点需要注意的是，：<p:page/>必须放在<form></form>标签之间，因为标签处理类里有生成input type="hidden"隐藏域来传递分页参数，如果<p:page/>部分在表单外部，那样的话，表单提交的时候分页参数就无法传递过去,所以正确的应用方法是：
     <form action="??">
     .................
    <p:page/>
    </form>
    当然这里你用struts的form标签也可以，只要<p:page/>被form包含即可。
      最后还需要说明的一点是，你action里查询时，把数据即可封装到PageData中，并把PageData对象设置到request作用域或者session或者application中，一般放到request即可，当然你放到session中，我这个分页组件也支持。至于如何把后台查询返回的List集合包装成一个pageData对象，具体请参看我前面几篇文章里通用Dao的源代码，再个就是把pageData对象通过request对象通过setAttribute("pageData",pageData对象)设置到request作用域，这里是以pageData作为key,且这个key也是固定的，不能修改成别的，因为分页标签处理类就是根绝这个key分别在request、session作用域里查找PageData对象的，如果你希望这个key不写死，那你就在标签处理类里再定义一个属性，通过页面传参过来。但是我是觉得没有必要，这个key写死对程序没什么影响，而且这个key也不可能变化，完全没必要动态，个人观点哈！细心的朋友可能会发现，我标签处理类也考虑了struts1的情况，struts1的部分代码我注释了，如果你项目里是用struts1框架，则请把//适用于Struts2 servlet注释掉，取消掉//适用于Struts1部分的注释即可.

本文来源 我爱IT技术网 http://www.52ij.com/jishu/93.html 转载请保留链接。