鷹翔宇空

int executeSQL(String sql) throws SQLException
{
	Connection conn = getConnection();	//通過某種方式獲取數(shù)據(jù)庫連接
	PreparedStatement ps = null;
	int res = 0;
	try{
		ps = conn.prepareStatement(sql);
		res = ps.executeUpdate();
}finally{
try{
ps.close();
}catch(Exception e){}
try{
	conn.close();//
}catch(Exception e){}
}
return res;
}

public interface InvocationHandler

InvocationHandler is the interface implemented by the invocation handler of a proxy instance. 

Each proxy instance has an associated invocation handler. 
When a method is invoked on a proxy instance, 
the method invocation is encoded and dispatched to the invoke method of its invocation handler.

public class ConnectionParam implements Serializable
{
	private String driver;				//數(shù)據(jù)庫驅(qū)動程序
	private String url;					//數(shù)據(jù)連接的URL
	private String user;					//數(shù)據(jù)庫用戶名
	private String password;				//數(shù)據(jù)庫密碼
	private int minConnection = 0;		//初始化連接數(shù)
	private int maxConnection = 50;		//最大連接數(shù)
	private long timeoutValue = 600000;//連接的最大空閑時間
	private long waitTime = 30000;		//取連接的時候如果沒有可用連接最大的等待時間

/**
 * 連接池類廠，該類常用來保存多個數(shù)據(jù)源名稱合數(shù)據(jù)庫連接池對應(yīng)的哈希
 * @author liusoft
 */
public class ConnectionFactory
{
	//該哈希表用來保存數(shù)據(jù)源名和連接池對象的關(guān)系表
	static Hashtable connectionPools = null;
	static{
		connectionPools = new Hashtable(2,0.75F);
	} 
	/**
	 * 從連接池工廠中獲取指定名稱對應(yīng)的連接池對象
	 * @param dataSource	連接池對象對應(yīng)的名稱
	 * @return DataSource	返回名稱對應(yīng)的連接池對象
	 * @throws NameNotFoundException	無法找到指定的連接池
	 */
	public static DataSource lookup(String dataSource) 
		throws NameNotFoundException
	{
		Object ds = null;
		ds = connectionPools.get(dataSource);
		if(ds == null || !(ds instanceof DataSource))
			throw new NameNotFoundException(dataSource);
		return (DataSource)ds;
	}

	/**
	 * 將指定的名字和數(shù)據(jù)庫連接配置綁定在一起并初始化數(shù)據(jù)庫連接池
	 * @param name		對應(yīng)連接池的名稱
	 * @param param	連接池的配置參數(shù)，具體請見類ConnectionParam
	 * @return DataSource	如果綁定成功后返回連接池對象
	 * @throws NameAlreadyBoundException	一定名字name已經(jīng)綁定則拋出該異常
	 * @throws ClassNotFoundException		無法找到連接池的配置中的驅(qū)動程序類
	 * @throws IllegalAccessException		連接池配置中的驅(qū)動程序類有誤
	 * @throws InstantiationException		無法實例化驅(qū)動程序類
	 * @throws SQLException				無法正常連接指定的數(shù)據(jù)庫
	 */
	public static DataSource bind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		DataSourceImpl source = null;
		try{
			lookup(name);
			throw new NameAlreadyBoundException(name);
		}catch(NameNotFoundException e){
			source = new DataSourceImpl(param);
			source.initConnection();
			connectionPools.put(name, source);
		}
		return source;
	}
	/**
	 * 重新綁定數(shù)據(jù)庫連接池
	 * @param name		對應(yīng)連接池的名稱
	 * @param param	連接池的配置參數(shù)，具體請見類ConnectionParam
	 * @return DataSource	如果綁定成功后返回連接池對象
	 * @throws NameAlreadyBoundException	一定名字name已經(jīng)綁定則拋出該異常
	 * @throws ClassNotFoundException		無法找到連接池的配置中的驅(qū)動程序類
	 * @throws IllegalAccessException		連接池配置中的驅(qū)動程序類有誤
	 * @throws InstantiationException		無法實例化驅(qū)動程序類
	 * @throws SQLException				無法正常連接指定的數(shù)據(jù)庫
	 */
	public static DataSource rebind(String name, ConnectionParam param)
		throws NameAlreadyBoundException,ClassNotFoundException,
				IllegalAccessException,InstantiationException,SQLException
	{
		try{
			unbind(name);
		}catch(Exception e){}
		return bind(name, param);
	}
	/**
	 * 刪除一個數(shù)據(jù)庫連接池對象
	 * @param name
	 * @throws NameNotFoundException
	 */
	public static void unbind(String name) throws NameNotFoundException
	{
		DataSource dataSource = lookup(name);
		if(dataSource instanceof DataSourceImpl){
			DataSourceImpl dsi = (DataSourceImpl)dataSource;
			try{
				dsi.stop();
				dsi.close();
			}catch(Exception e){
			}finally{
				dsi = null;
			}
		}
		connectionPools.remove(name);
	}
	
}

	String name = "pool";
	String driver = " sun.jdbc.odbc.JdbcOdbcDriver ";
	String url = "jdbc:odbc:datasource";
	ConnectionParam param = new ConnectionParam(driver,url,null,null);
	param.setMinConnection(1);
	param.setMaxConnection(5);
	param.setTimeoutValue(20000);
	ConnectionFactory.bind(name, param);
	System.out.println("bind datasource ok.");
	//以上代碼是用來登記一個連接池對象，該操作可以在程序初始化只做一次即可
	//以下開始就是使用者真正需要寫的代碼
	DataSource ds = ConnectionFactory.lookup(name);
	try{
		for(int i=0;i<10;i++){
			Connection conn = ds.getConnection();
			try{
				testSQL(conn, sql);
			}finally{
				try{
					conn.close();
				}catch(Exception e){}
			}
		}
	}catch(Exception e){
		e.printStackTrace();
	}finally{
		ConnectionFactory.unbind(name);
		System.out.println("unbind datasource ok.");
		System.exit(0);
	}

source = new DataSourceImpl(param);
source.initConnection();

/**
 * @see javax.sql.DataSource#getConnection(String,String)
 */
	public Connection getConnection(String user, String password) throws SQLException 
	{
		//首先從連接池中找出空閑的對象
		Connection conn = getFreeConnection(0);
		if(conn == null){
			//判斷是否超過最大連接數(shù),如果超過最大連接數(shù)
			//則等待一定時間查看是否有空閑連接,否則拋出異常告訴用戶無可用連接
			if(getConnectionCount() >= connParam.getMaxConnection())
				conn = getFreeConnection(connParam.getWaitTime());
			else{//沒有超過連接數(shù)，重新獲取一個數(shù)據(jù)庫的連接
				connParam.setUser(user);
				connParam.setPassword(password);
				Connection conn2 = DriverManager.getConnection(connParam.getUrl(), 
				user, password);
				//代理將要返回的連接對象
				_Connection _conn = new _Connection(conn2,true);
				synchronized(conns){
					conns.add(_conn);
				}
				conn = _conn.getConnection();
			}
		}
		return conn;
	}
	/**
	 * 從連接池中取一個空閑的連接
	 * @param nTimeout	如果該參數(shù)值為0則沒有連接時只是返回一個null
	 * 否則的話等待nTimeout毫秒看是否還有空閑連接，如果沒有拋出異常
	 * @return Connection
	 * @throws SQLException
	 */
	protected synchronized Connection getFreeConnection(long nTimeout) 
		throws SQLException
	{
		Connection conn = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			_Connection _conn = (_Connection)iter.next();
			if(!_conn.isInUse()){
				conn = _conn.getConnection();
				_conn.setInUse(true);				
				break;
			}
		}
		if(conn == null && nTimeout > 0){
			//等待nTimeout毫秒以便看是否有空閑連接
			try{
				Thread.sleep(nTimeout);
			}catch(Exception e){}
			conn = getFreeConnection(0);
			if(conn == null)
				throw new SQLException("沒有可用的數(shù)據(jù)庫連接");
		}
		return conn;
	}

/**
 * 數(shù)據(jù)連接的自封裝，屏蔽了close方法
 * @author Liudong
 */
class _Connection implements InvocationHandler
{
	private final static String CLOSE_METHOD_NAME = "close";
	private Connection conn = null;
	//數(shù)據(jù)庫的忙狀態(tài)
	private boolean inUse = false;
	//用戶最后一次訪問該連接方法的時間
	private long lastAccessTime = System.currentTimeMillis();
	
	_Connection(Connection conn, boolean inUse){
		this.conn = conn;
		this.inUse = inUse;
	}
	/**
	 * Returns the conn.
	 * @return Connection
	 */
	public Connection getConnection() {
		//返回數(shù)據(jù)庫連接conn的接管類，以便截住close方法
		Connection conn2 = (Connection)Proxy.newProxyInstance(
			conn.getClass().getClassLoader(),
			conn.getClass().getInterfaces(),this);
		return conn2;
	}
	/**
	 * 該方法真正的關(guān)閉了數(shù)據(jù)庫的連接
	 * @throws SQLException
	 */
	void close() throws SQLException{
		//由于類屬性conn是沒有被接管的連接，因此一旦調(diào)用close方法后就直接關(guān)閉連接
		conn.close();
	}
	/**
	 * Returns the inUse.
	 * @return boolean
	 */
	public boolean isInUse() {
		return inUse;
	}

	/**
	 * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object)
	 */
	public Object invoke(Object proxy, Method m, Object[] args) 
		throws Throwable 
	{
		Object obj = null;
		//判斷是否調(diào)用了close的方法，如果調(diào)用close方法則把連接置為無用狀態(tài)
		if(CLOSE_METHOD_NAME.equals(m.getName()))
			setInUse(false);		
		else
			obj = m.invoke(conn, args);	
		//設(shè)置最后一次訪問時間，以便及時清除超時的連接
		lastAccessTime = System.currentTimeMillis();
		return obj;
	}
		
	/**
	 * Returns the lastAccessTime.
	 * @return long
	 */
	public long getLastAccessTime() {
		return lastAccessTime;
	}

	/**
	 * Sets the inUse.
	 * @param inUse The inUse to set
	 */
	public void setInUse(boolean inUse) {
		this.inUse = inUse;
	}
}

	/**
	 * 關(guān)閉該連接池中的所有數(shù)據(jù)庫連接
	 * @return int 返回被關(guān)閉連接的個數(shù)
	 * @throws SQLException
	 */
	public int close() throws SQLException
	{
		int cc = 0;
		SQLException excp = null;
		Iterator iter = conns.iterator();
		while(iter.hasNext()){
			try{
				((_Connection)iter.next()).close();
				cc ++;
			}catch(Exception e){
				if(e instanceof SQLException)
					excp = (SQLException)e;
			}
		}
		if(excp != null)
			throw excp;
		return cc;
	}