如何实现数据库连接池

Question

import java.sql.Connection ;
import java.sql.SQLException;
import java.sql.DriverManager ;
import java.sql.Driver ;
import java.util.* ;
import java.io.*;public class DBConnectionManager {
  Hashtable  pools=new Hashtable();                                 //数据库连接池容器对象
  static DBConnectionManager instance;                              //本类的一个实例（静态对象）
  static int clients;                                               //客户数量（静态变量）
  Vector drivers=new Vector();                                      //数据库驱动程序容器对象
  PrintWriter log;                                                  //日志对象
  //String filename="file:///E:\\JBuilder3\\myprojects\\untitled10\\db.properties";
  //String filename="http://192.168.0.156:8880/oaSite/prjContext/db.properties";
  String filename="/db.properties";
                                                                    //数据库参数文件（提供默认属性文件）
  String driverMark="Tds";                                          //数据库驱动标识描述（提供默认标识）
/*
   方法名： DBConnectionManager
   参  数： （无）
   返回值： （无）
   备  注：该方法为类的构造方法
   功  能：初始化类（调用初始化方法）
*/
  private DBConnectionManager() {
    init();                                                         //调用初始化方法
  }/*
   方法名： DBConnectionManager
   参  数： 数据库连接参数文件名
   返回值： （无）
   备  注：该方法为类的构造方法
   功  能：初始化类（调用初始化方法）
*/
  private DBConnectionManager(String fname) {
    filename=fname;                                                 //初始化数据库参数文件
    init();                                                         //调用初始化方法
  }/*
   方法名：getConnection
   参  数：（无）
   返回值：数据库连接对象
   备  注：公用方法
   功  能：按照默认的数据库驱动程序标识取得数据库连接
*/
  public Connection getConnection() {
    System.out.println ("-------------start get connection---------------");
    DBConnectionPool pool = (DBConnectionPool) pools.get(driverMark);
    System.out.println ("------------- get a  connection pool---------------");
                                                                    //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    if (pool != null) {                                             //存在需要的数据库连接池对象
      return pool.getConnection();                                  //取得数据库连接，返回连接
    }
    return null;                                                    //未取得连接，返回空
  }/*
   方法名：getConnection
   参  数：数据库驱动程序标识
   返回值：数据库连接对象
   备  注：公用方法
   功  能：按照数据库驱动程序标识取得数据库连接
*/
  public Connection getConnection(String name) {
    DBConnectionPool pool = (DBConnectionPool) pools.get(name);     //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    if (pool != null) {                                             //存在需要的数据库连接池对象
      return pool.getConnection();                                  //取得数据库连接，返回连接
    }
    return null;                                                    //未取得连接，返回空
  }/*
   方法名：getConnection
   参  数：数据库驱动程序标识
           超时时间
   返回值：数据库连接对象
   备  注：公用方法
   功  能：按照数据库驱动程序标识和超时时间条件取得数据库连接
*/
  public Connection getConnection(String name, long time) {
    DBConnectionPool pool = (DBConnectionPool) pools.get(name);     //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    if (pool != null) {                                             //存在需要的数据库连接池对象
      return pool.getConnection(time);                              //取得超时时间条件内的数据库连接，返回连接
    }
    return null;                                                    //未取得连接，返回空
  }
}

Answer 1

//接上/*
   方法名：freeConnection
   参  数：数据库驱动程序标识
           数据库连接
   返回值：（空）
   备  注：公用方法
   功  能：按照数据库驱动程序标识释放一个数据库连接
*/
  public void freeConnection(String name, Connection con) {
    if (con==null) return;
    DBConnectionPool pool = (DBConnectionPool) pools.get(name);     //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    if (pool != null) {                                             //存在需要的数据库连接池对象
      pool.freeConnection(con);                                     //归还指定的数据库连接数据库连接
    }
  }/*
   方法名：freeConnection
   参  数：数据库连接
   返回值：（空）
   备  注：公用方法
   功  能：释放一个默认数据库驱动程序连接
*/
  public void freeConnection(Connection con) {
    System.out.println ("");
    System.out.println ("");
    System.out.println ("start free connection");
    if (con==null)  {
      System.out.println ("connection is null");
      return;
    }
    DBConnectionPool pool = (DBConnectionPool) pools.get(driverMark);
                                                                    //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    System.out.println ("get connection object");
    if (pool != null) {                                             //存在需要的数据库连接池对象
      pool.freeConnection(con);                                     //归还指定的数据库连接数据库连接
      System.out.println ("free connection success!!");
    }
  }/*
   方法名：getInstance
   参  数：（空）
   返回值：数据库连接池管理对象
   备  注：静态、同步方法
   功  能：取得数据库连接池管理对象的一个实例
*/
  static synchronized public DBConnectionManager getInstance() {
    System.out.println ("");
    System.out.println ("");    System.out.println ("~~~~~~~~~~start get dbcnPoolManager instance~~~~~~~~~~~~~~~~");    if (instance == null) {                                         //判断本类的静态实例对象是否有值
      instance = new DBConnectionManager();                         //没有：生成一个本类的实例
    }
    clients++;                                                      //在线连接数自增
    System.out.println ("get  DBConnectionManager Instance success!");
    System.out.println ("");
    return instance;                                                //返回本类的实例对象
  }/*
   方法名：getInstance
   参  数：数据库属性文件名
   返回值：数据库连接池管理对象
   备  注：静态、同步方法
   功  能：按照指定的数据库属性文件取得数据库连接池管理对象的一个实例
*/
  static synchronized public DBConnectionManager getInstance(String fname) {
    if (instance == null) {                                         //判断本类的静态实例对象是否有值
      instance = new DBConnectionManager(fname);                    //没有：按照参数文件生成一个本类的实例
    }
    clients++;                                                      //在线连接数自增
    System.out.println ("get DBConnectionManager Instance!");
    return instance;                                                //返回本类的实例对象
  }/*
   方法名：init
   参  数：（无）
   返回值：（无）
   备  注：私有方法
   功  能：初始化类
*/
  private void init() {
     InputStream is = getClass().getResourceAsStream(filename);     //按照属性文件名实例化输入流对象
     System.out.println ("get fileInputStream:"+filename);
    /*
     InputStream is=null;
     try{
          java.net.URL url = new java.net.URL(filename);
          is = url.openStream();     }catch (Exception urlerr) {
       urlerr.printStackTrace ();
     }
    */
    Properties dbProps = new Properties();                          //生成一个属性对象
    try {
      dbProps.load(is);                                             //属性对象加载输入流
    }
    catch (Exception e) {                                           //异常
      e.printStackTrace ();
      System.err.println("Can't read the properties file. " +
      "Make sure db.properties is in the CLASSPATH");
      return;
    }
    String logFile = dbProps.getProperty("logfile","DBConnectionManager.log");
                                                                    //取得数据库连接操作的日志文件
    try {
      log = new PrintWriter(new FileWriter(logFile, true), true);   //实例化写文件对象
    }
    catch (IOException e) {                                         //异常
      System.err.println("Can't open the log file: " + logFile);
      log = new PrintWriter(System.err);                            //实例化为系统默认的错误输出对象
    }    loadDrivers(dbProps);                                           //加载数据库驱动程序（参数：属性对象）
    System.out.println ("load database driver success!");
    createPools(dbProps);                                           //建立数据库连接池（参数：属性对象）
    System.out.println ("creat database connection pool success!");
  }
/*
   方法名：loadDrivers
   参  数：属性对象
   返回值：（无）
   备  注：私有方法
   功  能：按照指定参数加载数据库驱动程序
*/
  private void loadDrivers(Properties props) {
    String driverClasses = props.getProperty("drivers");            //取得数据库驱动程序标识串
    StringTokenizer st = new StringTokenizer(driverClasses);        //用数据库驱动程序标识串实例化标志间隔串
    while (st.hasMoreElements()) {                                  //循环：是否还有子串
      String driverClassName = st.nextToken().trim();               //取得一个子串，得到一个数据库驱动程序标识串
      try {
        Driver driver = (Driver)
        Class.forName(driverClassName).newInstance();               //按照数据库驱动程序标识串取得数据库驱动程序对象
        DriverManager.registerDriver(driver);                       //驱动程序管理器注册驱动程序对象
        drivers.addElement(driver);                                 //驱动程序容器对象添加驱动程序对象        log.println ("Registered JDBC driver " + driverClassName);  //打印消息
        //log("Registered JDBC driver " + driverClassName);
      }
      catch (Exception e) {                                         //异常
        log.println ("Can't register JDBC driver: " +driverClassName + ", Exception: " + e);
        //log("Can't register JDBC driver: " +driverClassName + ", Exception: " + e);
      }
    }
  }/*
   方法名：createPools
   参  数：属性对象
   返回值：（无）
   备  注：私有方法
   功  能：按照指定参数创建连接池
*/
  private void createPools(Properties props) {
    Enumeration propNames = props.propertyNames();                  //枚举数据库属性到枚举对象
    while (propNames.hasMoreElements()) {                           //循环：还有属性
      String name = (String) propNames.nextElement();               //取得属性串
      if (name.endsWith(".url")) {                                  //是URL串
        String poolName = name.substring(0, name.lastIndexOf(".")); //截取有效子串
        String url = props.getProperty(poolName + ".url");          //形成有效子串
        if (url == null) {                                          //子串为空
           log.println ("No URL specified for " + poolName);        //打印消息
           //log("No URL specified for " + poolName);
          continue;
        }
        String user = props.getProperty(poolName + ".user");        //取得用户属性
        String password = props.getProperty(poolName + ".password");//取得用户密码属性
        String maxconn = props.getProperty(poolName + ".maxconn", "0");
                                                                    //取得最大连接数属性
        int max;
        try {
          max = Integer.valueOf(maxconn).intValue();                //转化有数值型的最大连接数
        }
        catch (NumberFormatException e) {                           //

Answer 2

//接上
/*
   方法名：freeConnection
   参  数：数据库驱动程序标识
           数据库连接
   返回值：（空）
   备  注：公用方法
   功  能：按照数据库驱动程序标识释放一个数据库连接
*/
  public void freeConnection(String name, Connection con) {
    if (con==null) return;
    DBConnectionPool pool = (DBConnectionPool) pools.get(name);     //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    if (pool != null) {                                             //存在需要的数据库连接池对象
      pool.freeConnection(con);                                     //归还指定的数据库连接数据库连接
    }
  }/*
   方法名：freeConnection
   参  数：数据库连接
   返回值：（空）
   备  注：公用方法
   功  能：释放一个默认数据库驱动程序连接
*/
  public void freeConnection(Connection con) {
    System.out.println ("");
    System.out.println ("");
    System.out.println ("start free connection");
    if (con==null)  {
      System.out.println ("connection is null");
      return;
    }
    DBConnectionPool pool = (DBConnectionPool) pools.get(driverMark);
                                                                    //从容器中按照数据库驱动程序标识
                                                                    //取得数据库连接池对象
    System.out.println ("get connection object");
    if (pool != null) {                                             //存在需要的数据库连接池对象
      pool.freeConnection(con);                                     //归还指定的数据库连接数据库连接
      System.out.println ("free connection success!!");
    }
  }/*
   方法名：getInstance
   参  数：（空）
   返回值：数据库连接池管理对象
   备  注：静态、同步方法
   功  能：取得数据库连接池管理对象的一个实例
*/
  static synchronized public DBConnectionManager getInstance() {
    System.out.println ("");
    System.out.println ("");    System.out.println ("~~~~~~~~~~start get dbcnPoolManager instance~~~~~~~~~~~~~~~~");    if (instance == null) {                                         //判断本类的静态实例对象是否有值
      instance = new DBConnectionManager();                         //没有：生成一个本类的实例
    }
    clients++;                                                      //在线连接数自增
    System.out.println ("get  DBConnectionManager Instance success!");
    System.out.println ("");
    return instance;                                                //返回本类的实例对象
  }/*
   方法名：getInstance
   参  数：数据库属性文件名
   返回值：数据库连接池管理对象
   备  注：静态、同步方法
   功  能：按照指定的数据库属性文件取得数据库连接池管理对象的一个实例
*/
  static synchronized public DBConnectionManager getInstance(String fname) {
    if (instance == null) {                                         //判断本类的静态实例对象是否有值
      instance = new DBConnectionManager(fname);                    //没有：按照参数文件生成一个本类的实例
    }
    clients++;                                                      //在线连接数自增
    System.out.println ("get DBConnectionManager Instance!");
    return instance;                                                //返回本类的实例对象
  }

Answer 3

楼上这为老兄汉化的不错。我就用这位老兄的池子吧：    dbm=DBConnectionManager.getInstance();
    conn=dbm.getConnection("connection name");
    try {
          conn.setAutoCommit(true);
          stmt=conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
          ////
          ////  知道这里做什么吧！！！
         /////      }
      catch(Exception e) {
        System.err.println("error: " + e.getMessage());
      }
    }

Answer 4

下面我们以一个名为ConnectionPool的连接池为例来看看连接池的实现。先看看ConnectionPool的基本属性：
　　m_ConnectionPoolSize：连接池中连接数量下限
　　m_ConnectionPoolMax：连接池中连接数量上限 
　　m_ConnectionUseCount：一个连接的最大使用次数
　　m_ConnectionTimeout：一个连接的最长空闲时间
　　m_MaxConnections = -1：同一时间的最大连接数
　　m_timer：定时器 
　　这些属性定义了连接池与其中的每个连接的有效状态值。连接池的自我管理，实际上就是通过定时的对每个连接的状态、连接的数量进行判断而进行相应操作。
我们可以定义出ConnectionPool要完成管理所需要的基本接口： 
public class ConnectionPool implements TimerListener{
　　public boolean initialize() //连接池初始化 
　　public void destroy() //连接池的销毁 
　　public synchronized java.sql.Connection getConnection() //取一个连接 
　　public synchronized void close() //关闭一个连接 
　　private synchronized void removeFromPool() //把一个连接从连接池中删除 
　　private synchronized void fillPool() //维护连接池大小 
　　public synchronized void TimerEvent() //定时器事件处理函数 
} 
　　通过这几个接口，已经可以完成连接池的基本管理。在TimeEvent（）函数中完成连接池的状态检验工作，fillPool()时连接池至少保持最小连接数。因为我们要保存每一个连接的状态，所以还需要一个数据库连接对象： 
class ConnectionObject{
　　public java.sql.Connection con; public boolean inUse; //是否被使用标志 
　　public long lastAccess; //最近一次开始使用时间 
　　public int useCount; //被使用次数
}
加入了ConnectionObject对象后，在ConnectionPool中操作的应该只是ConnectionObject,而其他进程需要的只是ConnectionObject的con属性，因此我们再加入一个类，作为其他进程获得与返回连接的接口： CLASS Conn{
　　GetConnection(); //从连接池中取出一个有效连接 
　　CloseConnection(); //返回连接，此时并没有关闭连接，只是放回了连接池 
　　DestroyPool(); //销毁连接池 
}

Answer 5

其实用DataSource替代DriverManager就可以实现连接池了。

Answer 6

give you a database connection pool：import java.io.*; 
import java.sql.*; 
import java.util.*; 
import java.util.Date; /** 
* 管理类DBConnectionManager支持对一个或多个由属性文件定义的数据库连接 
* 池的访问.客户程序可以调用getInstance()方法访问本类的唯一实例. 
*/ 
public class DBConnectionManager 
{ 
static private DBConnectionManager instance; // 唯一实例 
static private int clients; private Vector drivers = new Vector(); 
private PrintWriter log; 
private Hashtable pools = new Hashtable(); /** 
* 返回唯一实例.如果是第一次调用此方法,则创建实例 
* 
* @return DBConnectionManager 唯一实例 
*/ 
static synchronized public DBConnectionManager getInstance() 
{ 
if (instance == null) 
{ 
instance = new DBConnectionManager(); 
} 
clients++; 
return instance; 
} /** 
* 建构函数私有以防止其它对象创建本类实例 
*/ 
private DBConnectionManager() 
{ 
init(); 
} /** 
* 将连接对象返回给由名字指定的连接池 
* 
* @param name 在属性文件中定义的连接池名字 
* @param con 连接对象 
*/ 
public void freeConnection(String name, Connection con) 
{ 
DBConnectionPool pool = (DBConnectionPool) pools.get(name); 
if (pool != null) 
{ 
pool.freeConnection(con); 
} 
} /** 
* 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数 
* 限制,则创建并返回新连接 
* 
* @param name 在属性文件中定义的连接池名字 
* @return Connection 可用连接或null 
*/ 
public Connection getConnection(String name) 
{ 
DBConnectionPool pool = (DBConnectionPool) pools.get(name); 
if (pool != null) 
{ 
return pool.getConnection(); 
} 
return null; 
} /** 
* 获得一个可用连接.若没有可用连接,且已有连接数小于最大连接数限制, 
* 则创建并返回新连接.否则,在指定的时间内等待其它线程释放连接. 
* 
* @param name 连接池名字 
* @param time 以毫秒计的等待时间 
* @return Connection 可用连接或null 
*/ 
public Connection getConnection(String name, long time) 
{ 
DBConnectionPool pool = (DBConnectionPool) pools.get(name); 
if (pool != null) 
{ 
return pool.getConnection(time); 
} 
return null; 
} /** 
* 关闭所有连接,撤销驱动程序的注册 
*/ 
public synchronized void release() 
{ 
// 等待直到最后一个客户程序调用 
if (--clients != 0) 
{ 
return; 
} Enumeration allPools = pools.elements(); 
while (allPools.hasMoreElements()) 
{ 
DBConnectionPool pool = (DBConnectionPool) allPools.nextElement(); 
pool.release(); 
} 
Enumeration allDrivers = drivers.elements(); 
while (allDrivers.hasMoreElements()) 
{ 
Driver driver = (Driver) allDrivers.nextElement(); 
try 
{ 
DriverManager.deregisterDriver(driver); 
log("撤销JDBC驱动程序 " + driver.getClass().getName()+"的注册"); 
} 
catch (SQLException e) 
{ 
log(e, "无法撤销下列JDBC驱动程序的注册: " + driver.getClass().getName()); 
} 
} 
} /** 
* 根据指定属性创建连接池实例. 
* 
* @param props 连接池属性 
*/ 
private void createPools(Properties props) 
{ 
Enumeration propNames = props.propertyNames(); 
while (propNames.hasMoreElements()) 
{ 
String name = (String) propNames.nextElement(); 
if (name.endsWith(".url")) 
{ 
String poolName = name.substring(0, name.lastIndexOf(".")); 
String url = props.getProperty(poolName + ".url"); 
if (url == null) 
{ 
log("没有为连接池" + poolName + "指定URL"); 
continue; 
} 
String user = props.getProperty(poolName + ".user"); 
String password = props.getProperty(poolName + ".password"); 
String maxconn = props.getProperty(poolName + ".maxconn", "0"); 
int max; 
try 
{ 
max = Integer.valueOf(maxconn).intValue(); 
} 
catch (NumberFormatException e) 
{ 
log("错误的最大连接数限制: " + maxconn + " .连接池: " + poolName); 
max = 0; 
} 
DBConnectionPool pool = new DBConnectionPool(poolName, url, user, password, max); 
pools.put(poolName, pool); 
log("成功创建连接池" + poolName); 
} 
} 
} /** 
* 读取属性完成初始化 
*/ 
private void init() 
{ 
InputStream is = getClass().getResourceAsStream("/db.properties"); 
Properties dbProps = new Properties(); 
try 
{ 
dbProps.load(is); 
} 
catch (Exception e) 
{ 
System.err.println("不能读取属性文件. " +"请确保db.properties在CLASSPATH指定的路径中"); 
return; 
} 
String logFile = dbProps.getProperty("logfile", "DBConnectionManager.log"); 
try 
{ 
log = new PrintWriter(new FileWriter(logFile, true), true); 
} 
catch (IOException e) 
{ 
System.err.println("无法打开日志文件: " + logFile); 
log = new PrintWriter(System.err); 
} 
loadDrivers(dbProps); 
createPools(dbProps); 
} /** 
* 装载和注册所有JDBC驱动程序 
* 
* @param props 属性 
*/ 
private void loadDrivers(Properties props) 
{ 
String driverClasses = props.getProperty("drivers"); 
StringTokenizer st = new StringTokenizer(driverClasses); 
while (st.hasMoreElements()) 
{ 
String driverClassName = st.nextToken().trim(); 
try 
{ 
Driver driver = (Driver)Class.forName(driverClassName).newInstance(); 
DriverManager.registerDriver(driver); 
drivers.addElement(driver); 
log("成功注册JDBC驱动程序" + driverClassName); 
} 
catch (Exception e) 
{ 
log("无法注册JDBC驱动程序: " + driverClassName + ", 错误: " + e); 
} 
} 
} /** 
* 将文本信息写入日志文件 
*/ 
private void log(String msg) 
{ 
log.println(new Date() + ": " + msg); 
} /** 
* 将文本信息与异常写入日志文件 
*/ 
private void log(Throwable e, String msg) 
{ 
log.println(new Date() + ": " + msg); 
e.printStackTrace(log); 
} /** 
* 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最 
* 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性. 
*/ 
class DBConnectionPool 
{ 
private int checkedOut; 
private Vector freeConnections = new Vector(); 
private int maxConn; 
private String name; 
private String password; 
private String URL; 
private String user; /** 
* 创建新的连接池 
* 
* @param name 连接池名字 
* @param URL 数据库的JDBC URL 
* @param user 数据库帐号,或 null 
* @param password 密码,或 null 
* @param maxConn 此连接池允许建立的最大连接数 
*/ 
public DBConnectionPool(String name, String URL, String user, String password,int maxConn) 
{ 
this.name = name; 
this.URL = URL; 
this.user = user; 
this.password = password; 
this.maxConn = maxConn; 
} /** 
* 将不再使用的连接返回给连接池 
* 
* @param con 客户程序释放的连接 
*/ 
public synchronized void freeConnection(Connection con) 
{ 
// 将指定连接加入到向量末尾 
freeConnections.addElement(con); 
checkedOut--; 
notifyAll(); 
} /** 
* 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接 
* 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之, 
* 然后递归调用自己以尝试新的可用连接. 
*/ 
public synchronized Connection getConnection() 
{ 
Connection con = null; 
if (freeConnections.size() > 0) 
{ 
// 获取向量中第一个可用连接 
con = (Connection) freeConnections.firstElement(); 
freeConnections.removeElementAt(0); 
try 
{ 
if (con.isClosed()) 
{ 
log("从连接池" + name+"删除一个无效连接"); 
// 递归调用自己,尝试再次获取可用连接 
con = getConnection(); 
} 
} 
catch (SQLException e) 
{ 
log("从连接池" + name+"删除一个无效连接"); 
// 递归调用自己,尝试再次获取可用连接 
con = getConnection(); 
} 
} 
else if (maxConn == 0 || checkedOut < maxConn) 
{ 
con = newConnection(); 
} 
if (con != null) 
{ 
checkedOut++; 
} 
return con; 
} /** 
* 从连接池获取可用连接.可以指定客户程序能够等待的最长时间 
* 参见前一个getConnection()方法. 
* 
* @param timeout 以毫秒计的等待时间限制 
*/ 
public synchronized Connection getConnection(long timeout) 
{ 
long startTime = new Date().getTime(); 
Connection con; 
while ((con = getConnection()) == null) 
{ 
try 
{ 
wait(timeout); 
} 
catch (InterruptedException e) {} 
if ((new Date().getTime() - startTime) >= timeout) 
{ 
// wait()返回的原因是超时 
return null; 
} 
} 
return con; 
} /** 
* 关闭所有连接 
*/ 
public synchronized void release() 
{ 
Enumeration allConnections = freeConnections.elements(); 
while (allConnections.hasMoreElem

Answer 7

谢谢，实际上这些代码我都分析过，但是不明白具体的调用，例如DBConnectionManager，就无法返回连接，我是这样调用的。db.properties文件内容是这样的：drivers=oracle.jdbc.driver.OracleDriver access.maxconn=20 
access.url=jdbc:oracle:thin:@172.18.8.4:1521:ORCL 
access.user=powersumfee 
access.password=cjh 然后调用如下：
DBConnectionManager dMan = DBConnectionManager.getInstance();
conn = dMan.getConnection("access");但是返回的都是空值，上面的调用是否有问题？
db.properties我已经放到CLASSPATH目录中了，是否文件内容设置有问题另 hccpro(hcc):
DataSource具体如何调用呢？是否有具体的范例？

Answer 8

谢谢，实际上这些代码我都分析过，但是不明白具体的调用，例如DBConnectionManager，就无法返回连接，我是这样调用的。db.properties文件内容是这样的：drivers=oracle.jdbc.driver.OracleDriver access.maxconn=20 
access.url=jdbc:oracle:thin:@172.18.8.4:1521:ORCL 
access.user=powersumfee 
access.password=cjh 然后调用如下：
DBConnectionManager dMan = DBConnectionManager.getInstance();
conn = dMan.getConnection("access");但是返回的都是空值，上面的调用是否有问题？
db.properties我已经放到CLASSPATH目录中了，是否文件内容设置有问题另 hccpro(hcc):
DataSource具体如何调用呢？是否有具体的范例？

Answer 9

楼上讲得很清楚！
其实就在一个pool类中是把若干Connect连接放到一个static Vector中，然后
写代码保证pool只被实例化一次(构造函数定义为private)！
然后再提供一个static 的 getConnection()函数就行了！当然多封装几层后你会发现可以让他功能很强打！

Answer 10

我们用的是直接在websphere4.0下配好(具体配置我也还没有搞的好清楚）的，然后用jndi得到DataSource，然后从DataSource得到一个连接这样用的。
看来真应该好好象前辈们学习！

Answer 11

to: technofantasy(www.applevb.com) 
我想你的db.properties文件肯定是没有找到，再去调整一下你的claaapath的设置试试。其实属性文件和数据库源(DataSource)是差不多的，都是把一些数据库的连接属性从程序中分离出来，避免了每次修改数据库连接后都要再去把程序重新编译的弊病。
DataSource的配置和具体的应用服务器有关的，可以参考相关的文档。
如果是weblogic的话，我可以提供参考。

Answer 12

db.properties放在WEB-INF\classes目录下，
使用如下：
 /**
      * @description
      * 连接数据库
      *
      * @para   无
      * @exception   (exception)
      * @return  无
      * 使用列子　
      */
   public static Connection connectBase(){
        try{
            DBConnectionManager dbcm=DBConnectionManager.getInstance();
             //初始化DBConnectionManager变量dbcm
            return dbcm.getConnection ();
             //调用DBConnectionManager类的getConnection方法得到数据库连接
        }
        catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }     /**
      * @description
      * 断开连接池，关闭对数据库的连接
      * @para ()
      * @return ()
      * @exception　()
      * 修改历史：
      * 修改描述：
      */
     public static boolean closeBase(Connection con){
       try{
            if(con==null){
            System.out.println ("连接为空");
            return false;
        }else{
            DBConnectionManager dbcm=DBConnectionManager.getInstance();
            dbcm.freeConnection (con);
            //调用DBConnectionManager类的freeConnection方法释放数据库连接
            }
         }catch(Exception e){
            System.out.println(e);
        }
        return  true;
    }

Answer 13

在JSP中能使用连接池吗，怎么用？谢谢

Answer 14

在Jsp中可以用连接池。
和Java里面的用法是一样的，但建议你还是放在bean里面。

Answer 15

在Jsp中可以用连接池。
和Java里面的用法是一样的，但建议你还是放在bean里面。

Answer 16

to各位大虾：
  这里各位大哥说的连接池和weblogic里面的jdbc中配置的连接池是什么关系？？----------谁告诉我，我是菜鸟！:(

Answer 17

问题是那个具体的实现啊，是shine_car贴的那个还是别的什么。连接池多了，具体问题具体分析。

Answer 18

现在我的问题是：
1、上面的连接池代码有没有人试过，我用了总是不成功。
2、性能如何，我根据上面的代码精简做了一个连接池的类，但是首先并没有使 oracle 中的回话数保持在我规定的数量内，而且好像性能没有显著的提高。

Answer 19

（1、上面的连接池代码有没有人试过，我用了总是不成功。）
我们的项目就是用的这个。不知是否驱动程序放在可找到的路径里面没。（for sql server，odbc）db.properties：
drivers=sun.jdbc.odbc.JdbcOdbcDriver com.inet.tds.TdsDriver
logfile=F:\\oaSite\\dblog.txt
uploadFilePath=F:\\oaSite\\web\\upload\\Tds.url=jdbc:inetdae:127.0.0.1:1433?charset=gb2312&database=oa
Tds.user=oaUser
Tds.password=oaUser
Tds.maxconn=6
Odbc.url=jdbc:odbc:toServer
Odbc.user=oaUser
Odbc.password=oaUser
2.性能还可以,不过没做测试。