JSP分页标签

最新推荐文章于 2018-09-13 19:22:12 发布
最新推荐文章于 2018-09-13 19:22:12 发布
阅读量1k 收藏
点赞数
文章标签： jsp action string 数据库 bean sql
本文介绍了一个基于Struts框架的自定义JSP分页标签实现，该标签支持动态计算页数、显示上一页和下一页链接，并允许用户选择每页显示的记录数。通过将分页信息保存在PageInfor Bean中并放置于Session，实现了灵活的分页导航。
摘要由CSDN通过智能技术生成

最近在学习Struts的标签，结合以前做过的一些小项目，把分页写成了一个标签，做得不是非常的完美，还有很多不足，比如在最后一页显示记录数为6条，这个时候如果改变pageSize，查询出的结果会是空的。。。
先说说自己的分页思路吧：
首先是一个标签处理类，里面有上一页，下一页的连接，以及跳转到第几页，和一个下拉列表用来选择每页显示记录数目，首先它会根据当前页来判断上一页下一页是不是应该显示，
当点击这些连接的时候会触发一个onchange或者是onclick事件，设置一页页面的隐藏表单值，然后提交表单让Action或者是Servlet对应的方法来处理，还有就是当前分页信息会被放在一个PageInfor的实体Bean中，这个Bean会放到Session当中，供Action以及模型层数据调用。。。
先贴一下自己的代码吧：
首先是，分页标签处理类：

Java代码 复制代码
  1. package tags;   
  2.   
  3. import java.io.IOException;   
  4.   
  5. import javax.servlet.jsp.JspException;   
  6. import javax.servlet.jsp.JspWriter;   
  7. import javax.servlet.jsp.tagext.TagSupport;   
  8.   
  9. import model.Page;   
  10. /*  
  11.  * 功能：一个JSP分页标签，可以向这个JSP标签传递的属性有  
  12.  * 1.rowCount:通过查询数据库得到，每次必须都是最新的啊，因为数据表里的数据不断变化,这个属性是必须的，在TLD中要设置required为true;  
  13.  * 要特别注意的就是这个rowCount，应该是带查询条件的记录数目。否则查询后如果总记录数有100条，而查询出的只有一条，它还会显示下一页。。。  
  14.  * 在这里，我是在查询数据库的时候把它查询出来的，然后设置在pageInfor里面。  
  15.  *   
  16.  * 2.pageCount:通过计算得到，由于rowCount的不断变化，它也是不断变化的啊  
  17.  * 3.pageSize:初始值设为10  
  18.  * 4.pageNow:当前页，被保存在一个PageInfor的Bean当中，这个Bean放在缓存当中.这个属性也是必须要设置的。  
  19.  * 5，action_pageIndex方法名，这个最好是不要写在里面，从外面传入方法名，有利于重用。。。  
  20.  *   
  21.  */  
  22. public class PageTag extends TagSupport {   
  23.     /**  
  24.      *   
  25.      */  
  26.     private static final long serialVersionUID = 1L;   
  27.     //一共多少条记录数，这个属性必须要传入   
  28.     private int rowCount=0;   
  29.     //当前页   
  30.     private int pageNow=1;   
  31.     //总共多少页   
  32.     private int pageCount;   
  33.     //每页多少条记录数   
  34.     private int pageSize=10;   
  35.        
  36.     //数据库表名，   
  37.     private String tablename="";   
  38.     //要传入Action层的方法名称，由表现层直接传入，而不是在标签里面写死，更好的重用性。   
  39.     private String action_pageIndex="";   
  40.        
  41.     private String action_pageSize="doPageSize";   
  42.     public int getPageCount() {   
  43.         return pageCount;   
  44.     }   
  45.     public void setPageCount(int pageCount) {   
  46.         this.pageCount = pageCount;   
  47.     }   
  48.     public int getPageNow() {   
  49.         return pageNow;   
  50.     }   
  51.     public void setPageNow(int pageNow) {   
  52.         this.pageNow = pageNow;   
  53.     }   
  54.     public int getPageSize() {   
  55.         return pageSize;   
  56.     }   
  57.     public void setPageSize(int pageSize) {   
  58.         this.pageSize = pageSize;   
  59.     }   
  60.     public int getRowCount() {   
  61.         return rowCount;   
  62.     }   
  63.     public void setRowCount(int rowCount) {   
  64.         this.rowCount = rowCount;   
  65.     }   
  66.     @Override  
  67.     public int doStartTag() throws JspException {   
  68.         JspWriter out=pageContext.getOut();   
  69.         //每次都要计算当前时刻的pageCount,因为rowCount是从pageInfor里面取得的，而pageInfor里面   
  70.         //的rowCount是从数据库中查询到得最新的数据条数。。   
  71.         int state = rowCount % pageSize;   
  72.         System.out.println("RowCOunt==========="+this.rowCount);   
  73.         System.out.println("PageSize============"+this.pageSize);   
  74.         if (state != 0) {   
  75.             pageCount = rowCount / pageSize + 1;   
  76.         } else {   
  77.             pageCount = rowCount / pageSize;   
  78.         }   
  79.   
  80.         if (pageCount <= 0) {   
  81.             pageCount = 1;   
  82.         }   
  83.         StringBuffer result=new StringBuffer();   
  84.         int prePage=pageNow-1;   
  85.         int nextPage=pageNow+1;   
  86.         if(prePage>0){   
  87.             //传递给JS三个参数，第一个是方法名称，第二个是查询页，第三格式页面大小   
  88.             result.append("<a href=# οnclick=doPostBack('"+this.action_pageIndex+"','"+prePage+"','"+this.pageSize+"')>");   
  89.             result.append("上一页");   
  90.             result.append("</a>");   
  91.         }else{   
  92.             result.append("上一页  ");   
  93.         }   
  94.         if(nextPage<=this.pageCount){   
  95.             result.append("<a href=# οnclick=doPostBack('"+this.action_pageIndex+"','"+nextPage+"','"+this.pageSize+"')>");   
  96.             result.append("下一页");   
  97.             result.append("</a>第");   
  98.         }else{   
  99.             result.append("下一页  第");   
  100.         }   
  101.         result.append("<input type='text' size=2 name='pageGoto' id='txtPageIndex' οnchange=doPostBack('"+this.action_pageIndex+"',$F(txtPageIndex),'"+this.pageSize+"')>页");   
  102.         result.append("                                 <select οnchange=doPostBack('"+this.action_pageIndex+"','"+this.pageNow+"',this.value)>");   
  103.         result.append("                                 <option value='10'");   
  104.         if(pageSize==10){   
  105.             //注意要有空格，否则可能会连起来   
  106.             result.append(" selected");   
  107.         }   
  108.         result.append(      ">10条记录</option>");   
  109.         result.append("                                 <option value='15'");   
  110.         if(pageSize==15){   
  111.             //注意要有空格，否则可能会连起来   
  112.             result.append(" selected");   
  113.         }   
  114.         result.append(      ">15条记录</option>");   
  115.         result.append("                                 <option value='20'");   
  116.         if(pageSize==20){   
  117.             //注意要有空格，否则可能会连起来   
  118.             result.append(" selected");   
  119.         }   
  120.         result.append(      ">20条记录</option>");   
  121.         result.append("</select>");   
  122.         result.append("<input type='button' value='Goto' οnclick='doPostBack('"+this.action_pageIndex+"',$F(txtPageIndex),'"+this.pageSize+"')'>");   
  123.         try {   
  124.             out.write(result.toString());   
  125.         } catch (IOException e) {   
  126.             System.out.println("在标签处理类输出的时候出现异常");   
  127.             e.printStackTrace();   
  128.         }   
  129.         return this.EVAL_BODY_INCLUDE;   
  130.     }   
  131.     @Override  
  132.     public int doEndTag() throws JspException {   
  133.         return this.EVAL_PAGE;   
  134.     }   
  135.     public String getAction_pageIndex() {   
  136.         return action_pageIndex;   
  137.     }   
  138.     public void setAction_pageIndex(String action_pageIndex) {   
  139.         this.action_pageIndex = action_pageIndex;   
  140.     }   
  141.     public String getAction_pageSize() {   
  142.         return action_pageSize;   
  143.     }   
  144.     public void setAction_pageSize(String action_pageSize) {   
  145.         this.action_pageSize = action_pageSize;   
  146.     }   
  147. }  
package tags;

import java.io.IOException;

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

import model.Page;
/*
 * 功能：一个JSP分页标签，可以向这个JSP标签传递的属性有
 * 1.rowCount:通过查询数据库得到，每次必须都是最新的啊，因为数据表里的数据不断变化,这个属性是必须的，在TLD中要设置required为true;
 * 要特别注意的就是这个rowCount，应该是带查询条件的记录数目。否则查询后如果总记录数有100条，而查询出的只有一条，它还会显示下一页。。。
 * 在这里，我是在查询数据库的时候把它查询出来的，然后设置在pageInfor里面。
 * 
 * 2.pageCount:通过计算得到，由于rowCount的不断变化，它也是不断变化的啊
 * 3.pageSize:初始值设为10
 * 4.pageNow:当前页，被保存在一个PageInfor的Bean当中，这个Bean放在缓存当中.这个属性也是必须要设置的。
 * 5，action_pageIndex方法名，这个最好是不要写在里面，从外面传入方法名，有利于重用。。。
 * 
 */
public class PageTag extends TagSupport {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	//一共多少条记录数，这个属性必须要传入
	private int rowCount=0;
	//当前页
	private int pageNow=1;
	//总共多少页
	private int pageCount;
	//每页多少条记录数
	private int pageSize=10;
	
	//数据库表名，
	private String tablename="";
	//要传入Action层的方法名称，由表现层直接传入，而不是在标签里面写死，更好的重用性。
	private String action_pageIndex="";
	
	private String action_pageSize="doPageSize";
	public int getPageCount() {
		return pageCount;
	}
	public void setPageCount(int pageCount) {
		this.pageCount = pageCount;
	}
	public int getPageNow() {
		return pageNow;
	}
	public void setPageNow(int pageNow) {
		this.pageNow = pageNow;
	}
	public int getPageSize() {
		return pageSize;
	}
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
	public int getRowCount() {
		return rowCount;
	}
	public void setRowCount(int rowCount) {
		this.rowCount = rowCount;
	}
	@Override
	public int doStartTag() throws JspException {
		JspWriter out=pageContext.getOut();
		//每次都要计算当前时刻的pageCount,因为rowCount是从pageInfor里面取得的，而pageInfor里面
		//的rowCount是从数据库中查询到得最新的数据条数。。
		int state = rowCount % pageSize;
		System.out.println("RowCOunt==========="+this.rowCount);
		System.out.println("PageSize============"+this.pageSize);
		if (state != 0) {
			pageCount = rowCount / pageSize + 1;
		} else {
			pageCount = rowCount / pageSize;
		}

		if (pageCount <= 0) {
			pageCount = 1;
		}
		StringBuffer result=new StringBuffer();
		int prePage=pageNow-1;
		int nextPage=pageNow+1;
		if(prePage>0){
			//传递给JS三个参数，第一个是方法名称，第二个是查询页，第三格式页面大小
			result.append("<a href=# οnclick=doPostBack('"+this.action_pageIndex+"','"+prePage+"','"+this.pageSize+"')>");
			result.append("上一页");
			result.append("</a>");
		}else{
			result.append("上一页  ");
		}
		if(nextPage<=this.pageCount){
			result.append("<a href=# οnclick=doPostBack('"+this.action_pageIndex+"','"+nextPage+"','"+this.pageSize+"')>");
			result.append("下一页");
			result.append("</a>第");
		}else{
			result.append("下一页  第");
		}
		result.append("<input type='text' size=2 name='pageGoto' id='txtPageIndex' οnchange=doPostBack('"+this.action_pageIndex+"',$F(txtPageIndex),'"+this.pageSize+"')>页");
		result.append("									<select οnchange=doPostBack('"+this.action_pageIndex+"','"+this.pageNow+"',this.value)>");
		result.append("									<option value='10'");
		if(pageSize==10){
			//注意要有空格，否则可能会连起来
			result.append(" selected");
		}
		result.append(		">10条记录</option>");
		result.append("									<option value='15'");
		if(pageSize==15){
			//注意要有空格，否则可能会连起来
			result.append(" selected");
		}
		result.append(		">15条记录</option>");
		result.append("									<option value='20'");
		if(pageSize==20){
			//注意要有空格，否则可能会连起来
			result.append(" selected");
		}
		result.append(		">20条记录</option>");
		result.append("</select>");
		result.append("<input type='button' value='Goto' οnclick='doPostBack('"+this.action_pageIndex+"',$F(txtPageIndex),'"+this.pageSize+"')'>");
		try {
			out.write(result.toString());
		} catch (IOException e) {
			System.out.println("在标签处理类输出的时候出现异常");
			e.printStackTrace();
		}
		return this.EVAL_BODY_INCLUDE;
	}
	@Override
	public int doEndTag() throws JspException {
		return this.EVAL_PAGE;
	}
	public String getAction_pageIndex() {
		return action_pageIndex;
	}
	public void setAction_pageIndex(String action_pageIndex) {
		this.action_pageIndex = action_pageIndex;
	}
	public String getAction_pageSize() {
		return action_pageSize;
	}
	public void setAction_pageSize(String action_pageSize) {
		this.action_pageSize = action_pageSize;
	}
}


标签约束文件page.tld:

Java代码 复制代码
  1. <tag>   
  2.         <name>page</name>   
  3.         <tag-class>tags.PageTag</tag-class>   
  4.         <body-content>empty</body-content>   
  5.         <attribute>   
  6.             <name>pageCount</name>   
  7.             <required>false</required>   
  8.             <rtexprvalue>true</rtexprvalue>   
  9.         </attribute>   
  10.         <attribute>   
  11.             <name>rowCount</name>   
  12.             <required>true</required>   
  13.             <rtexprvalue>true</rtexprvalue>   
  14.         </attribute>   
  15.         <attribute>   
  16.             <name>pageSize</name>   
  17.             <required>false</required>   
  18.             <rtexprvalue>true</rtexprvalue>   
  19.         </attribute>   
  20.         <attribute>   
  21.             <name>pageNow</name>   
  22.             <required>true</required>   
  23.             <rtexprvalue>true</rtexprvalue>   
  24.         </attribute>   
  25.         <attribute>   
  26.             <name>action_pageIndex</name>   
  27.             <required>true</required>   
  28.             <rtexprvalue>true</rtexprvalue>   
  29.         </attribute>   
  30.     </tag>  
<tag>
    	<name>page</name>
    	<tag-class>tags.PageTag</tag-class>
    	<body-content>empty</body-content>
    	<attribute>
    		<name>pageCount</name>
    		<required>false</required>
    		<rtexprvalue>true</rtexprvalue>
    	</attribute>
    	<attribute>
    		<name>rowCount</name>
    		<required>true</required>
    		<rtexprvalue>true</rtexprvalue>
    	</attribute>
    	<attribute>
    		<name>pageSize</name>
    		<required>false</required>
    		<rtexprvalue>true</rtexprvalue>
    	</attribute>
    	<attribute>
    		<name>pageNow</name>
    		<required>true</required>
    		<rtexprvalue>true</rtexprvalue>
    	</attribute>
    	<attribute>
    		<name>action_pageIndex</name>
    		<required>true</required>
    		<rtexprvalue>true</rtexprvalue>
    	</attribute>
    </tag>


在web.xml当中进行一下配置：

Java代码 复制代码
  1. <taglib>   
  2.     <taglib-uri>/WEB-INF/tld/page.tld</taglib-uri>   
  3.     <taglib-location>/WEB-INF/tld/page.tld</taglib-location> </taglib>  
<taglib>
  	<taglib-uri>/WEB-INF/tld/page.tld</taglib-uri>
 	<taglib-location>/WEB-INF/tld/page.tld</taglib-location> </taglib>


这样就可以在JSP页面当中进行引用了啊。
还有就是一个pageInfor Bean，用来记录用户当前页，分页大小，查询条件等操作，这个实体Bean会被放到Session当中，供各个类进行调用。
PageInfor代码：

Java代码 复制代码
  1. package tags;   
  2.   
  3. import java.util.HashMap;   
  4. import java.util.Map;   
  5. import model.StockDao;   
  6. /*  
  7.  * 为了保持可重用性，在这个类当中不能有任何关于表信息的代码，表明其实也应该放到外面去。。。  
  8.  * 比如rowCount,这个我们肯定是要通过set方法传给它的，然后再保存到session  
  9.  * 当中去。  
  10.  */  
  11. public class PageInfor {   
  12.     //表示当前页   
  13.     private int pageNow=1;   
  14.     //一共多少条记录，需要查询数据库得到   
  15.     private int rowCount=0;   
  16.     //计算得到总页数   
  17.     private int pageCount=1;   
  18.     //每页显示的记录数   
  19.     private int pageSize=10;   
  20.     //按照哪个字段进行排序   
  21.     private String sortBy="stockid";   
  22.     //按照升序还是降序进行排序，默认是升序   
  23.     private String sortType="asc";   
  24.     //当前业中的查询关键词   
  25.     private Map keyWords=new HashMap();   
  26.     //数据库表名   
  27.     private String tablename;   
  28.     public String getTablename() {   
  29.         return tablename;   
  30.     }   
  31.   
  32.     public void setTablename(String tablename) {   
  33.         this.tablename = tablename;   
  34.     }   
  35.   
  36.     //构造函数，完成初始化   
  37.     public PageInfor(){   
  38.         this.pageNow=1;   
  39.         this.sortType="asc";   
  40.     }   
  41.   
  42.     public Map getKeyWords() {   
  43.         return keyWords;   
  44.     }   
  45.   
  46.     public void setKeyWords(Map keyWords) {   
  47.         this.keyWords = keyWords;   
  48.     }   
  49.   
  50.     public int getPageCount() {   
  51.         return pageCount;   
  52.     }   
  53.   
  54.     public void setPageCount(int pageCount) {   
  55.         int i=this.rowCount%this.pageSize;   
  56.         if(i==0){   
  57.             this.pageCount=this.rowCount/this.pageSize;   
  58.         }else{   
  59.             this.pageCount=this.rowCount/this.pageSize+1;   
  60.         }   
  61.     }   
  62.   
  63.     public int getPageNow() {   
  64.         return pageNow;   
  65.     }   
  66.   
  67.     public void setPageNow(int pageNow) {   
  68.         this.pageNow = pageNow;   
  69.     }   
  70.   
  71.     public int getPageSize() {   
  72.         return pageSize;   
  73.     }   
  74.   
  75.     public void setPageSize(int pageSize) {   
  76.         this.pageSize = pageSize;   
  77.     }   
  78.   
  79.     public int getRowCount() {   
  80.         return rowCount;   
  81.     }   
  82.   
  83.     public void setRowCount(int rowCount) {   
  84.         this.rowCount = rowCount;   
  85.     }   
  86.   
  87.     public String getSortBy() {   
  88.         return sortBy;   
  89.     }   
  90.   
  91.     public void setSortBy(String sortBy) {   
  92.         this.sortBy = sortBy;   
  93.     }   
  94.   
  95.     public String getSortType() {   
  96.         return sortType;   
  97.     }   
  98.   
  99.     public void setSortType(String sortType) {   
  100.         this.sortType = sortType;   
  101.     }   
  102. }  
package tags;

import java.util.HashMap;
import java.util.Map;
import model.StockDao;
/*
 * 为了保持可重用性，在这个类当中不能有任何关于表信息的代码，表明其实也应该放到外面去。。。
 * 比如rowCount,这个我们肯定是要通过set方法传给它的，然后再保存到session
 * 当中去。
 */
public class PageInfor {
	//表示当前页
	private int pageNow=1;
	//一共多少条记录，需要查询数据库得到
	private int rowCount=0;
	//计算得到总页数
	private int pageCount=1;
	//每页显示的记录数
	private int pageSize=10;
	//按照哪个字段进行排序
	private String sortBy="stockid";
	//按照升序还是降序进行排序，默认是升序
	private String sortType="asc";
	//当前业中的查询关键词
	private Map keyWords=new HashMap();
	//数据库表名
	private String tablename;
	public String getTablename() {
		return tablename;
	}

	public void setTablename(String tablename) {
		this.tablename = tablename;
	}

	//构造函数，完成初始化
	public PageInfor(){
		this.pageNow=1;
		this.sortType="asc";
	}

	public Map getKeyWords() {
		return keyWords;
	}

	public void setKeyWords(Map keyWords) {
		this.keyWords = keyWords;
	}

	public int getPageCount() {
		return pageCount;
	}

	public void setPageCount(int pageCount) {
		int i=this.rowCount%this.pageSize;
		if(i==0){
			this.pageCount=this.rowCount/this.pageSize;
		}else{
			this.pageCount=this.rowCount/this.pageSize+1;
		}
	}

	public int getPageNow() {
		return pageNow;
	}

	public void setPageNow(int pageNow) {
		this.pageNow = pageNow;
	}

	public int getPageSize() {
		return pageSize;
	}

	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}

	public int getRowCount() {
		return rowCount;
	}

	public void setRowCount(int rowCount) {
		this.rowCount = rowCount;
	}

	public String getSortBy() {
		return sortBy;
	}

	public void setSortBy(String sortBy) {
		this.sortBy = sortBy;
	}

	public String getSortType() {
		return sortType;
	}

	public void setSortType(String sortType) {
		this.sortType = sortType;
	}
}


最后就是模型层的分页方法了，写得不是很好，见谅啊各位。

Java代码 复制代码
  1. public static List getPageNow(PageInfor pageInfor){   
  2.         int pageNow=pageInfor.getPageNow();   
  3.         int pageSize=pageInfor.getPageSize();   
  4.         String sortBy=pageInfor.getSortBy();   
  5.         String sortType=pageInfor.getSortType();   
  6.         Map keyWords=pageInfor.getKeyWords();   
  7.         List list=new ArrayList();   
  8.         //貌似这条sql语句也挺好用，select * from stock where stockid not in(select stockid from stock where rownum<pageSize*(pageNow-1)) and rowNum<pageSize;   
  9.         //这里有个诡异的地方是，我把表明替换成？用占位符来表示的时候，提示表明无效，只好用这个原始的方法了，嗨。。。   
  10.         String sql="SELECT * FROM (SELECT A.*, ROWNUM RN FROM (SELECT * FROM "+pageInfor.getTablename()+" where 1=1";   
  11.         if(null!=keyWords){   
  12.             Set set=keyWords.keySet();   
  13.             Iterator iterator=set.iterator();   
  14.             while(iterator.hasNext()){   
  15.                 String key=iterator.next().toString();   
  16.                 System.out.println("key========="+key);   
  17.                 String value=keyWords.get(key).toString();   
  18.                 sql+=" and "+key+" = "+value;   
  19.             }   
  20.                
  21.         }   
  22.         //下面这句是用来查询当前查询条件下的总记录数目   
  23.         try {String sql1=sql+")A)";   
  24.         System.out.println("sdfsdf:"+sql1);   
  25.             int rowCount=0;   
  26.             ps=conn.prepareStatement(sql1);   
  27.             rst=ps.executeQuery();   
  28.             while(rst.next()){   
  29.                 rowCount++;   
  30.             }   
  31.             pageInfor.setRowCount(rowCount);   
  32.         } catch (SQLException e) {   
  33.             e.printStackTrace();   
  34.             logger.error("------>getPageNow(PageInfor pageInfor),在查询总记录数的时候出现异常" +   
  35.                     "出错信息是:"+e.getMessage());   
  36.         }   
  37.            
  38.         sql+=" ) A WHERE ROWNUM <=? )WHERE RN >= ?";   
  39.         System.out.println("sql============"+sql);   
  40. //      String sql="select * from stock where stockid not in(select stockid from stock where rownum<=?) and rownum<=?";   
  41.         try {   
  42.             ps=conn.prepareStatement(sql);   
  43.             ps.setInt(1, pageSize*pageNow);   
  44.             ps.setInt(2,(pageNow-1)*pageSize+1);   
  45.             rst=ps.executeQuery();   
  46.             while(rst.next()){   
  47.                 StockBean sb=new StockBean();   
  48.                 sb.setStockid(rst.getString("stockid"));   
  49.                 sb.setWareid(rst.getString("wareid"));   
  50. //              sb.setWarename(rst.getString("warename"));   
  51.                 sb.setStockdate(rst.getDate("stockdate"));   
  52.                 sb.setMoneysum(rst.getInt("moneysum"));   
  53.                 sb.setOperator(rst.getString("operator"));   
  54.                 sb.setStockamount(rst.getInt("stockamount"));   
  55.                 list.add(sb);   
  56.             }   
  57.         } catch (SQLException e2) {   
  58.             e2.printStackTrace();   
  59.             logger.error("在查询分页的时候出现异常，出错信息是："+e2.getMessage());   
  60.         }   
  61.            
  62.         return list;   
  63.     }  
czl_danny
关注
JSP分页标签(最新)
11-24
自己开发的JSP界面分页标签，解决了当前分页代码的繁琐性，只需要导入此jar包即可使用，具体使用方法参照readme.txt文件内容
非常好用的jsp分页标签
06-25
本资源提供了一个非常好用的JSP分页标签，它简化了在JSP页面上实现分页的过程，无需编写过多的Java代码，只需在JSP页面上插入特定的标签即可。 1. **JSP分页标签**：JSP分页标签是一种预定义的、可重用的组件，可以...
JSP标签分页实现
maozhuxigood
07-24 165
网也中经常会用到分页，分页的实现有很多中。从数据库中回去分页数据的方法一般都差不多，主要就是怎么在网页上呈现出来的差别。一般我们会定义一个实体类，他将存放所有与分页相关的数据和设置。在使用struts2的时候可以在后台直接将将数据填充到分页实体类对象中，然后可以在结果页面通过标签活着EL表达式来获取相应的信息来完成分页显示。还有一种就是我们可以通过JSP标签来完成分页的显示。 首先我们定义一个实...
jsp分页标签
xiefangjian的专栏
07-03 989
noka tag是一套jsp标签库，集成了非常多的应用系统常用组件如树形菜单、折叠菜单、选项卡等 noka tag里面的dbgrid标签用于生成一个数据显示表格。此数据表包括分页，按列排序，自带选择框等功能。目前DBGrid支持SQL Server，Oracle，MySQL，PostgreSQL，DB2五种数据库海量数据分页，其它为普通分页。 该标签在子表显示时，当使用sql和class方
JSP自定义分页标签TAG
kevin_Luan的专栏
07-27 5464
首先我们需要在WEB-INF/tld/目录下创建page.tld文件 1.0 1.2 page http://www.kevin.com/taglibs/page htmlPage com.lss.common.tag.PageTag JSP htmlPage Tag pageNo false true pageSiz
Jsp自定义分页标签
小金子的博客
12-10 519
今天呢给大家分享一个Jsp分页标签的源码,由于这个制作的流程虽然不难,但是里面的细节较多,这里小金子没有时间带大家一点一点写出来,只能分享处源码让大家去下载学习,当然了,如果你自己能写出来,那最好啦,这里小金子只是抛砖引玉 这个是模仿百度下面的分页的,效果完全一样,但是百度的比较美观....好,跳过这个话题.. 可以看到效果几乎是一模一样的,当然了,下面就放出使
jsp分页标签库
05-14
本篇将详细介绍如何使用"jsp分页标签库"，以及如何在项目中实现分页功能。 分页是Web应用中常见的功能，特别是在数据量大的情况下，它能够帮助用户更有效地浏览和管理信息。在JSP中，我们可以利用TLD（Tag Library ...
jsp分页标签 分页标记
11-28
分页标记。网页开发中经常遇到查询，当记录多时需要分页显示，通过上一页、下一页浏览全部记录。通常的处理方法比较烦，特别是需要在页面中传递查询参数的表单，比较繁烦，当对记录进行操作时，往往要临时转到其它...
带有多种样式的JSP分页标签
12-11
带有多种样式的JSP分页标签，内附多种样式，方便使用，只需一句标签即可实现多样式分页
JSP自定义分页标签
12-16
JSP自定义分页标签，mysql数据库，通过导入jar包，使用标签的方式实现分页的功能。
自定义JSP分页标签
黄彪博客
09-07 397
1、在WEB-INF目录下面添加adtec.tld文件 <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/j2
自定义分页标签
liushijiao258的专栏
11-20 349
分页标签的使用方式如下： 通过给这个标签传入当前页号、每页要显示的记录数、总记录数和要跳转的URI，这个标签就可以生成翻页的HTML元素。 标签处理类 这个标签只是通过指定属性值就可以生成所有的翻页元素，因此这个标签不需要主体，可以直接继承自TagSupport类：public class PagerTag extends TagSupport {...} 然后为这个标签定义4个属性
jsp标签分页
huaieli1的博客
12-01 282
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <% // pages总页数 current当前页 String json =
jsp自定义分页标签
ld191474639的专栏
09-18 2493
package com.ajax; import java.io.IOException; import java.util.Enumeration; import javax.servlet.http.HttpServletRequest; import javax.servlet.jsp.JspException; import javax.servlet.jsp.tagex
JSP页面分页标签的使用
Orangesss_的博客
09-13 421
1.组成 1. 两个utils工具类 2. 一个tld文件 2.NavigationTag.java package oranges.util; import java.io.IOException; import java.util.Map; import javax.servlet.http.HttpServletRequest; import javax.servlet...
JSP自定义分页标签实现与TLD文件编写详解
在JSP开发中，自定义分页标签是提高代码复用性和页面灵活性的重要手段。本文将详细介绍如何在JSP中实现一个名为`htmlPage`的自定义分页标签，通过`PageTag`类来处理数据分页功能。以下是实现过程的关键步骤和相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值