Rd2PM
HtmlParser初步研究
使用代理模式让应用程序使用动态java代码
httpclient 3.0初步研究
java垃圾回收学习
SimpleStringSearch初步研究
 I am happy on programming web.
posts - 23,comments - 66,trackbacks - 0
[转]jsp分页技术实现
title: JSP分页技术实现
summary:使用工具类实现通用分页处理
author: evan_zhao
email: evan_zhao@hotmail.com
from:http://www.javaresearch.org/article/showarticle.jsp?column=106&thread=8893

　　目前比较广泛使用的分页方式是将查询结果缓存在HttpSession或有状态bean中，翻页的时候从缓存中取出一页数据显示。这种方法有两个主要的缺点：一是用户可能看到的是过期数据；二是如果数据量非常大时第一次查询遍历结果集会耗费很长时间，并且缓存的数据也会占用大量内存，效率明显下降。
　　其它常见的方法还有每次翻页都查询一次数据库，从ResultSet中只取出一页数据（使用rs.last();rs.getRow()获得总计录条数，使用rs.absolute()定位到本页起始记录）。这种方式在某些数据库(如oracle)的JDBC实现中差不多也是需要遍历所有记录，实验证明在记录数很大时速度非常慢。
　　至于缓存结果集ResultSet的方法则完全是一种错误的做法。因为ResultSet在Statement或Connection关闭时也会被关闭，如果要使ResultSet有效势必长时间占用数据库连接。

　　因此比较好的分页做法应该是每次翻页的时候只从数据库里检索页面大小的块区的数据。这样虽然每次翻页都需要查询数据库，但查询出的记录数很少，网络传输数据量不大，如果使用连接池更可以略过最耗时的建立数据库连接过程。而在数据库端有各种成熟的优化技术用于提高查询速度，比在应用服务器层做缓存有效多了。

　　在oracle数据库中查询结果的行号使用伪列ROWNUM表示（从1开始）。例如select *  from employee where rownum<10 返回前10条记录。但因为rownum是在查询之后排序之前赋值的，所以查询employee按birthday排序的第100到120条记录应该这么写：
        select * from (
            select my_table.*, rownum as my_rownum from (
                select name, birthday from employee order by birthday
            ) my_table where rownum <120
        ) where my_rownum>=100

　　mySQL可以使用LIMIT子句：
　　　　select name, birthday from employee order by birthday LIMIT 99,20
　　DB2有rownumber()函数用于获取当前行数。
　　SQL Server没研究过，可以参考这篇文章：http://www.csdn.net/develop/article/18/18627.shtm

　　在Web程序中分页会被频繁使用，但分页的实现细节却是编程过程中比较麻烦的事情。大多分页显示的查询操作都同时需要处理复杂的多重查询条件，sql语句需要动态拼接组成，再加上分页需要的记录定位、总记录条数查询以及查询结果的遍历、封装和显示，程序会变得很复杂并且难以理解。因此需要一些工具类简化分页代码，使程序员专注于业务逻辑部分。下面是我设计的两个工具类：
　　PagedStatement  封装了数据库连接、总记录数查询、分页查询、结果数据封装和关闭数据库连接等操作，并使用了PreparedStatement支持动态设置参数。
　　RowSetPage   参考PetStore的page by page iterator模式， 设计 RowSetPage用于封装查询结果（使用OracleCachedRowSet缓存查询出的一页数据，关于使用CachedRowSet封装数据库查询结果请参考JSP页面查询显示常用模式）以及当前页码、总记录条数、当前记录数等信息， 并且可以生成简单的HTML分页代码。
　　PagedStatement 查询的结果封装成RowsetPage。

　　下面是简单的使用示例：

  2.     //DAO查询数据部分代码：
  3.     …
  4.     public RowSetPage getEmployee(String gender, int pageNo) throws Exception{
  5.         String sql="select emp_id, emp_code,  user_name, real_name from employee where gender =?";
  6.        //使用Oracle数据库的分页查询实现,每页显示5条
  7.         PagedStatement pst =new PagedStatementOracleImpl(sql,  pageNo, 5);
  8.         pst.setString(1, gender);
  9.         return pst.executeQuery();
  10.     }


  13.     //Servlet处理查询请求部分代码：

  15.     …
  16.     int pageNo;
  17.     try{
  18.         //可以通过参数pageno获得用户选择的页码
  19.         pageNo = Integer.parseInt(request.getParameter("pageno") );
  20.     }catch(Exception ex){
  21.         //默认为第一页
  22.         pageNo=1;
  23.     }
  24.     String gender = request.getParameter("gender" );
  25.     request.setAttribute("empPage", myBean.getEmployee(gender, pageNo) );
  26.     …

  28.     //JSP显示部分代码
  29. <%@ page import = "page.RowSetPage"%>
  30.     …
  31.     <script language="javascript">
  32.         function doQuery(){
  33.             form1.actionType.value="doQuery";
  34.             form1.submit();
  35.     }
  36.     </script>
  37.     …
  38.     <form name=form1 method=get>
  39.       <input type=hidden name=actionType>
  40.       性别：
  41.       <input type=text name=gender size=1 value="<%=request.getParameter("gender")%>">
  42.       <input type=button value=" 查询 " onclick="doQuery()">
  43. <%
  44.     RowSetPage empPage = (RowSetPage)request.getAttribute("empPage");
  45.     if (empPage == null ) empPage = RowSetPage.EMPTY_PAGE;
  46. %>
  47.     …
  48.     <table  cellspacing="0" width="90%">
  49.         <tr>  <td>ID</td> <td>代码</td> <td>用户名 </td> <td>姓名</td>  </tr>
  50. <%
  51.     javax.sql.RowSet empRS = (javax.sql.RowSet) empPage.getRowSet();
  52.     if (empRS!=null) while (empRS.next() ) {
  53. %>
  54.         <tr>  
  55.             <td><%= empRS.getString("EMP_ID")%></td> 
  56.             <td><%= empRS.getString("EMP_CODE")%></td>  
  57.             <td><%= empRS.getString("USER_NAME")%></td> 
  58.             <td><%= empRS.getString("REAL_NAME")%></td>  
  59.         </tr>
  60. <%
  61.     }// end while
  62. %>
  63.         <tr>
  64. <%
  65.     //显示总页数和当前页数(pageno)以及分页代码。
  66.     //此处doQuery为页面上提交查询动作的javascript函数名， pageno为标识当前页码的参数名
  67. %>
  68.             <td colspan=4><%= empPage .getHTML("doQuery", "pageno")%></td>
  69.         </tr>
  70.     </table>
  71.     </form>

　　效果如图：


　　因为分页显示一般都会伴有查询条件和查询动作，页面应已经有校验查询条件和提交查询的javascript方法（如上面的doQuery），所以 RowSetPage.getHTML()生成的分页代码在用户选择新页码时直接回调前面的处理提交查询的javascript方法。注意在显示查询结果的时候上次的查询条件也需要保持，如<input type=text name=gender size= 1 value="<%=request.getParameter("gender")%>">。同时由于页码的参数名可以指定，因此也支持在同一页面中有多个分页区。
　　另一种分页代码实现是生成每一页的URL，将查询参数和页码作为QueryString附在URL后面。这种方法的缺陷是在查询条件比较复杂时难以处理，并且需要指定处理查询动作的servlet，可能不适合某些定制的查询操作。
　　如果对RowSetPage.getHTML()生成的默认分页代码不满意可以编写自己的分页处理代码，RowSetPage提供了很多getter方法用于获取相关信息（如当前页码、总页数、 总记录数和当前记录数等）。
　　在实际应用中可以将分页查询和显示做成jsp taglib， 进一步简化JSP代码，屏蔽Java Code。

附：分页工具类的源代码， 有注释，应该很容易理解。

1.Page.java
2.RowSetPage.java(RowSetPage继承Page)
3.PagedStatement.java
4.PagedStatementOracleImpl.java(PagedStatementOracleImpl继承PagedStatement)



您可以任意使用这些源代码，但必须保留author evan_zhao@hotmail.com字样

  2. ///////////////////////////////////
  3. //
  4. //  Page.java
  5. //  author: evan_zhao@hotmail.com
  6. //
  7. ///////////////////////////////////

  9. package page;

  11. import java.util.List;
  12. import java.util.ArrayList;
  13. import java.util.Collection;
  14. import java.util.Collections;


  17. /**
  18.  * Title: 分页对象<br>
  19.  * Description:  用于包含数据及分页信息的对象<br>
  20.  *                Page类实现了用于显示分页信息的基本方法，但未指定所含数据的类型，
  21.  *               可根据需要实现以特定方式组织数据的子类，<br>
  22.  *                如RowSetPage以RowSet 封装数据，ListPage以List封装数据<br>
  23.  * Copyright:    Copyright (c) 2002 <br>
  24.  * @author evan_zhao@hotmail.com <br>
  25.  * @version 1.0
  26.  */
  27. public  class Page implements java.io.Serializable {
  28.     public static final Page EMPTY_PAGE = new Page();
  29.     public static final int  DEFAULT_PAGE_SIZE = 20;
  30.     public static final  int MAX_PAGE_SIZE = 9999;

  32.     private int myPageSize = DEFAULT_PAGE_SIZE;

  34.     private int start;
  35.     private int avaCount,totalSize;
  36.     private Object data;

  38.     private int currentPageno;
  39.     private int totalPageCount;

  41.     /**
  42.      * 默认构造方法，只构造空页
  43.      */
  44.     protected Page(){
  45.         this.init(0,0,0,DEFAULT_PAGE_SIZE,new Object());
  46.     }

  48.     /**
  49.      * 分页数据初始方法，由子类调用
  50.      * @param start 本页数据在数据库中的起始位置
  51.      * @param avaCount 本页包含的数据条数
  52.      * @param totalSize 数据库中总记录条数
  53.      * @param pageSize 本页容量
  54.      * @param data 本页包含的数据
  55.      */
  56.     protected void init(int start, int avaCount, int totalSize, int pageSize, Object data){

  58.         this.avaCount =avaCount;
  59.         this.myPageSize = pageSize;

  61.         this.start = start;
  62.         this.totalSize = totalSize;

  64.         this.data=data;

  66.         //System.out.println("avaCount:"+avaCount);
  67.         //System.out.println("totalSize:"+totalSize);
  68.         if (avaCount>totalSize) {
  69.             //throw new RuntimeException("记录条数大于总条数？！");
  70.         }

  72.         this.currentPageno = (start -1)/pageSize +1;
  73.         this.totalPageCount = (totalSize + pageSize -1) / pageSize;

  75.         if (totalSize==0 && avaCount==0){
  76.             this.currentPageno = 1;
  77.             this.totalPageCount = 1;
  78.         }
  79.         //System.out.println("Start Index to Page No: " + start + "-" + currentPageno);
  80.     }

  82.     public  Object getData(){
  83.         return this.data;
  84.     }

  86.     /**
  87.      * 取本页数据容量（本页能包含的记录数）
  88.      * @return 本页能包含的记录数
  89.      */
  90.     public int getPageSize(){
  91.         return this.myPageSize;
  92.     }

  94.     /**
  95.      * 是否有下一页
  96.      * @return 是否有下一页
  97.      */
  98.     public boolean hasNextPage() {
  99.       /*
  100.         if (avaCount==0 && totalSize==0){
  101.             return false;
  102.         }
  103.         return (start + avaCount -1) < totalSize;
  104.        */
  105.       return (this.getCurrentPageNo()<this.getTotalPageCount());
  106.     }

  108.     /**
  109.      * 是否有上一页
  110.      * @return  是否有上一页
  111.      */
  112.     public boolean hasPreviousPage() {
  113.       /*
  114.         return start > 1;
  115.        */
  116.       return (this.getCurrentPageNo()>1);
  117.     }

  119.     /**
  120.      * 获取当前页第一条数据在数据库中的位置
  121.      * @return
  122.      */
  123.     public int getStart(){
  124.         return start;
  125.     }

  127.     /**
  128.      * 获取当前页最后一条数据在数据库中的位置
  129.      * @return
  130.      */
  131.     public int getEnd(){
  132.         int end = this.getStart() + this.getSize() -1;
  133.         if (end<0) {
  134.             end = 0;
  135.         }
  136.         return end;
  137.     }

  139.     /**
  140.      * 获取上一页第一条数据在数据库中的位置
  141.      * @return 记录对应的rownum
  142.      */
  143.     public int getStartOfPreviousPage() {
  144.         return Math.max(start-myPageSize, 1);
  145.     }


  148.     /**
  149.      * 获取下一页第一条数据在数据库中的位置
  150.      * @return 记录对应的rownum
  151.      */
  152.     public int getStartOfNextPage() {
  153.         return start + avaCount;
  154.     }

  156.     /**
  157.      * 获取任一页第一条数据在数据库中的位置，每页条数使用默认值
  158.      * @param pageNo 页号
  159.      * @return 记录对应的rownum
  160.      */
  161.     public static int getStartOfAnyPage(int pageNo){
  162.         return getStartOfAnyPage(pageNo, DEFAULT_PAGE_SIZE);
  163.     }

  165.     /**
  166.      * 获取任一页第一条数据在数据库中的位置
  167.      * @param pageNo 页号
  168.      * @param pageSize 每页包含的记录数
  169.      * @return 记录对应的rownum
  170.      */
  171.     public static int getStartOfAnyPage(int pageNo, int pageSize){
  172.         int startIndex = (pageNo-1) * pageSize + 1;
  173.         if ( startIndex < 1) startIndex = 1;
  174.         //System.out.println("Page No to Start Index: " + pageNo + "-" + startIndex);
  175.         return startIndex;
  176.     }

  178.     /**
  179.      * 取本页包含的记录数
  180.      * @return 本页包含的记录数
  181.      */
  182.     public int getSize() {
  183.         return avaCount;
  184.     }

  186.     /**
  187.      * 取数据库中包含的总记录数
  188.      * @return 数据库中包含的总记录数
  189.      */
  190.     public int getTotalSize() {
  191.         return this.totalSize;
  192.     }

  194.     /**
  195.      * 取当前页码
  196.      * @return 当前页码
  197.      */
  198.     public int getCurrentPageNo(){
  199.         return  this.currentPageno;
  200.     }

  202.     /**
  203.      * 取总页码
  204.      * @return 总页码
  205.      */
  206.     public int getTotalPageCount(){
  207.         return this.totalPageCount;
  208.     }


  211.     /**
  212.      *
  213.      * @param queryJSFunctionName 实现分页的JS脚本名字，页码变动时会自动回调该方法
  214.      * @param pageNoParamName 页码参数名称
  215.      * @return
  216.      */
  217.     public String getHTML(String queryJSFunctionName, String pageNoParamName){
  218.         if (getTotalPageCount()<1){
  219.             return "<input type='hidden' name='"+pageNoParamName+"' value='1' >";
  220.         }
  221.         if (queryJSFunctionName == null || queryJSFunctionName.trim().length()<1) {
  222.             queryJSFunctionName = "gotoPage";
  223.         }
  224.         if (pageNoParamName == null || pageNoParamName.trim().length()<1){
  225.             pageNoParamName = "pageno";
  226.         }

  228.         String gotoPage = "_"+queryJSFunctionName;

  230.         StringBuffer html = new StringBuffer("\n");
  231.         html.append("<script language=\"Javascript1.2\">\n")
  232.              .append("function ").append(gotoPage).append("(pageNo){  \n")
  233.              .append(  "   var curPage=1;  \n")
  234.              .append(  "   try{ curPage = document.all[\"")
  235.              .append(pageNoParamName).append("\"].value;  \n")
  236.              .append(  "        document.all[\"").append(pageNoParamName)
  237.              .append("\"].value = pageNo;  \n")
  238.              .append(  "        ").append(queryJSFunctionName).append("(pageNo); \n")
  239.              .append(  "        return true;  \n")
  240.              .append(  "   }catch(e){ \n")
  241. //             .append(  "      try{ \n")
  242. //             .append(  "           document.forms[0].submit();  \n")
  243. //             .append(  "      }catch(e){   \n")
  244.              .append(  "          alert('尚未定义查询方法：function ")
  245.              .append(queryJSFunctionName).append("()'); \n")
  246.              .append(  "          document.all[\"").append(pageNoParamName)
  247.              .append("\"].value = curPage;  \n")
  248.              .append(  "          return false;  \n")
  249. //             .append(  "      }  \n")
  250.              .append(  "   }  \n")
  251.              .append(  "}")
  252.              .append(  "</script>  \n")
  253.              .append(  "");
  254.         html.append( "<table  border=0 cellspacing=0 cellpadding=0 align=center width=80%>  \n")
  255.              .append( "  <tr>  \n")
  256.              .append( "    <td align=left><br>  \n");
  257.         html.append(  "       共" ).append( getTotalPageCount() ).append( "页")
  258.              .append(  "       [") .append(getStart()).append("..").append(getEnd())
  259.              .append("/").append(this.getTotalSize()).append("]  \n")
  260.              .append( "    </td>  \n")
  261.              .append( "    <td align=right>  \n");
  262.         if (hasPreviousPage()){
  263.              html.append( "[<a href='javascript:").append(gotoPage)
  264.              .append("(") .append(getCurrentPageNo()-1) 
  265.              .append( ")'>上一页</a>]   \n");
  266.         }
  267.         html.append(  "       第")
  268.              .append(   "        <select name='")
  269.              .append(pageNoParamName).append("' onChange='javascript:")
  270.              .append(gotoPage).append("(this.value)'>\n");
  271.         String selected = "selected";
  272.         for(int i=1;i<=getTotalPageCount();i++){
  273.             if( i == getCurrentPageNo() )
  274.                  selected = "selected";
  275.             else selected = "";
  276.             html.append( "      <option value='").append(i).append("' ")
  277.               .append(selected).append(">").append(i).append("</option>  \n");
  278.         }
  279.         if (getCurrentPageNo()>getTotalPageCount()){
  280.             html.append( "      <option value='").append(getCurrentPageNo())
  281.             .append("' selected>").append(getCurrentPageNo())
  282.             .append("</option>  \n");
  283.         }
  284.         html.append( "    </select>页  \n");
  285.         if (hasNextPage()){
  286.              html.append( "    [<a href='javascript:").append(gotoPage)
  287.                .append("(").append((getCurrentPageNo()+1)) 
  288.                .append( ")'>下一页</a>]   \n");
  289.         }
  290.         html.append( "</td></tr></table>  \n");

  292.         return html.toString();

  294.     }
  295. }




  300. ///////////////////////////////////
  301. //
  302. //  RowSetPage.java
  303. //  author: evan_zhao@hotmail.com
  304. //
  305. ///////////////////////////////////
  306. package page;

  308. import javax.sql.RowSet;


  311. /**
  312.  * <p>Title: RowSetPage</p>
  313.  * <p>Description: 使用RowSet封装数据的分页对象</p>
  314.  * <p>Copyright: Copyright (c) 2003</p>
  315.  * @author evan_zhao@hotmail.com
  316.  * @version 1.0
  317.  */

  319. public class RowSetPage extends Page {
  320.     private javax.sql.RowSet rs;

  322.     /**
  323.      *空页
  324.      */
  325.     public static final RowSetPage EMPTY_PAGE = new RowSetPage();

  327.     /**
  328.      *默认构造方法，创建空页
  329.      */
  330.     public RowSetPage(){
  331.       this(null, 0,0);
  332.     }

  334.     /**
  335.      *构造分页对象
  336.      *@param crs 包含一页数据的OracleCachedRowSet
  337.      *@param start 该页数据在数据库中的起始位置
  338.      *@param totalSize 数据库中包含的记录总数
  339.      */
  340.     public RowSetPage(RowSet crs, int start, int totalSize) {
  341.         this(crs,start,totalSize,Page.DEFAULT_PAGE_SIZE);
  342.     }

  344.     /**
  345.      *构造分页对象
  346.      *@param crs 包含一页数据的OracleCachedRowSet
  347.      *@param start 该页数据在数据库中的起始位置
  348.      *@param totalSize 数据库中包含的记录总数
  349.      *@pageSize 本页能容纳的记录数
  350.      */
  351.     public RowSetPage(RowSet crs, int start, int totalSize, int pageSize) {
  352.         try{
  353.             int avaCount=0;
  354.             if (crs!=null) {
  355.                 crs.beforeFirst();
  356.                 if (crs.next()){
  357.                     crs.last();
  358.                     avaCount = crs.getRow();
  359.                 }
  360.                 crs.beforeFirst();
  361.             }
  362.             rs = crs;
  363.             super.init(start,avaCount,totalSize,pageSize,rs);
  364.         }catch(java.sql.SQLException sqle){
  365.             throw new RuntimeException(sqle.toString());
  366.         }
  367.     }

  369.     /**
  370.      *取分页对象中的记录数据
  371.      */
  372.     public javax.sql.RowSet getRowSet(){
  373.         return rs;
  374.     }


  377. }




  382. ///////////////////////////////////
  383. //
  384. //  PagedStatement.java
  385. //  author: evan_zhao@hotmail.com
  386. //
  387. ///////////////////////////////////

  389. package page;

  391. import foo.DBUtil;

  393. import java.math.BigDecimal;
  394. import java.util.List;
  395. import java.util.Iterator;
  396. import java.util.Collections;

  398. import java.sql.Connection;
  399. import java.sql.SQLException;
  400. import java.sql.ResultSet;
  401. import java.sql.Statement;
  402. import java.sql.PreparedStatement;
  403. import java.sql.Timestamp;
  404. import javax.sql.RowSet;

  406. /**
  407.  * <p>Title: 分页查询</p>
  408.  * <p>Description: 根据查询语句和页码查询出当页数据</p>
  409.  * <p>Copyright: Copyright (c) 2002</p>
  410.  * @author evan_zhao@hotmail.com
  411.  * @version 1.0
  412.  */
  413. public abstract class PagedStatement {
  414.     public final static int MAX_PAGE_SIZE = Page.MAX_PAGE_SIZE;

  416.     protected String countSQL, querySQL;
  417.     protected int pageNo,pageSize,startIndex,totalCount;
  418.     protected javax.sql.RowSet rowSet;
  419.     protected RowSetPage rowSetPage;

  421.     private List boundParams;

  423.     /**
  424.      * 构造一查询出所有数据的PageStatement
  425.      * @param sql  query sql
  426.      */
  427.     public PagedStatement(String sql){
  428.         this(sql,1,MAX_PAGE_SIZE);
  429.     }


  432.     /**
  433.      * 构造一查询出当页数据的PageStatement
  434.      * @param sql  query sql
  435.      * @param pageNo  页码
  436.      */
  437.     public PagedStatement(String sql, int pageNo){
  438.         this(sql, pageNo, Page.DEFAULT_PAGE_SIZE);
  439.     }

  441.     /**
  442.      * 构造一查询出当页数据的PageStatement，并指定每页显示记录条数
  443.      * @param sql query sql
  444.      * @param pageNo 页码
  445.      * @param pageSize 每页容量
  446.      */
  447.     public PagedStatement(String sql, int pageNo, int pageSize){
  448.         this.pageNo = pageNo;
  449.         this.pageSize = pageSize;
  450.         this.startIndex = Page.getStartOfAnyPage(pageNo, pageSize);
  451.         this.boundParams = Collections.synchronizedList(new java.util.LinkedList());

  453.         this.countSQL = "select count(*) from ( " + sql +") ";
  454.         this.querySQL = intiQuerySQL(sql, this.startIndex, pageSize);
  455.     }


  458.     /**
  459.      *生成查询一页数据的sql语句
  460.      *@param sql 原查询语句
  461.      *@startIndex 开始记录位置
  462.      *@size 需要获取的记录数
  463.      */
  464.     protected abstract  String intiQuerySQL(String sql, int startIndex, int size);


  467.     /**
  468.      *使用给出的对象设置指定参数的值
  469.      *@param index 第一个参数为1，第二个为2，。。。
  470.      *@param obj 包含参数值的对象
  471.      */
  472.     public void setObject(int index, Object obj) throws SQLException{
  473.         BoundParam bp = new BoundParam(index, obj);
  474.         boundParams.remove(bp);
  475.         boundParams.add( bp);
  476.     }

  478.     /**
  479.      *使用给出的对象设置指定参数的值
  480.      *@param index 第一个参数为1，第二个为2，。。。
  481.      *@param obj 包含参数值的对象
  482.      *@param targetSqlType 参数的数据库类型
  483.      */
  484.     public void setObject(int index, Object obj, int targetSqlType) throws SQLException{
  485.         BoundParam bp = new BoundParam(index, obj, targetSqlType);
  486.         boundParams.remove(bp);
  487.         boundParams.add(bp );
  488.     }

  490.     /**
  491.      *使用给出的对象设置指定参数的值
  492.      *@param index 第一个参数为1，第二个为2，。。。
  493.      *@param obj 包含参数值的对象
  494.      *@param targetSqlType 参数的数据库类型(常量定义在java.sql.Types中)
  495.      *@param scale 精度，小数点后的位数
  496.      * （只对targetSqlType是Types.NUMBER或Types.DECIMAL有效，其它类型则忽略）
  497.      */
  498.     public void setObject(int index, Object obj, int targetSqlType, int scale) throws SQLException{
  499.         BoundParam bp = new BoundParam(index, obj, targetSqlType, scale) ;
  500.         boundParams.remove(bp);
  501.         boundParams.add(bp);
  502.     }

  504.     /**
  505.      *使用给出的字符串设置指定参数的值
  506.      *@param index 第一个参数为1，第二个为2，。。。
  507.      *@param str 包含参数值的字符串
  508.      */
  509.     public void setString(int index, String str)throws SQLException{
  510.         BoundParam bp = new BoundParam(index, str)  ;
  511.         boundParams.remove(bp);
  512.         boundParams.add(bp);
  513.     }

  515.     /**
  516.      *使用给出的字符串设置指定参数的值
  517.      *@param index 第一个参数为1，第二个为2，。。。
  518.      *@param timestamp 包含参数值的时间戳
  519.      */
  520.     public void setTimestamp(int index, Timestamp timestamp)throws SQLException{
  521.         BoundParam bp = new BoundParam(index, timestamp)  ;
  522.         boundParams.remove(bp);
  523.         boundParams.add( bp );
  524.     }

  526.     /**
  527.      *使用给出的整数设置指定参数的值
  528.      *@param index 第一个参数为1，第二个为2，。。。
  529.      *@param value 包含参数值的整数
  530.      */
  531.     public void setInt(int index, int value)throws SQLException{
  532.         BoundParam bp =  new BoundParam(index, new Integer(value))  ;
  533.         boundParams.remove(bp);
  534.         boundParams.add( bp );
  535.     }

  537.     /**
  538.      *使用给出的长整数设置指定参数的值
  539.      *@param index 第一个参数为1，第二个为2，。。。
  540.      *@param value 包含参数值的长整数
  541.      */
  542.     public void setLong(int index, long value)throws SQLException{
  543.         BoundParam bp =  new BoundParam(index, new Long(value))  ;
  544.         boundParams.remove(bp);
  545.         boundParams.add( bp );
  546.     }

  548.     /**
  549.      *使用给出的双精度浮点数设置指定参数的值
  550.      *@param index 第一个参数为1，第二个为2，。。。
  551.      *@param value 包含参数值的双精度浮点数
  552.      */
  553.     public void setDouble(int index, double value)throws SQLException{
  554.         BoundParam bp =  new BoundParam(index, new Double(value))   ;
  555.         boundParams.remove(bp);
  556.         boundParams.add( bp);
  557.     }

  559.     /**
  560.      *使用给出的BigDecimal设置指定参数的值
  561.      *@param index 第一个参数为1，第二个为2，。。。
  562.      *@param bd 包含参数值的BigDecimal
  563.      */
  564.     public void setBigDecimal(int index, BigDecimal bd)throws SQLException{
  565.         BoundParam bp =   new BoundParam(index, bd )   ;
  566.         boundParams.remove(bp);
  567.         boundParams.add( bp);
  568.     }

  570.     private  void setParams(PreparedStatement pst) throws SQLException{
  571.         if (pst==null || this.boundParams==null || this.boundParams.size()==0 ) return ;
  572.         BoundParam param;
  573.         for (Iterator itr = this.boundParams.iterator();itr.hasNext();){
  574.             param = (BoundParam) itr.next();
  575.             if  (param==null) continue;
  576.             if (param.sqlType == java.sql.Types.OTHER){
  577.                 pst.setObject(param.index, param.value);
  578.             }else{
  579.                 pst.setObject(param.index, param.value, param.sqlType, param.scale);
  580.             }
  581.         }
  582.     }



  586.     /**
  587.      * 执行查询取得一页数据，执行结束后关闭数据库连接
  588.      * @return RowSetPage
  589.      * @throws SQLException
  590.      */
  591.     public  RowSetPage executeQuery() throws SQLException{
  592.         System.out.println("executeQueryUsingPreparedStatement");
  593.         Connection conn = DBUtil.getConnection();
  594.         PreparedStatement pst = null;
  595.         ResultSet rs = null;
  596.         try{
  597.             pst = conn.prepareStatement(this.countSQL);
  598.             setParams(pst);
  599.             rs =pst.executeQuery();
  600.             if (rs.next()){
  601.                 totalCount = rs.getInt(1);
  602.             } else {
  603.                 totalCount = 0;
  604.             }

  606.             rs.close();
  607.             pst.close();

  609.             if (totalCount < 1 ) return RowSetPage.EMPTY_PAGE;

  611.             pst = conn.prepareStatement(this.querySQL);
  612.             System.out.println(querySQL);
  613.             pst.setFetchSize(this.pageSize);
  614.             setParams(pst);
  615.             rs =pst.executeQuery();
  616.             //rs.setFetchSize(pageSize);

  618.             this.rowSet = populate(rs);

  620.             rs.close();
  621.             rs = null;
  622.             pst.close();
  623.             pst = null;

  625.             this.rowSetPage = new RowSetPage(this.rowSet,startIndex,totalCount,pageSize);
  626.             return this.rowSetPage;
  627.         }catch(SQLException sqle){
  628.             //System.out.println("executeQuery SQLException");
  629.             sqle.printStackTrace();
  630.             throw sqle;
  631.         }catch(Exception e){
  632.             e.printStackTrace();
  633.             throw new RuntimeException(e.toString());
  634.         }finally{
  635.             //System.out.println("executeQuery finally");
  636.             DBUtil.close(rs, pst, conn);
  637.         }
  638.     }

  640.     /**
  641.      *将ResultSet数据填充进CachedRowSet
  642.      */
  643.     protected abstract RowSet populate(ResultSet rs) throws SQLException;

  645.     /**
  646.      *取封装成RowSet查询结果
  647.      *@return RowSet
  648.      */
  649.     public javax.sql.RowSet getRowSet(){
  650.         return this.rowSet;
  651.     }


  654.     /**
  655.      *取封装成RowSetPage的查询结果
  656.      *@return RowSetPage
  657.      */
  658.     public RowSetPage getRowSetPage() {
  659.         return this.rowSetPage;
  660.     }



  664.     /**
  665.      *关闭数据库连接
  666.      */
  667.     public void close(){
  668.         //因为数据库连接在查询结束或发生异常时即关闭，此处不做任何事情
  669.         //留待扩充。
  670.     }



  674.     private class BoundParam {
  675.         int index;
  676.         Object value;
  677.         int sqlType;
  678.         int scale;

  680.         public BoundParam(int index, Object value) {
  681.             this(index, value, java.sql.Types.OTHER);
  682.         }

  684.         public BoundParam(int index, Object value, int sqlType) {
  685.             this(index, value, sqlType, 0);
  686.         }

  688.         public BoundParam(int index, Object value, int sqlType, int scale) {
  689.             this.index = index;
  690.             this.value = value;
  691.             this.sqlType = sqlType;
  692.             this.scale = scale;
  693.         }

  695.         public boolean equals(Object obj){
  696.             if (obj!=null && this.getClass().isInstance(obj)){
  697.                 BoundParam bp = (BoundParam)obj;
  698.                 if (this.index==bp.index) return true;
  699.             }
  700.             return false;
  701.         }
  702.     }

  704. }


  707. ///////////////////////////////////
  708. //
  709. //  PagedStatementOracleImpl.java
  710. //  author: evan_zhao@hotmail.com
  711. //
  712. ///////////////////////////////////
  713. package page;
  714. import java.sql.ResultSet;
  715. import java.sql.SQLException;
  716. import javax.sql.RowSet;
  717. import oracle.jdbc.rowset.OracleCachedRowSet;

  719. /**
  720.  * <p>Title: 分页查询Oracle数据库实现</p>
  721.  * <p>Copyright: Copyright (c) 2002</p>
  722.  * @author evan_zhao@hotmail.com
  723.  * @version 1.0
  724.  */
  725. public class PagedStatementOracleImpl extends PagedStatement {

  727.     /**
  728.      * 构造一查询出所有数据的PageStatement
  729.      * @param sql  query sql
  730.      */
  731.     public PagedStatementOracleImpl(String sql){
  732.         super(sql);
  733.     }


  736.     /**
  737.      * 构造一查询出当页数据的PageStatement
  738.      * @param sql  query sql
  739.      * @param pageNo  页码
  740.      */
  741.     public PagedStatementOracleImpl(String sql, int pageNo){
  742.         super(sql, pageNo);
  743.     }

  745.     /**
  746.      * 构造一查询出当页数据的PageStatement，并指定每页显示记录条数
  747.      * @param sql query sql
  748.      * @param pageNo 页码
  749.      * @param pageSize 每页容量
  750.      */
  751.     public PagedStatementOracleImpl(String sql, int pageNo, int pageSize){
  752.         super(sql, pageNo, pageSize);
  753.     }


  756.     /**
  757.      *生成查询一页数据的sql语句
  758.      *@param sql 原查询语句
  759.      *@startIndex 开始记录位置
  760.      *@size 需要获取的记录数
  761.      */
  762.     protected String intiQuerySQL(String sql, int startIndex, int size){
  763.         StringBuffer querySQL = new StringBuffer();
  764.         if (size != super.MAX_PAGE_SIZE) {
  765.             querySQL.append("select * from (select my_table.*,rownum as my_rownum from(")
  766.                     .append(  sql)
  767.                     .append(") my_table where rownum<").append(startIndex + size)
  768.                     .append(") where my_rownum>=").append(startIndex);
  769.         } else {
  770.             querySQL.append("select * from (select my_table.*,rownum as my_rownum from(")
  771.                     .append(sql)
  772.                     .append(") my_table ")
  773.                     .append(") where my_rownum>=").append(startIndex);
  774.         }
  775.         return querySQL.toString();
  776.     }

  778.     /**
  779.      *将ResultSet数据填充进CachedRowSet
  780.      */
  781.     protected  RowSet populate(ResultSet rs) throws SQLException{
  782.         OracleCachedRowSet ocrs = new OracleCachedRowSet();
  783.         ocrs.populate(rs);
  784.         return ocrs;
  785.     }

  787. }


相关连接：
　　JSP页面查询显示常用模式,介绍查询结果集封装的几种常用模式。本程序使用了其中部分代码
　　RowSet规范原来是JDBC(TM) 2.0 Optional Package的一部分，现在已经并入JDBC3.0规范，并且将成为J2SE1.5的组成部分。
　　关于RowSet的实现各个数据库的jdbc driver应该都有提供,oracle实现可以到http://otn.oracle.com/software/tech/java/sqlj_jdbc/content.html下载(Additional RowSet support)
　　Sun也提供了RowSet的参考实现，应该可以支持大多数数据库：http://java.sun.com/products/jdbc/download.html
　　PetStore 是Sun关于J2EE设计模式的一个示例程序。
posted on 2006-03-13 22:27 rd2pm 阅读(954) 评论(0)  编辑  收藏

只有注册用户登录后才能发表评论。
网站导航:
 
Copyright ©2024 rd2pm Powered By博客园 模板提供：沪江博客