数据库的操作

数据库的

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.sql.DataSource;

import com.wyebd.publicuse.ApplicationResource;

public class DBProxy
{
 private Connection _conn = null;//存放当前的数据库连接对象
 private List _listResultSet = new ArrayList();//存放在当前的数据库连接对象中使用的ResultSet对象
 private List _listStatement = new ArrayList();//存放在当前的数据库连接对象中使用的Statement对象
 
    /**
     * 通过静态工厂方法返回DBProxy的实例
     * @return DBProxy
     */
    public static DBProxy getInstance()
    {
        return new DBProxy();
    }
 /**
  * 私有构造方法，完成数据库连接的获取。
  */
   
   
    public static void main(String[] args){
     DBProxy.getInstance();
    }
 private DBProxy()
 {
  //通过应用服务器提供的连接池访问数据库
  String dsName = ApplicationResource.getValueByKey("DataSourceName");
  try
  {
   DataSource ds = null;
   Context ctx = new InitialContext();
            ds  =  (DataSource)ctx.lookup(dsName);
   //Object ref = ctx.lookup(dsName);
   //ds = (DataSource)PortableRemoteObject.narrow(ref, DataSource.class);
   _conn = ds.getConnection();
   _conn.setAutoCommit(false); //禁止自动提交
  }
  catch (Exception ex)
  {
   //System.out.println(ex.getMessage());
   //上下文环境变量中找不到数据源，则采用手动方式连接数据库
   try
   {
    Class.forName(ApplicationResource.getValueByKey("driver"));
    //System.out.println(ApplicationResource.getValueByKey("url"));
    _conn = DriverManager.getConnection(ApplicationResource.getValueByKey("url"),
      ApplicationResource.getValueByKey("username"),
      ApplicationResource.getValueByKey("password")); //获得数据库连接对象
    _conn.setAutoCommit(false); //禁止自动提交，以用于事务中处理提交或者回滚
   }
   catch(Exception sqle)
   {
    sqle.printStackTrace();
   }   
  }
 }

 
 /**
  * 返回当前的数据库连接对象。
  * @return Connection
  */
 public Connection getConnection()
 {
  return this._conn;
 }

 /**
  * 执行数据库的查询操作，将传入的字符串参数做为数据库查询操作的SQL语句。由于需要返回ResultSet对象，
     * 故此处无法进行数据库连接资源的清理，必须在调用该方法处执行完业务操作后调用该类的release()方法执行
     * 数据库连接资源的清理。
  * @param sqlClause String 查询操作的SQL语句
  * @return ResultSet 按照查询操作的SQL语句得到的结果集
  */
 public ResultSet query(String sqlClause) throws SQLException
 {
     ResultSet rs = null;

  try
  {
      PreparedStatement pStmt = _conn.prepareStatement(sqlClause,ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,ResultSet.HOLD_CURSORS_OVER_COMMIT);
      _listStatement.add(pStmt);
      rs = pStmt.executeQuery();
      _listResultSet.add(rs);
  }
  catch (SQLException sqle)
  {
      throw sqle;
  }

  return rs;
 }

 /**
  * 用PreparedStatement 查询数据库。
  * 执行数据库的查询操作，将传入的字符串参数做为数据库查询操作的SQL语句，查询语句中的占位符与数组参数必须一一对应。
  * 由于需要返回ResultSet对象，故此处无法进行数据库连接资源的清理，
     * 必须在调用该方法处执行完业务操作后调用该类的release()方法执行清理。
  * @param sqlClause  String 查询操作的SQL语句（包括占位符）
  * @param vals Object[] 对应占位符的数组变量
  * @return ResultSet 按照查询操作的SQL语句得到的结果集
  */
 public ResultSet query(String sqlClause, Object[] vals) throws SQLException
 {
     ResultSet rs = null;

     try
  {
      PreparedStatement pStmt = _conn.prepareStatement(sqlClause,ResultSet.TYPE_SCROLL_INSENSITIVE,
           ResultSet.CONCUR_READ_ONLY,ResultSet.HOLD_CURSORS_OVER_COMMIT);
      _listStatement.add(pStmt);

      if (vals != null)
   {
    int size = vals.length;
    for (int i = 0; i < size; i++)
    {
     if (vals[i] != null)
     {
      pStmt.setObject( (i + 1), vals[i]);
     }
     else
     {
      pStmt.setNull( (i + 1), Types.OTHER);
     }
    }
   }

      rs = pStmt.executeQuery();
      _listResultSet.add(rs);
  }
  catch (SQLException sqle)
  {
      throw sqle;
  }

  return rs;
 }

 /**
  * 执行数据库的更新操作，将传入的字符串参数做为数据库更新操作的SQL语句。
  * @param sqlClause String 更新数据库的SQL语句
  * @return int 返回操作影响的数据行数
  */
 public int update(String sqlClause) throws SQLException
 {
  int changeCount = 0;
  PreparedStatement pStmt = null;

  try
  {
      pStmt = _conn.prepareStatement(sqlClause);
      changeCount = pStmt.executeUpdate();
   _conn.commit();
     }
  catch (SQLException sqle)
  {
   throw sqle;
  }
  finally
  {
      close(pStmt);
  }

  return changeCount;
 }

 /**
  * 用PreparedStatement更新数据库。
  * 执行数据库的更新操作，将传入的字符串参数做为数据库更新操作的SQL语句，更新语句中的占位符与数组参数必须一一对应。
  * @param sqlClause  String 查询操作的SQL语句（包括占位符）
  * @param columnValues Object[] 对应占位符的数组变量
  * @return int 数据操作影响的行数
  */
 public int update(String sqlClause, Object[] columnValues) throws SQLException
 {
  int changeCount = 0;
  PreparedStatement pStmt = null;
  
  try
  {
      pStmt = _conn.prepareStatement(sqlClause);
   if (columnValues != null)
   {
    int size = columnValues.length;
    for (int i = 0; i < size; i++)
    {
     if (columnValues[i] != null)
     {
      pStmt.setObject( (i + 1), columnValues[i]);
     }
     else
     {
      pStmt.setNull( (i + 1), Types.OTHER);
     }
    }
   }

   changeCount = pStmt.executeUpdate();
   _conn.commit();
  }
  catch (SQLException sqle)
  {
      throw sqle;
  }
  finally
  {
      close(pStmt);
  }

  return changeCount;
 }

    /**
     * 带事务的数据更新处理：执行数据库的更新操作，将传入的字符串参数做为数据库更新操作的SQL语句。
     * @param sqlClause String 更新数据库的SQL语句
     * @return int 返回操作影响的数据行数
     */
    public int updateWithTrans(String sqlClause) throws SQLException
    {
        int changeCount = 0;
        PreparedStatement pStmt = null;

        try
        {
            pStmt = _conn.prepareStatement(sqlClause);
   changeCount = pStmt.executeUpdate();
       }
        catch (SQLException sqle)
        {
   throw sqle;
        }
  finally
  {
      close(pStmt);
  }

        return changeCount;
    }

    /**
     * 带事务的数据更新处理：用PreparedStatement更新数据库。
     * 执行数据库的更新操作，将传入的字符串参数做为数据库更新操作的SQL语句，更新语句中的占位符与数组参数必须一一对应。
     * @param sqlClause  String 查询操作的SQL语句（包括占位符）
     * @param columnValues Object[] 对应占位符的数组变量
     * @return ResultSet 数据操作影响的行数
     */
    public int updateWithTrans(String sqlClause, Object[] columnValues) throws SQLException
    {
        int changeCount = 0;
        PreparedStatement pStmt = null;
        try
        {
            pStmt = _conn.prepareStatement(sqlClause);
            if (columnValues != null)
            {
                int size = columnValues.length;
                for (int i = 0; i < size; i++)
                {
                    if (columnValues[i] != null)
                    {
                        pStmt.setObject( (i + 1), columnValues[i]);
                    }
                    else
                    {
                        pStmt.setNull( (i + 1), Types.OTHER);
                    }
                }
            }

            changeCount = pStmt.executeUpdate();
        }
        catch (SQLException sqle)
        {
   throw sqle;
        }
  finally
  {
      close(pStmt);
  }

        return changeCount;
    }

 /**
  * 带事务的数据更新处理：将多个SQL语句存放在List对象中，并放于同一事务中处理。
  * @param listSql List 放在同一事务中处理的sql语句列表
  * @return boolean 事务的处理结果.成功返回true,否则返回false
  */
 public boolean updateWithTrans(List listSql) throws SQLException
 {
  boolean result = false;
  Statement stmt = null;

  try
  {
      stmt = _conn.createStatement();
   Iterator it = listSql.iterator();
   while (it.hasNext())
   {
    stmt.addBatch(String.valueOf(it.next()));
   }

   stmt.executeBatch();
   result = true;
  }
  catch (SQLException sqle)
  {
            result = false;
   throw sqle;
  }
  finally
  {
      close(stmt);
  }

  return result;
 }

    /**
     * 设置事务执行的开始点。
     * @return 操作成功与否
     */
    public boolean doSetSavepoint()
    {
        boolean bResult = false;
       
        try
        {
            _conn.setAutoCommit(false);
            bResult = true;
        }
        catch(SQLException sqle)
        {
            bResult = false;
        }
       
        return bResult;
    }

    /**
     * 执行事务提交操作。如果提交失败则自动执行回滚操作。
     * @return 操作成功与否
     */
    public boolean doCommit()
    {
        boolean bResult = false;

        try
        {
            _conn.commit();
            bResult = true;
        }
        catch(SQLException sqle)
        {
            bResult = false;
        }
       
        return bResult;
    }

    /**
     * 执行事务回滚操作。
     * @return 操作成功与否
     */
    public boolean doRollback()
    {
        boolean bResult = false;
        try
        {
            _conn.rollback();
            bResult = true;
        }
        catch(SQLException sqle)
        {
            bResult = false;
        }
       
        return bResult;
    }

 
 /**
  * 单独关闭Statement,公开此方法，以便于其它类中调用单独关闭Statement。
  * @param stmt Statement
 public void closeStatement(Statement stmt)
 {
  close(stmt);
 }
  */

 /**
  * 单独关闭ResultSet,公开此方法，以便于其它类中调用单独关闭ResultSet。
  * @param rs ResultSet
 public void closeResultSet(ResultSet rs)
 {
  close(rs);
 }
  */

 /**
  * 关闭ResultSet。
  * @param rs ResultSet
  */
 private void close(ResultSet rs)
 {
  try
  {
   if (rs != null)
    rs.close();
   rs = null;
  }
  catch (SQLException e)
  {
   e.printStackTrace();
  }
 }

 /**
  * 关闭Statement。
  * @param stmt Statement
  */
 private void close(Statement stmt)
 {
  try
  {
   if (stmt != null)
    stmt.close();
   stmt = null;
  }
  catch (SQLException e)
  {
   e.printStackTrace();
  }
 }

 /**
  * 关闭数据库连接。
  * @param _conn Connection
  */
 private void close(Connection _conn)
 {
  try
  {
   if (_conn != null)
   {
    _conn.close();
   }
  }
  catch (SQLException e)
  {
   e.printStackTrace();
  }
 }

    /**
     *  释放所有的资源：使用完DBProxy类后，必须在finally语句中调用此方法，以实现彻底释放所有的资源。
     */
    public void release()
    {
        //关闭listResultSet集合中的ResultSet对象
  Iterator itResultSet = _listResultSet.iterator();
  //System.out.println("_listResultSet.size():" + _listResultSet.size());
  //System.out.println("_listStatement.size():" + _listStatement.size());
  while (itResultSet.hasNext())
  {
      close((ResultSet)itResultSet.next());
  }       
       
        //关闭listStatement集合中的Statement对象
  Iterator itStatement = _listStatement.iterator();
  while (itStatement.hasNext())
  {
      close((Statement)itStatement.next());
  }       
  
  //关闭数据库连接对象
  close(_conn);
    }

   

 /*
 public static void main(String[] args) throws Exception {
  String strSQL = "Create table ? " +
    "( ? ," +
    "  ? ," +
    "  ? ," +
    "  ? )";
  Object[] objParam = {"TableTest", "SaleID INT IDENTITY(100000,1) NOT FOR REPLICATION",
    "CHECK NOT FOR REPLICATION (SaleID <= 199999)",
    "SalesRegion CHAR(2)",
    "CONSTRAINT ID_PK PRIMARY KEY (SaleID)"};
  //建立数据库表格
  String strSQL = "CREATE TABLE mylogintable   " +
    "( date_in datetime, user_id int, myuser_name varchar(100) )";
  Object[] objParam = null;
  
  Test test = new Test();
  System.out.println(test.changeData(strSQL,objParam));
  

  //删除数据库表格
  String strSQL = "DROP TABLE mylogintable ";
  Object[] objParam = null;
  
  Test test = new Test();
  System.out.println(test.changeData(strSQL,objParam));
  
  

  String strSQL = "insert into  dbo.Sys_User ( User_Name , Card_Id ) values ( ?, ? )";
  Object[] objParam = { "fjpddd", "343434"};

  Test test = new Test();
  System.out.println(test.changeData(strSQL,objParam));
  
     DBProxy dbProxy = DBProxy.getInstance();
  ResultSet rs = dbProxy.query("select * from Dim_Tab_Define ");
  if (rs.next())
      System.out.println(rs.getString("Table_Name"));
  
  rs = dbProxy.query("select * from Dim_Prop_Define  ");
  if (rs.next())
      System.out.println(rs.getString("Column_Name"));
  dbProxy.release();
 }
 */
}

 

 

 

运用数据库进行操作的一些方法

 

import java.io.Serializable;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import com.wyebd.publicuse.ApplicationResource;
import com.wyebd.publicuse.Debug;

public class BaseTable extends ArrayList implements Serializable
{
 //用于翻页时的数据变量定义
 protected int intRowCount = 0; //记录数据总条数
 protected int intPageCount = 0; //记录数据总页数
 protected int intCurrentPageNo = 1; //记录数据当前页数
 //protected int intPageSize = Integer.valueOf(ApplicationResource.getValueByKey("app.data.pagesize")).intValue(); //记录每页显示的数据数
 protected int intPageSize = 20;

 //用于定位数据位置时的数据变量定义
 private int currPosition = 0;
 protected boolean eof = true;//结果集结尾标志
 protected boolean bof = true;//结果集开始标志

 //用于事务操作中的代理类
    private DBProxy dbProxyWithTrans = null;
   
    //用于sqlServer的日期格式
    private static DateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  
    protected ResultSetMetaData metaData=null;
   
   
    public ResultSetMetaData getMetaData()
 {
  return metaData;
 }

 public static  DateFormat getDf()
    {
     return (DateFormat) df.clone();
    }

    /**
     * 提供翻页的数据查询操作。执行SELECT数据操作，并将查询结果存储至当前BaseTable对象中，并关闭记录集。
     * @param selectSql String  选取数据的SQL语句
     * @param request HttpServletRequest  页面的请求对象
     * @return BaseTable 返回根据SQL语句选取的当前页的数据结果集封装成的ArrayList
     */
    public BaseTable selectData(String selectSql,HttpServletRequest request)
    {
        ResultSet rs = null;
        DBProxy dbProxy = DBProxy.getInstance();

     String strCurrentPageNo = request.getParameter("pageNo");  //取得待显示页码
     String strPageSize = request.getParameter("pageSize"); //取得每页显示的数据数

     if (strCurrentPageNo != null && !strCurrentPageNo.equals(""))
         intCurrentPageNo = Integer.valueOf(strCurrentPageNo).intValue();
     else
         intCurrentPageNo = 1;

     if (strCurrentPageNo != null && !strCurrentPageNo.equals(""))
      intPageSize = Integer.valueOf(strPageSize).intValue();
     else
         intPageSize = Integer.valueOf(ApplicationResource.getValueByKey("app.data.pagesize")).intValue();

        try
        {
            rs = dbProxy.query(selectSql);
            metaData =rs.getMetaData();
           
         //取得总共的数据条数
         rs.last();
         intRowCount = rs.getRow();
         rs.first();

         intPageCount = (intRowCount + intPageSize - 1) / intPageSize;

         if (intCurrentPageNo > intPageCount)
             intCurrentPageNo = intPageCount;

         rs.absolute((intCurrentPageNo - 1) * intPageSize + 1);
            pushToMap(rs, intPageSize); //只取一页的数据
            goFirst();
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.selectData(String selectSql):" + selectSql,true);
            Debug.printException(e,"BaseTable.selectData(String selectSql)");
        }
        finally
        {
            dbProxy.release();
        }

        return this;
    }

    /**
     * 提供翻页的数据查询操作。用PreparedStatement执行SELECT数据操作，并将查询结果存储至当前BaseTable对象中，并关闭记录集。
     * @param selectSql String  选取数据的带有占位符的SQL语句
     * @param columnValues 对应SQL语句中的占位符的替换值
     * @param request HttpServletRequest  页面的请求对象
     * @return  返回根据SQL语句选取的数据结果集封装成的ArrayList
     */
    public BaseTable selectData(String selectSql, Object[] columnValues,HttpServletRequest request)
    {
        ResultSet rs = null;
        DBProxy dbProxy = DBProxy.getInstance();

     String strCurrentPageNo = request.getParameter("pageNo");  //取得待显示页码
     String strPageSize = request.getParameter("pageSize"); //取得每页显示的数据数

     if (strCurrentPageNo != null && !strCurrentPageNo.equals(""))
         intCurrentPageNo = Integer.valueOf(strCurrentPageNo).intValue();
     else
         intCurrentPageNo = 1;

     if (strCurrentPageNo != null && !strCurrentPageNo.equals(""))
      intPageSize = Integer.valueOf(strPageSize).intValue();
     else
         intPageSize = Integer.valueOf(ApplicationResource.getValueByKey("app.data.pagesize")).intValue();

        try
        {
            rs = dbProxy.query(selectSql,columnValues);
            metaData =rs.getMetaData();
           
         //取得总共的数据条数
         rs.last();
         intRowCount = rs.getRow();
         rs.first();

         intPageCount = (intRowCount + intPageSize - 1) / intPageSize;

         if (intCurrentPageNo > intPageCount)
             intCurrentPageNo = intPageCount;

         rs.absolute((intCurrentPageNo - 1) * intPageSize + 1);
            pushToMap(rs, intPageSize); //只取一页的数据
            goFirst();
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.selectData(String selectSql, Object[] columnValues):" + selectSql,true);
            Debug.printException(e,"BaseTable.selectData(String selectSql, Object[] columnValues)");
        }
        finally
        {
            dbProxy.release();
        }

        return this;
    }

    /**
     * 用于在JSP页面上输出翻页控制功能的链接及按钮对象
     * @param pageLink String 该参数包括翻页后跳转的页面链接及所有需要传递的参数（如：数据查询条件、页面判断逻辑标识等），翻页控制参数（即：每页的数据条数和第几页）除外。
     * @return String
     */
    public String writePageInfo(String pageLink)
    {
  String pageInfo = "";

  //如果链接串中不含义"?"符号，如:pageControl.writePageInfo("rdbloglist.jsp")，则系统在后边自动添加，以免拼凑出的字符串出现HTML语法错误
  if (pageLink.indexOf("?") == -1)
   pageLink = pageLink + "?1=1";

  if (intRowCount > 0)
  {
   pageInfo = "数据总数：" + intRowCount + "&nbsp;&nbsp;第" + intCurrentPageNo +
        "页/共" + intPageCount + "页/n";

   if (intCurrentPageNo != 1)
   {
    pageInfo = pageInfo + "&nbsp;&nbsp;<a href=/"" + pageLink + "&pageNo=1&pageSize=" +
         intPageSize + "/" title='点击显示首页数据'>首页</a>/n";
   }

   if (intCurrentPageNo > 1)
   {
    pageInfo = pageInfo + "&nbsp;<a href=/"" + pageLink + "&pageNo=" +
         String.valueOf(intCurrentPageNo - 1) + "&pageSize=" + intPageSize +
         "/" title='点击显示前一页数据'>上页</a>/n";
   }

   if (intCurrentPageNo < intPageCount)
   {
    pageInfo = pageInfo + "&nbsp;<a href=/"" + pageLink + "&pageNo=" +
         String.valueOf(intCurrentPageNo + 1) + "&pageSize=" + intPageSize +
         "/" title='点击显示下一页数据'>下页</a>/n";
   }

   if (intCurrentPageNo < intPageCount)
   {
    pageInfo = pageInfo + "&nbsp;<a href=/"" + pageLink + "&pageNo=" +
         String.valueOf(intPageCount) + "&pageSize=" + intPageSize +
         "/" title='点击显示尾页数据'>尾页</a>/n";
   }

   pageInfo = pageInfo + "<script language='javascript'>/n";
   pageInfo = pageInfo + "function gotoPage(objGoButton)/n";
   pageInfo = pageInfo + "{/n";
   pageInfo = pageInfo + "    var objPageSize,objPageNo;/n";
   pageInfo = pageInfo + "    if (isNaN(document.all.pageSize.value))/n";
   pageInfo = pageInfo + "    {/n";
   pageInfo = pageInfo + "        var bJ = 0;/n";
   pageInfo = pageInfo + "        for (var i = 0; i < document.all.length; i ++)/n";
   pageInfo = pageInfo + "        {/n";
   pageInfo = pageInfo + "            if (document.all(i).value=='Go')/n";
   pageInfo = pageInfo + "            {/n";
   pageInfo = pageInfo + "                if (document.all(i) == objGoButton)/n";
   pageInfo = pageInfo + "                {/n";
   pageInfo = pageInfo + "                    objPageSize = document.all.pageSize(bJ)/n";
   pageInfo = pageInfo + "                    objPageNo = document.all.pageNo(bJ)/n";
   pageInfo = pageInfo + "                    break;/n";
   pageInfo = pageInfo + "                }/n";
   pageInfo = pageInfo + "                else/n";
   pageInfo = pageInfo + "                    bJ ++;/n";
   pageInfo = pageInfo + "            }/n";
   pageInfo = pageInfo + "        }/n";
   pageInfo = pageInfo + "    }/n";
   pageInfo = pageInfo + "    else/n";
   pageInfo = pageInfo + "    {/n";
   pageInfo = pageInfo + "        objPageSize = document.all.pageSize/n";
   pageInfo = pageInfo + "        objPageNo = document.all.pageNo/n";
   pageInfo = pageInfo + "    }/n";
   pageInfo = pageInfo + "    if(objPageSize.value.match(///d+/) != objPageSize.value)/n";
   pageInfo = pageInfo + "    {/n";
   pageInfo = pageInfo + "        alert('请输入正整数数字！');/n";
   pageInfo = pageInfo + "        objPageSize.select();/n";
   pageInfo = pageInfo + "        objPageSize.focus();/n";
   pageInfo = pageInfo + "        return;/n";
   pageInfo = pageInfo + "    }/n";
   pageInfo = pageInfo + "    if(objPageNo.value.match(///d+/) != objPageNo.value)/n";
   pageInfo = pageInfo + "    {/n";
   pageInfo = pageInfo + "        alert('请输入正整数数字页码！');/n";
   pageInfo = pageInfo + "        objPageNo.select();/n";
   pageInfo = pageInfo + "        objPageNo.focus();/n";
   pageInfo = pageInfo + "        return;/n";
   pageInfo = pageInfo + "    }/n";
   pageInfo = pageInfo + "    if(objPageNo != null &&  document.all.intPageCount != null && (new Number(objPageNo.value)).valueOf() > (new Number(document.all.intPageCount.value)).valueOf())/n";
   pageInfo = pageInfo + "    {/n";
   pageInfo = pageInfo + "        alert('您输入的页码大于最大页码！//n请重新输入页码！');/n";
   pageInfo = pageInfo + "        objPageNo.select();/n";
   pageInfo = pageInfo + "        objPageNo.focus();/n";
   pageInfo = pageInfo + "        return;/n";
   pageInfo = pageInfo + "    }/n";
   pageInfo = pageInfo + "    objGoButton.disabled=true;/n";
   pageInfo = pageInfo + "    /n";
   pageInfo = pageInfo + "    window.location.href=/"" + pageLink +
        "&pageNo=/" + objPageNo.value + /"&pageSize=/" + objPageSize.value;/n";
   pageInfo = pageInfo + "}/n";
   pageInfo = pageInfo + "</script>/n";
   pageInfo = pageInfo +
        "&nbsp;&nbsp;每页显示<input type='text' size='2' name='pageSize' value='" +
        intPageSize + "' class='Input'>条/n";
   if (intCurrentPageNo < intPageCount)
   {
    pageInfo = pageInfo +
         "&nbsp;转到第<input type='text' size='2' name='pageNo' value='" +
         String.valueOf(intCurrentPageNo + 1) + "' class='Input'>页/n";
   }
   else
   {
    pageInfo = pageInfo +
         "&nbsp;转到第<input type='text' size='2' name='pageNo' value='" +
         intCurrentPageNo + "' class='Input'>页/n";
   }
   pageInfo = pageInfo + "<input type=/"button/" class=/"ButtonSmall/" name=/"buttonGotoPage/" value=/"Go/" οnclick=/"gotoPage(this);/" title=/"点击跳转到指定的页面/">/n";
   pageInfo = pageInfo + "<input type=/"hidden/" name=/"intPageCount/" value=/"" +
        intPageCount + "/">/n";
  }
  else
   pageInfo = "数据总数：0";

  return pageInfo;
    }

    /**
     * 用于执行SELECT数据操作，并将查询结果存储至当前BaseTable对象中，并关闭记录集。
     * @param selectSql String  选取数据的SQL语句
     * @return BaseTable 返回根据SQL语句选取的数据结果集封装成的ArrayList
     */
    public BaseTable selectData(String selectSql)
    {
        ResultSet rs = null;
        DBProxy dbProxy = DBProxy.getInstance();
        try
        {
            rs = dbProxy.query(selectSql);
            metaData =rs.getMetaData();
            pushToMap(rs, 0); //将所有记录存储
            goFirst();
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.selectData(String selectSql):" + selectSql,true);
            Debug.printException(e,"BaseTable.selectData(String selectSql)");
        }
        finally
        {
            dbProxy.release();
        }
        return this;
    }

    /**
     * 用PreparedStatement执行SELECT数据操作，并将查询结果存储至当前BaseTable对象中，并关闭记录集。
     * @param selectSql String  选取数据的带有占位符的SQL语句
     * @param columnValues 对应SQL语句中的占位符的替换值
     * @return  返回根据SQL语句选取的数据结果集封装成的ArrayList
     */
    public BaseTable selectData(String selectSql, Object[] columnValues)
    {
        ResultSet rs = null;
        DBProxy dbProxy = DBProxy.getInstance();

        try
        {
            rs = dbProxy.query(selectSql,columnValues);
            metaData =rs.getMetaData();
           
            pushToMap(rs, 0); //将所有记录存储
            goFirst();
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.selectData(String selectSql, Object[] columnValues):" + selectSql,true);
            Debug.printException(e,"BaseTable.selectData(String selectSql, Object[] columnValues)");
        }
        finally
        {
            dbProxy.release();
        }

        return this;
    }

 /**
     * 用于根据参数中的SQL语句，执行数据INSERT/UPDATE/DELETE操作。
     * @param changeSql String 执行数据操作的SQL语句
     * @return int 数据影响的行数
     */
    public int changeData(String changeSql)
    {
        DBProxy dbProxy = DBProxy.getInstance();
        int changeCount = 0;

        try
        {
            changeCount = dbProxy.update(changeSql);
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.changeData(String changeSql):" + changeSql,true);
            Debug.printException(e,"BaseTable.changeData(String changeSql)");
        }
        finally
        {
            dbProxy.release();
        }

        return changeCount;
    }

 /**
     * 用于执行数据的INSERT/UPDATE/DELETE操作。<br>
  * 使用PreparedStatement更新数据库。
  * @param changeSql String 带占位符的SQL语句
  * @param columnValues 传递给SQL语中用于替换占位符的数组
  * @return int 数据影响的行数
  */
 public int changeData(String changeSql, Object[] columnValues)
 {
  int changeCount = 0;
        DBProxy dbProxy = DBProxy.getInstance();

  try
  {
   changeCount = dbProxy.update(changeSql,columnValues);
  }
  catch (Exception e)
  {
            Debug.print("BaseTable.changeData(String changeSql, Object[] columnValues):" + changeSql,true);
   Debug.printException(e,"BaseTable.changeData(String changeSql, Object[] columnValues)");
  }
        finally
        {
            dbProxy.release();
        }

  return changeCount;
 }

 /**
     * 用于根据参数中的SQL语句，执行数据INSERT/UPDATE/DELETE操作。
     * @param changeSql String 执行数据操作的SQL语句
     * @return int 数据影响的行数
     */
    public int changeDataWithTrans(String changeSql)
    {
        int changeCount = 0;

        try
        {
            changeCount = dbProxyWithTrans.updateWithTrans(changeSql);
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.changeDataWithTrans(String changeSql):" + changeSql,true);
            Debug.printException(e,"BaseTable.changeDataWithTrans(String changeSql)");
        }

        return changeCount;
    }

    /**
     * 在同一事务中执行数据的INSERT/UPDATE/DELETE操作。
     * @param listSql List 不同的数据更新操作SQL语句组成的List对象
     * @return boolean 同一事务中的操作是否执行成功
     */
    public boolean changeDataWithTrans(List listSql)
    {
        boolean bResult = false;
       
        try
        {
            dbProxyWithTrans.updateWithTrans(listSql);
            bResult = true;
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.changeDataWithTrans(List listSql):" + listSql,true);
            Debug.printException(e,"BaseTable.changeDataWithTrans(List listSql)");
        }

        return bResult;
    }

    /**
     * 用于执行数据的INSERT/UPDATE/DELETE操作。<br>
     * 使用PreparedStatement更新数据库。
     * @param changeSql String 带占位符的SQL语句
     * @param columnValues 传递给SQL语中用于替换占位符的数组
     * @return int 数据影响的行数
     */
    public int changeDataWithTrans(String changeSql, Object[] columnValues)
    {
        int changeCount = 0;
        try
        {
            changeCount = dbProxyWithTrans.updateWithTrans(changeSql,columnValues);
        }
        catch (Exception e)
        {
            Debug.print("BaseTable.changeData(String changeSql, Object[] columnValues):" + changeSql,true);
            Debug.printException(e,"BaseTable.changeData(String changeSql, Object[] columnValues)");
        }

        return changeCount;
    }

 /**
  * 用于实现将记录集中的数据存储至HashMap对象中。
  * @param rs ResultSet 待存储的记录集对象
  * @param intRowCount int 要存储的记录行数，0表示所有行
  */
 private void pushToMap(ResultSet rs, int intRowCount)
 {
  try
  {
   clear();
   ResultSetMetaData rsmd = rs.getMetaData();
   int numCols = rsmd.getColumnCount();
   if (intRowCount == 0) //表示存储整个结果集
   {
    while (rs.next())
    {
     HashMap rowMap = new HashMap();
     for (int i = 1; i <= numCols; i++)
     {
      rowMap.put(rsmd.getColumnLabel(i).toUpperCase(), rs.getString(rsmd.getColumnLabel(i)));
     }
     add(rowMap);
     
     eof = false;
    }
   }
   else //表示存储指定条数的结果集中的数据
   {
    if (rs.getRow() > 0)
    {
     int iCurrRows = 1;
     do
     {
      HashMap rowMap = new HashMap();
      for (int i = 1; i <= numCols; i++)
      {
       rowMap.put(rsmd.getColumnLabel(i).toUpperCase(), rs.getString(rsmd.getColumnLabel(i)));
      }
      add(rowMap);
      iCurrRows++;
     }
     while (iCurrRows <= intRowCount && rs.next());
     
     eof = false;
    }

   }
  }
  catch (Exception e)
  {
   Debug.printException(e,"BaseTable.pushToMap(ResultSet rs, int intRowCount)");
  }
 }

 /**
  * 用于返回当前记录行中指定字段名的数据值。
  * @param columnName String 要返回的字段列名
  * @return String
  */
 public String getString(String columnName)
 {
  String value = null;
  if ( (currPosition >= 0) && (currPosition < size()))
            value = (String) ( (HashMap) get(currPosition)).get(columnName.toUpperCase());

  if (value == null)
   value = "";

  return value;
 }

 /**
  * 用于返回当前记录行中指定字段名的Integer。
  * @param columnName String 要返回的字段列名
  * @return Calendar
  */
 public Integer getInteger(String columnName)throws ParseException
 {
  String str=getString(columnName);
  
   return Integer.valueOf(str.trim());
  
  
  
 }
 
 /**
  * 用于返回当前记录行中指定字段名的Boolean，如果原先存的int
  * @param columnName String 要返回的字段列名
  * @return Calendar
  */
 public Boolean getBoolean(String columnName)throws ParseException
 {
  String str=getString(columnName).trim();
  if(str.equals("0"))
   return false;
  else if(str.equals("1"))
   return true;
  else
   throw new ParseException("it is not a boolean :='"+str+"'",3);
  
  
  
 }
 /**
  * 用于返回当前记录行中指定字段名的long。
  * @param columnName String 要返回的字段列名
  * @return Calendar
  */
 public Long getLong(String columnName)throws ParseException
 {
  String str=getString(columnName).trim();
  
   return Long.valueOf(str);
  
  
  
 }
 /**
  * 用于返回当前记录行中指定字段名的calendar。
  * @param columnName String 要返回的字段列名
  * @return Calendar
  */
 public Calendar getCalendar(String columnName)throws ParseException
 {
  String str=getString(columnName);
  Calendar c=Calendar.getInstance();
  Date d=getDf().parse(str);
  c.setTime(d);
  return c;
 }
 
 /**
  * 用于将当前数据记录集定位至第一行。
  */
 public void goFirst()
 {
  if (size() > 0)
  {
            //将当前结果集指针定位于第一条数据之前，以用于next方法的定位取数据
   currPosition = -1;
   eof = false;
  }
  else
  {
   eof = true;
  }

  bof = true;
 }

 /**
  * 用于将当前数据记录集定位至当前行的前一行。
  */
 public void previous()
 {
  if (size() > 0)
  {
   if (bof == false)
   {
    currPosition = currPosition - 1;
    if (currPosition == -1)
     bof = true;
    else
     bof = false;
   }

   eof = false;
  }
 }

    /**
     * 用于将当前数据记录集定位至当前行的下一行。
     * @return 如果当前记录集已浏览完毕，则返回false，否则返回true。
     */
 public boolean next()
 {
  if (size() > 0)
  {
   if (currPosition < size() - 1)
   {
    currPosition = currPosition + 1;
    eof = false;
   }
   else
   {
    eof = true;
   }

   bof = false;
  }

        return (!eof);
 }

 /**
  * 用于将当前数据记录集定位至最后一行。
  */
 public void goLast()
 {
  if (size() > 0)
  {
   currPosition = size() - 1;
   bof = false;
   eof = true;
  }
 }

 /**
  * 返回boolean,用于判断当前记录集指针是否已经在开始的位置。
  * @return boolean
  */
 public boolean isBof()
 {
  return bof;
 }

 /**
  * 返回boolean,用于判断当前记录集指针是否已经在最后的位置。
  * @return boolean
  */
 public boolean isEof()
 {
  return eof;
 }

    /**
     * 设置事务执行的开始点。
     * @return 操作成功与否
     */
    public boolean doSetSavepoint()
    {
        dbProxyWithTrans = DBProxy.getInstance();
        return dbProxyWithTrans.doSetSavepoint();
    }

    /**
     * 执行事务提交操作。如果提交失败则自动执行回滚操作。
     * @return 操作成功与否
     */
    public boolean doCommit()
    {
     boolean bResult = dbProxyWithTrans.doCommit();
     dbProxyWithTrans.release();
     
        return bResult;
    }

    /**
     * 执行事务回滚操作。
     * @return 操作成功与否
     */
    public boolean doRollback()
    {
     boolean bResult = dbProxyWithTrans.doRollback();
     dbProxyWithTrans.release();
     
        return bResult;
    }

}

 

 

 

一些使用例子

 

 

import javax.servlet.http.HttpServletRequest;

public class BaseTableUseExample
{
 /**
  * 根据用户名称获取数据样例
  * @param username
  * @return
  */
 public BaseTable selectById(String username)
 {
  BaseTable bTable = new BaseTable();
  String strSQL = "SELECT * FROM Sys_User WHERE User_Name = ? ";
     Object[] columnValues = {username};

  bTable = bTable.selectData(strSQL, columnValues);
  return bTable;
 }

 /**
 * 选取所有的用户数据，并返回BaseTable对象，以用于处理。结合显示的JSP页面，实现翻页功能。
 * @return BaseTable
 */
   public BaseTable selectAll(HttpServletRequest request)
   {

    BaseTable bTable = new BaseTable();
    String strSQL = "SELECT Chapter_Topic,Page_No FROM Mark_Chapter where KeyId > 0";
    bTable = bTable.selectData(strSQL,request);

    return bTable;
   }

 /**
 * 选取所有的用户数据，并返回BaseTable对象，以用于处理。结合显示的JSP页面，实现翻页功能。
 * @return BaseTable
 */
   public BaseTable selectAllByState(String state, HttpServletRequest request)
   {

    BaseTable bTable = new BaseTable();
    String strSQL = "SELECT * FROM Sys_User where State  = ? ";
  Object[] columnValues = {state};
  bTable = bTable.selectData(strSQL,columnValues,request);

    return bTable;
   }

 /**
  * 根据用户名称和密码查看该用户的信息
  * @param word1
  * @param word2
  * @return
  */
 public BaseTable selectByTwo(String word1,String word2)
 {
  BaseTable bTable = new BaseTable();
  String strSQL = "SELECT Chapter_Topic,Page_No FROM Mark_Chapter";

     Object[] columnValues = {word1, word2};
  bTable = bTable.selectData(strSQL,columnValues);

  return bTable;
 }
   /**
  * 获取数据
  * @param sqlWord1 String
  * @param word1 String
  * @return BaseTable
  */
 public BaseTable selectByOne(String sqlWord1,String word1)
 {
  BaseTable bTable = new BaseTable();
     String strSQL = "SELECT * FROM Sys_User WHERE " + sqlWord1 + " =  ? ";
     Object[] columnValues = {word1};
     bTable = bTable.selectData(strSQL,columnValues);

  return bTable;
 }

    /**
     * 根据拼凑成的SQL语句strUpdate更新数据表
     * @param strUpdate String
     * @return int
     */
    public int update(String strUpdate)
    {
        BaseTable bTable = new BaseTable();
        //将SQL语句strUpdate做为参数传递给BaseTable对象的实例bTable，并执行其changeData方法以完成指定的操作，
        //并相应返回数据操作（包括插入、更新、删除）的行数，如果返回行数为0，则对数据表的操作没有执行成功。
        return bTable.changeData(strUpdate);
    }

    /**
     * 使用PrepareStatement更新数据，采用预编译SQL语句，提高运行速度并且使数据操作更安全。
     * @param id String
     * @param username String
     * @param nickname String
     * @return int
     */
    public int update(String id, String username, String nickname)
    {
        BaseTable bTable = new BaseTable();
        String strSql = "UPDATE WCMUSER SET USERNAME =? ,nickname =? WHERE USERID = ? ";
        Object[] columnValues = {username, nickname, id};

        return bTable.changeData(strSql,columnValues);
    }

    /**
     * 根据插入语句插入数据
     * @param strInsert String
     * @return int
     */
    public int insert(String strInsert)
    {
        BaseTable bTable = new BaseTable();

        return bTable.changeData(strInsert);
    }

    /**
     * 使用PrepareStatement插入数据，采用预编译SQL语句，提高运行速度并且使数据操作更安全。
     * @param id String
     * @param username String
     * @param nickname String
     * @return int
     */
    public int insert(String id, String username, String nickname)
    {
        BaseTable bTable = new BaseTable();
        String strSql = "INSERT INTO WCMUSER (USERID,USERNAME,nickname) VALUES(? ,? ,? )";
        Object[] columnValues = {id, username, nickname};

        return bTable.changeData(strSql,columnValues);
    }

    /**
     * 根据编号删除数据
     * @param id String
     * @return int
     */
    public int deleteById(String id)
    {
        BaseTable bTable = new BaseTable();
        String strSQL = "DELETE FROM WCMUSER WHERE ID = " + id;

        return bTable.changeData(strSQL);
    }

    /**
     * 根据编号更新数据，用于从两个表更新数据，将更新语句放于事务处理中
     * @param id String
     * @return boolean true表示事务执行成功；false表示事务执行失败
     */
    public boolean updateByIdInTransction(String id)
    {
     boolean bResult = false;
     
        BaseTable bTable = new BaseTable();
        bTable.doSetSavepoint();
        String strSQL = "update Product set Product_title = '测试Title工a' WHERE Product_Id = " + id;
        int iResult2 = bTable.changeDataWithTrans(strSQL);
        strSQL = "update Product set Old_Name = '测试Old_Namev人a' WHERE Product_Id = " + id;
        int iResult3 = bTable.changeDataWithTrans(strSQL);
        strSQL = "update Product set Product_Path = '测试Product_Pathv一a' WHERE Product_Id = ? ";
        Object[] columValues = {id };
        int iResult1 = bTable.changeDataWithTrans(strSQL,columValues);
       
        bResult = iResult1 > 0 && iResult2 > 0 && iResult3 > 0;
       
        if (bResult)
         bTable.doCommit();
        else
         bTable.doRollback();
     
        return bResult;
    }
   
    public static void main(String[] args)
    {
     BaseTable bt=new BaseTable();
     bt.selectData("select * from sysobjects");
     while(bt.next())
     {
      System.out.println(bt.getString("name"));
     }
    }
}