jsp翻页

///////////////////////////////////
//
//  RowSetPage.java
//  author: [e-mail]
//
///////////////////////////////////
package page;

import javax.sql.RowSet;


/**
* <p>Title: RowSetPage</p>
* <p>Description: 使用RowSet封装数据的分页对象</p>
* <p>Copyright: Copyright (c) 2003</p>
* @author [e-mail]
* @version 1.0
*/

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

    /**
     *空页
     */
    public static final RowSetPage EMPTY_PAGE = new RowSetPage();

    /**
     *默认构造方法，创建空页
     */
    public RowSetPage(){
      this(null, 0,0);
    }

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

    /**
     *构造分页对象
     *@param crs 包含一页数据的OracleCachedRowSet
     *@param start 该页数据在数据库中的起始位置
     *@param totalSize 数据库中包含的记录总数
     *@pageSize 本页能容纳的记录数
     */
    public RowSetPage(RowSet crs, int start, int totalSize, int pageSize) {
        try{
            int avaCount=0;
            if (crs!=null) {
                crs.beforeFirst();
                if (crs.next()){
                    crs.last();
                    avaCount = crs.getRow();
                }
                crs.beforeFirst();
            }
            rs = crs;
            super.init(start,avaCount,totalSize,pageSize,rs);
        }catch(java.sql.SQLException sqle){
            throw new RuntimeException(sqle.toString());
        }
    }

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


}




///////////////////////////////////
//
//  PagedStatement.java
//  author: [e-mail]
//
///////////////////////////////////

package page;

import foo.DBUtil;

import java.math.BigDecimal;
import java.util.List;
import java.util.Iterator;
import java.util.Collections;

import java.sql.Connection;
import java.sql.SQLException;
import java.sql.ResultSet;
import java.sql.Statement;
import java.sql.PreparedStatement;
import java.sql.Timestamp;
import javax.sql.RowSet;

/**
* <p>Title: 分页查询</p>
* <p>Description: 根据查询语句和页码查询出当页数据</p>
* <p>Copyright: Copyright (c) 2002</p>
* @author [e-mail]
* @version 1.0
*/
public abstract class PagedStatement {
    public final static int MAX_PAGE_SIZE = Page.MAX_PAGE_SIZE;

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

    private List boundParams;

    /**
     * 构造一查询出所有数据的PageStatement
     * @param sql  query sql
     */
    public PagedStatement(String sql){
        this(sql,1,MAX_PAGE_SIZE);
    }


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

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

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


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


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

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

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

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

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

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

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

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

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

    private  void setParams(PreparedStatement pst) throws SQLException{
        if (pst==null || this.boundParams==null || this.boundParams.size()==0 ) return ;
        BoundParam param;
        for (Iterator itr = this.boundParams.iterator();itr.hasNext();){
            param = (BoundParam) itr.next();
            if  (param==null) continue;
            if (param.sqlType == java.sql.Types.OTHER){
                pst.setObject(param.index, param.value);
            }else{
                pst.setObject(param.index, param.value, param.sqlType, param.scale);
            }
        }
    }



    /**
     * 执行查询取得一页数据，执行结束后关闭数据库连接
     * @return RowSetPage
     * @throws SQLException
     */
    public  RowSetPage executeQuery() throws SQLException{
        System.out.println("executeQueryUsingPreparedStatement");
        Connection conn = DBUtil.getConnection();
        PreparedStatement pst = null;
        ResultSet rs = null;
        try{
            pst = conn.prepareStatement(this.countSQL);
            setParams(pst);
            rs =pst.executeQuery();
            if (rs.next()){
                totalCount = rs.getInt(1);
            } else {
                totalCount = 0;
            }

            rs.close();
            pst.close();

            if (totalCount < 1 ) return RowSetPage.EMPTY_PAGE;

            pst = conn.prepareStatement(this.querySQL);
            System.out.println(querySQL);
            pst.setFetchSize(this.pageSize);
            setParams(pst);
            rs =pst.executeQuery();
            //rs.setFetchSize(pageSize);

            this.rowSet = populate(rs);

            rs.close();
            rs = null;
            pst.close();
            pst = null;

            this.rowSetPage = new RowSetPage(this.rowSet,startIndex,totalCount,pageSize);
            return this.rowSetPage;
        }catch(SQLException sqle){
            //System.out.println("executeQuery SQLException");
            sqle.printStackTrace();
            throw sqle;
        }catch(Exception e){
            e.printStackTrace();
            throw new RuntimeException(e.toString());
        }finally{
            //System.out.println("executeQuery finally");
            DBUtil.close(rs, pst, conn);
        }
    }

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

    /**
     *取封装成RowSet查询结果
     *@return RowSet
     */
    public javax.sql.RowSet getRowSet(){
        return this.rowSet;
    }


    /**
     *取封装成RowSetPage的查询结果
     *@return RowSetPage
     */
    public RowSetPage getRowSetPage() {
        return this.rowSetPage;
    }



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



    private class BoundParam {
        int index;
        Object value;
        int sqlType;
        int scale;

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

        public BoundParam(int index, Object value, int sqlType) {
            this(index, value, sqlType, 0);
        }

        public BoundParam(int index, Object value, int sqlType, int scale) {
            this.index = index;
            this.value = value;
            this.sqlType = sqlType;
            this.scale = scale;
        }

        public boolean equals(Object obj){
            if (obj!=null && this.getClass().isInstance(obj)){
                BoundParam bp = (BoundParam)obj;
                if (this.index==bp.index) return true;
            }
            return false;
        }
    }

}


///////////////////////////////////
//
//  PagedStatementOracleImpl.java
//  author: [e-mail]
//
///////////////////////////////////
package page;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.RowSet;
import oracle.jdbc.rowset.OracleCachedRowSet;

/**
* <p>Title: 分页查询Oracle数据库实现</p>
* <p>Copyright: Copyright (c) 2002</p>
* @author [e-mail]
* @version 1.0
*/
public class PagedStatementOracleImpl extends PagedStatement {

    /**
     * 构造一查询出所有数据的PageStatement
     * @param sql  query sql
     */
    public PagedStatementOracleImpl(String sql){
        super(sql);
    }


    /**
     * 构造一查询出当页数据的PageStatement
     * @param sql  query sql
     * @param pageNo  页码
     */
    public PagedStatementOracleImpl(String sql, int pageNo){
        super(sql, pageNo);
    }

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


    /**
     *生成查询一页数据的sql语句
     *@param sql 原查询语句
     *@startIndex 开始记录位置
     *@size 需要获取的记录数
     */
    protected String intiQuerySQL(String sql, int startIndex, int size){
        StringBuffer querySQL = new StringBuffer();
        if (size != super.MAX_PAGE_SIZE) {
            querySQL.append("select * from (select my_table.*,rownum as my_rownum from(")
                    .append(  sql)
                    .append(") my_table where rownum<").append(startIndex + size)
                    .append(") where my_rownum>=").append(startIndex);
        } else {
            querySQL.append("select * from (select my_table.*,rownum as my_rownum from(")
                    .append(sql)
                    .append(") my_table ")
                    .append(") where my_rownum>=").append(startIndex);
        }
        return querySQL.toString();
    }

    /**
     *将ResultSet数据填充进CachedRowSet
     */
    protected  RowSet populate(ResultSet rs) throws SQLException{
        OracleCachedRowSet ocrs = new OracleCachedRowSet();
        ocrs.populate(rs);
        return ocrs;
    }

}