jsp分页技术实现

 

　　目前比较广泛使用的分页方式是将查询结果缓存在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条记录应该这么写：

[pre]        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

[/pre]

　　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封装数据库查询结果请参考）以及当前页码、总记录条数、当前记录数等信息， 并且可以生成简单的HTML分页代码。

　　PagedStatement 查询的结果封装成RowsetPage。

　　下面是简单的使用示例：

2.     //DAO查询数据部分代码：
3.     …
4.     public RowSetPage getEmployee( gender, int pageNo) throws{
5.          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 = .parseInt(request.getParameter("pageno") );
20.     }catch( ex){
21.         //默认为第一页
22.         pageNo=1;
23.     }
24.      gender = request.getParameter("gender" );
25.     request.setAttribute("empPage", myBean.getEmployee(gender, pageNo) );
26.     …
28.     //JSP显示部分代码
29. <%@ page import = "page.RowSetPage"%>
30.     …
31.     "javascript">
32.         function doQuery(){
33.             form1.actionType.value="doQuery";
34.             form1.submit();
35.     }
36.     
37.     …
38.     
39.       
40.       性别：
41.       "<%=request.getParameter("gender")%>">
42.       " 查询 " onclick="doQuery()">
43. <%
44.     RowSetPage empPage = (RowSetPage)request.getAttribute("empPage");
45.     if (empPage == null ) empPage = RowSetPage.EMPTY_PAGE;
46. %>
47.     …
48.     "0" width="90%">
49.         ID代码用户名姓名  
50. <%
51.     javax.sql. empRS = (javax.sql.) empPage.getRowSet();
52.     if (empRS!=null) while (empRS.next() ) {
53. %>
54.           
55.             <%= empRS.getString("EMP_ID")%>
56.             <%= empRS.getString("EMP_CODE")%>  
57.             <%= empRS.getString("USER_NAME")%>
58.             <%= empRS.getString("REAL_NAME")%>  
59.         
60. <%
61.     }// end while
62. %>
63.         
64. <%
65.     //显示总页数和当前页数(pageno)以及分页代码。
66.     //此处doQuery为页面上提交查询动作的javascript函数名， pageno为标识当前页码的参数名
67. %>
68.             <%= empPage .getHTML("doQuery", "pageno")%>
69.         
70.     
71.     

　　效果如图：

　　因为分页显示一般都会伴有查询条件和查询动作，页面应已经有校验查询条件和提交查询的javascript方法（如上面的doQuery），所以RowSetPage.getHTML()生成的分页代码在用户选择新页码时直接回调前面的处理提交查询的javascript方法。注意在显示查询结果的时候上次的查询条件也需要保持，如">。同时由于页码的参数名可以指定，因此也支持在同一页面中有多个分页区。

　　另一种分页代码实现是生成每一页的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 [e-mail]字样

2. ///////////////////////////////////
3. //
4. //  Page.java
5. //  author: [e-mail]
6. //
7. ///////////////////////////////////
9. package page;
11. import java.util.;
12. import java.util.;
13. import java.util.;
14. import java.util.;
17. /**
18.  * Title: 分页对象
    
19.  * Description:  用于包含数据及分页信息的对象
    
20.  *               Page类实现了用于显示分页信息的基本方法，但未指定所含数据的类型，
21.  *               可根据需要实现以特定方式组织数据的子类，
    
22.  *               如RowSetPage以RowSet封装数据，ListPage以List封装数据
    
23.  * Copyright:    Copyright (c) 2002 
    
24.  * @author [e-mail] 
    
25.  * @version 1.0
26.  */
27. public  class Page implements java.io. {
28.     publicstaticfinal Page EMPTY_PAGE = new Page();
29.     publicstaticfinalint  DEFAULT_PAGE_SIZE = 20;
30.     publicstaticfinal  int MAX_PAGE_SIZE = 9999;
32.     privateint myPageSize = DEFAULT_PAGE_SIZE;
34.     privateint start;
35.     privateint avaCount,totalSize;
36.     private data;
38.     privateint currentPageno;
39.     privateint totalPageCount;
41.     /**
42.      * 默认构造方法，只构造空页
43.      */
44.     protected Page(){
45.         this.init(0,0,0,DEFAULT_PAGE_SIZE,new());
46.     }
48.     /**
49.      * 分页数据初始方法，由子类调用
50.      * @param start 本页数据在数据库中的起始位置
51.      * @param avaCount 本页包含的数据条数
52.      * @param totalSize 数据库中总记录条数
53.      * @param pageSize 本页容量
54.      * @param data 本页包含的数据
55.      */
56.     protectedvoid init(int start, int avaCount, int totalSize, int pageSize,  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   getData(){
83.         returnthis.data;
84.     }
86.     /**
87.      * 取本页数据容量（本页能包含的记录数）
88.      * @return 本页能包含的记录数
89.      */
90.     publicint getPageSize(){
91.         returnthis.myPageSize;
92.     }
94.     /**
95.      * 是否有下一页
96.      * @return 是否有下一页
97.      */
98.     publicboolean 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.     publicboolean hasPreviousPage() {
113.       /*
114.         return start > 1;
115.        */
116.       return (this.getCurrentPageNo()>1);
117.     }
119.     /**
120.      * 获取当前页第一条数据在数据库中的位置
121.      * @return
122.      */
123.     publicint getStart(){
124.         return start;
125.     }
127.     /**
128.      * 获取当前页最后一条数据在数据库中的位置
129.      * @return
130.      */
131.     publicint 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.     publicint getStartOfPreviousPage() {
144.         return.max(start-myPageSize, 1);
145.     }
148.     /**
149.      * 获取下一页第一条数据在数据库中的位置
150.      * @return 记录对应的rownum
151.      */
152.     publicint getStartOfNextPage() {
153.         return start + avaCount;
154.     }
156.     /**
157.      * 获取任一页第一条数据在数据库中的位置，每页条数使用默认值
158.      * @param pageNo 页号
159.      * @return 记录对应的rownum
160.      */
161.     publicstaticint getStartOfAnyPage(int pageNo){
162.         return getStartOfAnyPage(pageNo, DEFAULT_PAGE_SIZE);
163.     }
165.     /**
166.      * 获取任一页第一条数据在数据库中的位置
167.      * @param pageNo 页号
168.      * @param pageSize 每页包含的记录数
169.      * @return 记录对应的rownum
170.      */
171.     publicstaticint 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.     publicint getSize() {
183.         return avaCount;
184.     }
186.     /**
187.      * 取数据库中包含的总记录数
188.      * @return 数据库中包含的总记录数
189.      */
190.     publicint getTotalSize() {
191.         returnthis.totalSize;
192.     }
194.     /**
195.      * 取当前页码
196.      * @return 当前页码
197.      */
198.     publicint getCurrentPageNo(){
199.         return  this.currentPageno;
200.     }
202.     /**
203.      * 取总页码
204.      * @return 总页码
205.      */
206.     publicint getTotalPageCount(){
207.         returnthis.totalPageCount;
208.     }
211.     /**
212.      *
213.      * @param queryJSFunctionName 实现分页的JS脚本名字，页码变动时会自动回调该方法
214.      * @param pageNoParamName 页码参数名称
215.      * @return
216.      */
217.     public getHTML( queryJSFunctionName,  pageNoParamName){
218.         if (getTotalPageCount()<1){
219.             return"+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.          gotoPage = "_"+queryJSFunctionName;
230.          html = new("\n");
231.         html.append("\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(  "  \n")
253.              .append(  "");
254.         html.append( "  \n")
255.              .append( "    \n")
256.              .append( "    
       \n");
257.         html.append(  "       共" ).append( getTotalPageCount() ).append( "页")
258.              .append(  "       [") .append(getStart()).append("..").append(getEnd())
259.              .append("/").append(this.getTotalSize()).append("]  \n")
260.              .append( "      \n")
261.              .append( "      \n");
262.         if (hasPreviousPage()){
263.              html.append( "[).append(gotoPage)
264.              .append("(") .append(getCurrentPageNo()-1) 
265.              .append( ")'>上一页]   \n");
266.         }
267.         html.append(  "       第")
268.              .append(   "        )
269.              .append(pageNoParamName).append("' onChange='javascript:")
270.              .append(gotoPage).append("(this.value)'>\n");
271.          selected = "selected";
272.         for(int i=1;i<=getTotalPageCount();i++){
273.             if( i == getCurrentPageNo() )
274.                  selected = "selected";
275.             else selected = "";
276.             html.append( "      ).append(i).append("' ")
277.               .append(selected).append(">").append(i).append("  \n");
278.         }
279.         if (getCurrentPageNo()>getTotalPageCount()){
280.             html.append( "      ).append(getCurrentPageNo())
281.             .append("' selected>").append(getCurrentPageNo())
282.             .append("  \n");
283.         }
284.         html.append( "    页  \n");
285.         if (hasNextPage()){
286.              html.append( "    [).append(gotoPage)
287.                .append("(").append((getCurrentPageNo()+1)) 
288.                .append( ")'>下一页]   \n");
289.         }
290.         html.append( "  \n");
292.         return html.toString();
294.     }
295. }
300. ///////////////////////////////////
301. //
302. //  RowSetPage.java
303. //  author: [e-mail]
304. //
305. ///////////////////////////////////
306. package page;
308. import javax.sql.;
311. /**
312.  * 

     Title: RowSetPage

313.  * 

     Description: 使用RowSet封装数据的分页对象

314.  * 

     Copyright: Copyright (c) 2003

315.  * @author [e-mail]
316.  * @version 1.0
317.  */
319. publicclass RowSetPage extends Page {
320.     private javax.sql. rs;
322.     /**
323.      *空页
324.      */
325.     publicstaticfinal 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( 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( 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. sqle){
365.             thrownew(sqle.toString());
366.         }
367.     }
369.     /**
370.      *取分页对象中的记录数据
371.      */
372.     public javax.sql. getRowSet(){
373.         return rs;
374.     }
377. }
382. ///////////////////////////////////
383. //
384. //  PagedStatement.java
385. //  author: [e-mail]
386. //
387. ///////////////////////////////////
389. package page;
391. import foo.DBUtil;
393. import java.math.;
394. import java.util.;
395. import java.util.;
396. import java.util.;
398. import java.sql.;
399. import java.sql.;
400. import java.sql.;
401. import java.sql.;
402. import java.sql.;
403. import java.sql.;
404. import javax.sql.;
406. /**
407.  * 

     Title: 分页查询

408.  * 

     Description: 根据查询语句和页码查询出当页数据

409.  * 

     Copyright: Copyright (c) 2002

410.  * @author [e-mail]
411.  * @version 1.0
412.  */
413. publicabstractclass PagedStatement {
414.     publicfinalstaticint MAX_PAGE_SIZE = Page.MAX_PAGE_SIZE;
416.     protected countSQL, querySQL;
417.     protectedint pageNo,pageSize,startIndex,totalCount;
418.     protected javax.sql. rowSet;
419.     protected RowSetPage rowSetPage;
421.     private boundParams;
423.     /**
424.      * 构造一查询出所有数据的PageStatement
425.      * @param sql  query sql
426.      */
427.     public PagedStatement( sql){
428.         this(sql,1,MAX_PAGE_SIZE);
429.     }
432.     /**
433.      * 构造一查询出当页数据的PageStatement
434.      * @param sql  query sql
435.      * @param pageNo  页码
436.      */
437.     public PagedStatement( 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( sql, int pageNo, int pageSize){
448.         this.pageNo = pageNo;
449.         this.pageSize = pageSize;
450.         this.startIndex = Page.getStartOfAnyPage(pageNo, pageSize);
451.         this.boundParams = .synchronizedList(new java.util.());
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.     protectedabstract   intiQuerySQL( sql, int startIndex, int size);
467.     /**
468.      *使用给出的对象设置指定参数的值
469.      *@param index 第一个参数为1，第二个为2，。。。
470.      *@param obj 包含参数值的对象
471.      */
472.     publicvoid setObject(int index,  obj) throws{
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.     publicvoid setObject(int index,  obj, int targetSqlType) throws{
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.     publicvoid setObject(int index,  obj, int targetSqlType, int scale) throws{
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.     publicvoid setString(int index,  str)throws{
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.     publicvoid setTimestamp(int index,  timestamp)throws{
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.     publicvoid setInt(int index, int value)throws{
532.         BoundParam bp =  new BoundParam(index, new(value))  ;
533.         boundParams.remove(bp);
534.         boundParams.add( bp );
535.     }
537.     /**
538.      *使用给出的长整数设置指定参数的值
539.      *@param index 第一个参数为1，第二个为2，。。。
540.      *@param value 包含参数值的长整数
541.      */
542.     publicvoid setLong(int index, long value)throws{
543.         BoundParam bp =  new BoundParam(index, new(value))  ;
544.         boundParams.remove(bp);
545.         boundParams.add( bp );
546.     }
548.     /**
549.      *使用给出的双精度浮点数设置指定参数的值
550.      *@param index 第一个参数为1，第二个为2，。。。
551.      *@param value 包含参数值的双精度浮点数
552.      */
553.     publicvoid setDouble(int index, double value)throws{
554.         BoundParam bp =  new BoundParam(index, new(value))   ;
555.         boundParams.remove(bp);
556.         boundParams.add( bp);
557.     }
559.     /**
560.      *使用给出的BigDecimal设置指定参数的值
561.      *@param index 第一个参数为1，第二个为2，。。。
562.      *@param bd 包含参数值的BigDecimal
563.      */
564.     publicvoid setBigDecimal(int index,  bd)throws{
565.         BoundParam bp =   new BoundParam(index, bd )   ;
566.         boundParams.remove(bp);
567.         boundParams.add( bp);
568.     }
570.     private  void setParams( pst) throws{
571.         if (pst==null || this.boundParams==null || this.boundParams.size()==0 ) return ;
572.         BoundParam param;
573.         for ( itr = this.boundParams.iterator();itr.hasNext();){
574.             param = (BoundParam) itr.next();
575.             if  (param==null) continue;
576.             if (param.sqlType == java.sql..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{
592.         .out.println("executeQueryUsingPreparedStatement");
593.          conn = DBUtil.getConnection();
594.          pst = null;
595.          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.             .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.             returnthis.rowSetPage;
627.         }catch( sqle){
628.             //System.out.println("executeQuery SQLException");
629.             sqle.printStackTrace();
630.             throw sqle;
631.         }catch( e){
632.             e.printStackTrace();
633.             thrownew(e.toString());
634.         }finally{
635.             //System.out.println("executeQuery finally");
636.             DBUtil.close(rs, pst, conn);
637.         }
638.     }
640.     /**
641.      *将ResultSet数据填充进CachedRowSet
642.      */
643.     protectedabstract populate( rs) throws;
645.     /**
646.      *取封装成RowSet查询结果
647.      *@return RowSet
648.      */
649.     public javax.sql. getRowSet(){
650.         returnthis.rowSet;
651.     }
654.     /**
655.      *取封装成RowSetPage的查询结果
656.      *@return RowSetPage
657.      */
658.     public RowSetPage getRowSetPage() {
659.         returnthis.rowSetPage;
660.     }
664.     /**
665.      *关闭数据库连接
666.      */
667.     publicvoid close(){
668.         //因为数据库连接在查询结束或发生异常时即关闭，此处不做任何事情
669.         //留待扩充。
670.     }
674.     privateclass BoundParam {
675.         int index;
676.          value;
677.         int sqlType;
678.         int scale;
680.         public BoundParam(int index,  value) {
681.             this(index, value, java.sql..OTHER);
682.         }
684.         public BoundParam(int index,  value, int sqlType) {
685.             this(index, value, sqlType, 0);
686.         }
688.         public BoundParam(int index,  value, int sqlType, int scale) {
689.             this.index = index;
690.             this.value = value;
691.             this.sqlType = sqlType;
692.             this.scale = scale;
693.         }
695.         publicboolean equals( obj){
696.             if (obj!=null&&this.getClass().isInstance(obj)){
697.                 BoundParam bp = (BoundParam)obj;
698.                 if (this.index==bp.index) returntrue;
699.             }
700.             returnfalse;
701.         }
702.     }
704. }
707. ///////////////////////////////////
708. //
709. //  PagedStatementOracleImpl.java
710. //  author: [e-mail]
711. //
712. ///////////////////////////////////
713. package page;
714. import java.sql.;
715. import java.sql.;
716. import javax.sql.;
717. import oracle.jdbc.rowset.OracleCachedRowSet;
719. /**
720.  * 

     Title: 分页查询Oracle数据库实现

721.  * 

     Copyright: Copyright (c) 2002

722.  * @author [e-mail]
723.  * @version 1.0
724.  */
725. publicclass PagedStatementOracleImpl extends PagedStatement {
727.     /**
728.      * 构造一查询出所有数据的PageStatement
729.      * @param sql  query sql
730.      */
731.     public PagedStatementOracleImpl( sql){
732.         super(sql);
733.     }
736.     /**
737.      * 构造一查询出当页数据的PageStatement
738.      * @param sql  query sql
739.      * @param pageNo  页码
740.      */
741.     public PagedStatementOracleImpl( 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( sql, int pageNo, int pageSize){
752.         super(sql, pageNo, pageSize);
753.     }
756.     /**
757.      *生成查询一页数据的sql语句
758.      *@param sql 原查询语句
759.      *@startIndex 开始记录位置
760.      *@size 需要获取的记录数
761.      */
762.     protected intiQuerySQL( sql, int startIndex, int size){
763.          querySQL = new();
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   populate( rs) throws{
782.         OracleCachedRowSet ocrs = new OracleCachedRowSet();
783.         ocrs.populate(rs);
784.         return ocrs;
785.     }
787. }

出处： 作者：佚名

 

 

源文档 <>