dbconnectionmanager.java

数据库连接池

package hrms.common;
/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: </p>
 * @author unascribed
 * @version 1.0
 */

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 Hashtable pools = new Hashtable();

 /**
 * 返回唯一实例.如果是第一次调用此方法,则创建实例
 *
 * @return DBConnectionManager 唯一实例
 */
 static synchronized public DBConnectionManager getInstance() {
 if (instance == null) {
 instance = new DBConnectionManager();
 if(instance.createPools()==false)
	 instance=null;
 }
 clients++;
 return instance;
 }

 /**
 * 建构函数私有以防止其它对象创建本类实例
 */
 private DBConnectionManager() {

 }

 /*
 * 将连接对象返回给由名字指定的连接池
 *
 * @param name 在属性文件中定义的连接池名字
 * @param con 连接对象
 */
 public void freeConnection( Connection con) {
 String name="oraclepool";
 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
 if (pool != null) {
 pool.freeConnection(con);
 }
 }

 /*
 * 获得一个可用的(空闲的)连接.如果没有可用连接,且已有连接数小于最大连接数
 * 限制,则创建并返回新连接
 *
 * @param name 在属性文件中定义的连接池名字
 * @return Connection 可用连接或null
 */
 public Connection getConnection() {
 String name="oraclepool";
 DBConnectionPool pool = (DBConnectionPool) pools.get(name);
 if (pool != null) {
 return pool.getConnection();
 }
 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 boolean createPools() {
   String dbuser;
   String dbpassword;
   String dburl;
   String dbdriver;
   int maxconnection=0;
   InputStream in=null;
   try{
	    try{
           in=new FileInputStream("set/config.dat");
	    }catch(NullPointerException ne){
	      try{
	         in=new FileInputStream("D:\\fcgl\\Tomcat\\bin\\set\\config.dat");
	      }catch(NullPointerException se){
	    	 in=new FileInputStream("E:\\cqcj\\Tomcat\\bin\\set\\config.dat"); 
	       }
	    }catch(Exception e){
	       try{
	    	in=new FileInputStream("D:\\fcgl\\Tomcat\\bin\\set\\config.dat");
	      }catch(Exception ee){
	       in=new FileInputStream("E:\\cqcj\\Tomcat\\bin\\set\\config.dat");
	      }
	    }
        Properties prop=new Properties();
        prop.load(in);
        dbuser=prop.getProperty("dbuser");
        dbpassword=prop.getProperty("dbpassword");
        dburl=prop.getProperty("dburl");
        dbdriver=prop.getProperty("dbdriver");
        maxconnection=Integer.parseInt(prop.getProperty("maxconnection","4"));
        }catch(Exception e){
         System.out.println("can't load config.dat file,the cause is :");
         System.out.println(e);
         return false;
     }

     try{
        //  Class.forName("oracle.jdbc.driver.OracleDriver");
        Class.forName(dbdriver);
        //  con = DriverManager.getConnection(dburl,dbuser,dbpassword);
        }catch(Exception e){
          System.out.println("can't load the database driver,the cause is :");
          System.out.println(e);
         return false;
    }
 String poolName="oraclepool";
 DBConnectionPool pool = new DBConnectionPool(poolName, dburl, dbuser, dbpassword, maxconnection);
 pools.put(poolName, pool);
 for(int i=0;i<maxconnection;i++){
  Connection con=pool.newConnection();
  pool.checkedOut++;
  instance.freeConnection(con);
  if(con==null) return false;
 }
 return true;
 }

 /*
 * 此内部类定义了一个连接池.它能够根据要求创建新连接,直到预定的最
 * 大连接数为止.在返回连接给客户程序之前,它能够验证连接的有效性.
 */
 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) {
 // 将指定连接加入到向量末尾
   try{ if (con.isClosed())return;}catch(Exception e){return;}
   if(freeConnections.size()>maxConn){
     try{con.close();}catch(Exception e){}
   }else{
     freeConnections.addElement(con);
     checkedOut--;
     notifyAll();
   }
 }

/*
 * 从连接池获得一个可用连接.如没有空闲的连接且当前连接数小于最大连接
 * 数限制,则创建新连接.如原来登记为可用的连接不再有效,则从向量删除之,
 * 然后递归调用自己以尝试新的可用连接.
*/

 public  Connection getConnection() {
	  checkedOut++; 
	 //if(checkedOut>800){System.exit(0);}
 Connection con = null;

 if (freeConnections.size() > 0) {
	 // 获取向量中第一个可用连接
	 con = (Connection) freeConnections.firstElement();
	 freeConnections.removeElementAt(0);
	 try {
		if (con.isClosed()) { con = getConnection(); }
	    Statement st=con.createStatement();//isClose()不能判断网络断线的情况，用此方法判断
		st.close();
	} catch (SQLException e) {
		try{con.close();}catch(Exception e1){}
		con = getConnection();
	}
 }
 else  { 
	 con = newConnection();
 }
 //if (con != null) { checkedOut++; }
 return con;
 }

 /*
 * 关闭所有连接
 */
 public synchronized void release() {
 Enumeration allConnections = freeConnections.elements();
 while (allConnections.hasMoreElements()) {
 Connection con = (Connection) allConnections.nextElement();
 try {
 con.close();
// log("关闭连接池" + name+"中的一个连接");
 }
 catch (SQLException e) {
 //log(e, "无法关闭连接池" + name+"中的连接");
}
 }
 freeConnections.removeAllElements();
 }

/*
 * 创建新的连接
 */
 private Connection newConnection() {
 Connection con = null;
//DriverManager.setLoginTimeout(10);
//System.out.println("newconnection");
 try {
 if (user == null) {
 con = DriverManager.getConnection(URL);
 }
 else {
 con = DriverManager.getConnection(URL, user, password);
 }
 //log("连接池" + name+"创建一个新的连接");
 }
 catch (SQLException e) {
//	 System.exit(0);
 //log(e, "无法创建下列URL的连接: " + URL);
 return null;
 }
 return con;
 }
 }
 public static void main(String[] args){
	 DBConnectionManager.getInstance();
     Connection con=DBConnectionManager.getInstance().getConnection();
	 System.out.println(con.toString());
 }
 }