目前使用的JAVA数据库链接管理类

好吧，直入主题。
首先需要设置好数据库连接池，参见Javaworld@TW出的 wiki
由于我们的服务器上仅有一个应用，使用的是在web.xml中添加一个随容器启动的servlet来实现加载连接池的方法，该servlet通过读取 WEB-INF/config/proxool.xml完成proxool的初始化。如下：

< servlet-name > ServletConfigurator </ servlet-name >
   < servlet-class > org.logicalcobwebs.proxool.configuration.ServletConfigurator </ servlet-class >
   < init-param >
     < param-name > xmlFile </ param-name >
     < param-value > WEB-INF/config/proxool.xml </ param-value >
   </ init-param >
   < load-on-startup > 1 </ load-on-startup >
</ servlet >

proxool.xml文件， 注意   <alias>ems</alias>这项，将是DriverManager.getConnection()的参数
用户名和密码也需注意，下面的参数尚未经过严格测试，可能存在性能瓶颈，欢迎请

<? xml version="1.0" encoding="UTF-8" ?>
<!--  the proxool configuration can be embedded within your own application's.
    Anything outside the "proxool" tag is ignored. -->
< proxool-config >
     < proxool >
         < alias > ems </ alias >
         < driver-url >
            jdbc:jtds:sqlserver://localhost:1433/ems
         </ driver-url >
         < driver-class > net.sourceforge.jtds.jdbc.Driver </ driver-class >
         < driver-properties >
             < property  name ="user"  value ="user"   />
             < property  name ="password"  value ="user"   />
         </ driver-properties >
         <!-- 最少保持的空闲连接数 -->
         < prototype-count > 5 </ prototype-count >
         <!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中 -->
         < maximum-connection-count > 100 </ maximum-connection-count >
         <!-- 最小连接数 -->
         < minimum-connection-count > 10 </ minimum-connection-count >
         <!-- 最大的等待请求数,即因没有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受 -->
         < proxool .simultaneous-build-throttle >
            200
         </ proxool.simultaneous-build-throttle >
         <!-- Test SQL -->
         < house-keeping-test-sql >
            SELECT getDate()
         </ house-keeping-test-sql >
         <!-- 自动侦察各个连接状态的时间间隔(毫秒),侦察到空闲的连接就马上回收,超时的销毁 -->
         < house-keeping-sleep-time > 90000 </ house-keeping-sleep-time >
     </ proxool >

至此，准备工作已经完成，接下来就是DatabaseManagerjava
每个方法均有注释， 需要commons.logging包，用于输出log

package  com.util;

import  java.sql.Connection;
import  java.sql.DriverManager;
import  java.sql.ResultSet;
import  java.sql.SQLException;
import  java.sql.Statement;

import  org.apache.commons.logging.Log;
import  org.apache.commons.logging.LogFactory;

/**
 * 数据库管理器:与数据库建立连接、断开连接、执行查询和更新操作
 * 
 *  @author Kryptonum
 *  @version  1.2
 * 
  */
public   class  DatabaseManager {

     private   static   final  Log logger  =  LogFactory.getLog(DatabaseManager. class );

     public  DatabaseManager() {
    }

     /**
     * 获得一个数据库连接
     * 
     *  @return  Connection对象
     * 
      */
     public  Connection getConnection() {

        Connection conn  =   null ;

         try  {
            Class.forName( " org.logicalcobwebs.proxool.ProxoolDriver " );
            conn  =  DriverManager.getConnection( " proxool.ems " );
        }  catch  (ClassNotFoundException e) {
             //  在classpath中未找到合适的驱动
            logger.error( " No suitable driver found " );
            logger.error(e.getMessage());
             return   null ;
        }  catch  (SQLException e) {
             //  获取连接失败
            logger
                    .error( " Get connection failed, check the proxool configuration file and web.xml " );
            logger.error(e.getMessage());
             return   null ;
        }

         if  (conn  !=   null ) {
             if  (logger.isDebugEnabled()) {
                logger.debug( " Connected " );
            }
        }

         return  conn; //  返回该Connection
    }

     /**
     * 传入执行查询的语句，返回结果集
     * 
     *  @param  conn
     *            Connection连接对象
     *  @param  sql
     *            String类型的sql语句
     *  @return  结果集 ResultSet
      */
     public  ResultSet executeQuery(Connection conn, String sql) {

        Statement stmt  =   null ; //  声明Statement stmt
        ResultSet rs  =   null ; //  声明ResultSet rs

         if  (conn  !=   null ) {
             //  Connection 不为null，执行查询

             //  若debug模式开启，则输出debug 信息
             if  (logger.isDebugEnabled()) {
                logger.debug(sql);
            }

             try  {
                stmt  =  conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
                        ResultSet.CONCUR_READ_ONLY); //  通过Connection创建一个Statemet
                rs  =  stmt.executeQuery(sql); //  执行查询语句，
            }  catch  (SQLException sqlex) {
                logger.error( " Execute query failed: [ "   +  sql  +   " ] " );
                logger.error(sqlex.getMessage());
                 return   null ;
            }
             return  rs;
        }  else  {
             //  Connection 为null，输出info信息，返回null
            logger.info( " Connection is null, execute sql query: [ "   +  sql
                     +   " ] failed " );
             return   null ;
        }
    }

     /**
     * 传入执行数据更新的语句，返回更新结果，成功执行为真
     * 
     *  @param  conn
     *            Connection连接对象
     *  @param  sql
     *            String类型的sql语句
     *  @return  执行结果，布尔型
      */
     public   boolean  executeUpdate(Connection conn, String sql) {

         boolean  status  =   false ; //  执行结果，默认为false

        Statement stmt  =   null ; //  声明Statement stmt

         if  (conn  !=   null ) {
             //  Connection 不为null，执行更新

             //  若debug模式开启，则输出debug 信息
             if  (logger.isDebugEnabled()) {
                logger.debug(sql);
            }

             try  {
                stmt  =  conn.createStatement(); //  通过Connection创建一个Statemet
                 int  count  =  stmt.executeUpdate(sql); //  执行更新数据操作，返回影响的行数

                 //  根据count值,判断执行的成功或失败
                 if  (count  >   0 )
                    status  =   true ;

            }  catch  (SQLException sqlex) {
                logger.error( " Execute update failed: [ "   +  sql  +   " ] " );
                logger.error(sqlex.getMessage());
            }
        }  else  {
             //  Connection 为null，输出info信息，返回false

            logger.info( " Connection is null, execute sql update: [ "   +  sql
                     +   " ] failed " );
        }
         return  status;

    }

     /**
     * 释放从连接池取得的连接
     * 
     *  @param  conn
     *            Connection连接对象
      */
     public   void  releaseConnection(Connection conn) {

         //  释放连接
         if  (conn  !=   null ) {
             try  {
                conn.close();
                 if  (logger.isDebugEnabled()) {
                    logger.debug( " Connection released " );
                }
            }  catch  (SQLException sqlex) {
                logger.error( " Release connection failed " );
            }  finally  {
                conn  =   null ;
            }
        }
    }
}

代码的应用，举两个例子
1、查询

package  ttm.bean;

import  java.sql.Connection;
import  java.sql.ResultSet;
import  java.sql.SQLException;
import  java.util.ArrayList;

import  com.util.DatabaseManager;

public   class  ScoreTypeDAO {

     private  DatabaseManager dm  =   null ;

     private  Connection conn  =   null ;

    /**
     * 构造函数，初始化DatabaseManager对象
     * 
     */
    public ScoreTypeDAO() {
        dm = new DatabaseManager();
    }

    /**
     * 获取所有成绩类型编号
     * 
     * @return 所有成绩类型编号
     */
    public ArrayList<String> getAllScoreTypeId() {

        ArrayList<String> sctpId = new ArrayList<String>();
        String sql = "select SCORE_TP_ID from TC_SCORE_TP;";

        try {
            // 建立连接
            conn = dm.getConnection();
            ResultSet rst = dm.executeQuery(conn, sql);

            while (rst.next()) {
                // new a string
                String str = new String();

                str = rst.getString(1);// 成绩类型名称

                sctpId.add(str);
            }
        } catch (SQLException sqlex) {
            sqlex.printStackTrace();
        } finally {
            dm.releaseConnection(conn);
        }

        return sctpId;
    }

}

2、删除

package  ttm.bean;

import  java.sql.Connection;
import  java.sql.ResultSet;
import  java.sql.SQLException;
import  java.util.ArrayList;

import  com.util.DatabaseManager;

public   class  CrswreDAO {

     private  DatabaseManager dm  =   null ;

     private  Connection conn  =   null ;

    public CrswreDAO() {
        dm = new DatabaseManager();
    }
 
    /**
     * 删除给定id的课件
     * 
     * @param crswreid
     */
    public void delCrswre(String crswreid) {

        String sql = "delete from TC_EDU_CRSWRE where ISN = '" + crswreid + "'";

        try {
            // 建立连接
            conn = dm.getConnection();

            dm.executeUpdate(conn, sql);

        } finally {
            dm.releaseConnection(conn);
        }
    }

总结：简化的目的基本打到了，但是离我的目标还是有很大的差距。首先try...catch...finally还是存在，代码依然很繁杂；其次就是异常没有被很好的进行管理。
    这是第一次自己做工具的类尝试，虽然不是非常成功，却还是让我有很大的收获。独力完成如spring中的jdbc助手类般的代码对我而言似乎还太远，不过理解spring中的方法已经没有太大问题，接下来合理运用spring提供的基础架构是我和Pheonix要钻研的。