package oa.main;

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;

/**
 * 管理類DBConnectionManager支持對(duì)一個(gè)或多個(gè)由屬性文件定義的數(shù)據(jù)庫(kù)連接
 * 池的訪問(wèn).客戶程序可以調(diào)用getInstance()方法訪問(wèn)本類的唯一實(shí)例.
 */
public class DBConnectionManager
{
	static private DBConnectionManager instance; // 唯一實(shí)例
	static private int clients;

	private Vector drivers = new Vector();
	private PrintWriter log;
	public static Hashtable pools = new Hashtable();

	/**
	 * 返回唯一實(shí)例.如果是第一次調(diào)用此方法,則創(chuàng)建實(shí)例
	 *
	 * @return DBConnectionManager 唯一實(shí)例
	 */
	static synchronized public DBConnectionManager getInstance()
	{
		//if(instance == null)為了能夠在控制臺(tái)和Tomcat中都能使用連接池，在配置文件中初始化了兩次
		//第一次初始化默認(rèn)的配置參數(shù)，給控制臺(tái)使用，
		//第二次初始化Tomcat中的配置參數(shù)，
		//為了在第二次能夠重新進(jìn)行參數(shù)讀取，此處注掉
		{
			instance = new DBConnectionManager();
		}
		clients++;
		return instance;
	}

	public static int getCurConns(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool!=null)
		{
			return pool.getCurConns();
		}
		else
		{
			return 0;
		}
	}

	public static int getSumConns(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool!=null)
		{
			return pool.getSumConns();
		}
		else
		{
			return 0;
		}
	}

	public static int getMaxConns(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool!=null)
		{
			return pool.getMaxConns();
		}
		else
		{
			return 0;
		}
	}

	public static int getNullPool(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool!=null)
		{
			return pool.getNullPool();
		}
		else
		{
			return 0;
		}
	}

	public static int getOracleErr(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool!=null)
		{
			return pool.getOracleErr();
		}
		else
		{
			return 0;
		}
	}

	/**
	 * 建構(gòu)函數(shù)私有以防止其它對(duì)象創(chuàng)建本類實(shí)例
	 */
	private DBConnectionManager()
	{
		init();
	}

	/**
	 * 將連接對(duì)象返回給由名字指定的連接池
	 *
	 * @param name 在屬性文件中定義的連接池名字
	 * @param con 連接對(duì)象
	 */
	public void freeConnection(String name, Connection con)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool != null)
		{
			pool.freeConnection(con);
		}
	}

	/**
	 * 獲得一個(gè)可用的(空閑的)連接.如果沒(méi)有可用連接,且已有連接數(shù)小于最大連接數(shù)
	 * 限制,則創(chuàng)建并返回新連接
	 *
	 * @param name 在屬性文件中定義的連接池名字
	 * @return Connection 可用連接或null
	 */
	public Connection getConnection(String name)
	{
		DBConnectionPool pool = (DBConnectionPool)pools.get(name);
		if(pool != null)
		{
			return pool.getConnection();
		}
		return null;
	}

	/**
	 * 獲得一個(gè)可用連接.若沒(méi)有可用連接,且已有連接數(shù)小于最大連接數(shù)限制,
	 * 則創(chuàng)建并返回新連接.否則,在指定的時(shí)間內(nèi)等待其它線程釋放連接.
	 *
	 * @param name 連接池名字
	 * @param time 以毫秒計(jì)的等待時(shí)間
	 * @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 static void test(String name)
	{
		DBConnectionPool pool =  (DBConnectionPool)pools.get(name);
		pool.test();
	}

	/**
	 * 關(guān)閉所有連接,撤銷(xiāo)驅(qū)動(dòng)程序的注冊(cè)
	 */
	public synchronized void release()
	{
		// 等待直到最后一個(gè)客戶程序調(diào)用
		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("撤銷(xiāo)JDBC驅(qū)動(dòng)程序 " + driver.getClass().getName() + "的注冊(cè)");
			}
			catch(SQLException e)
			{
				log(e, "無(wú)法撤銷(xiāo)下列JDBC驅(qū)動(dòng)程序的注冊(cè): " + driver.getClass().getName());
			}
		}
	}

	/**
	 * 根據(jù)指定屬性創(chuàng)建連接池實(shí)例.
	 *
	 * @param props 連接池屬性
	 */
	private void createPools()
	{
		String poolName = Configuration.ConnectionPoolName;
		String url = Configuration.DB_URL;
		if(url == null)
		{
			log("沒(méi)有為連接池" + poolName + "指定URL");
			return ;
		}
		String user = Configuration.DB_USERNAME;
		String password = Configuration.DB_PASSWORD;
		String maxconn = Configuration.DB_MAXCONNNUM;
		int max;
		try
		{
			max = Integer.valueOf(maxconn).intValue();
		}
		catch(NumberFormatException e)
		{
			log("錯(cuò)誤的最大連接數(shù)限制: " + maxconn + " .連接池: " + poolName);
			max = 0;
		}
		DBConnectionPool pool =
			new DBConnectionPool(poolName, url, user, password, max);
		pools.put(poolName, pool);
		log("成功創(chuàng)建連接池" + poolName);

	}

	/**
	 * 讀取屬性完成初始化
	 */
	private void init()
	{
		 String logFile = Configuration.DB_LOGFILE;
		 try {
		   log = new PrintWriter(new FileWriter(logFile, true), true);
		 }
		 catch (IOException e) {
		   System.err.println("無(wú)法打開(kāi)日志文件: " + logFile);
		   log = new PrintWriter(System.err);
		 }

		loadDrivers();
		createPools();
	}

	/**
	 * 裝載和注冊(cè)所有JDBC驅(qū)動(dòng)程序
	 *
	 * @param props 屬性
	 */
	private void loadDrivers()
	{
		String driverClasses = Configuration.DB_JDBCDRIVER;
		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("成功注冊(cè)JDBC驅(qū)動(dòng)程序" + driverClassName);
			}
			catch(Exception e)
			{
				log("無(wú)法注冊(cè)JDBC驅(qū)動(dòng)程序: " +
					driverClassName + ", 錯(cuò)誤: " + e);
				System.out.println("\r\n無(wú)法注冊(cè)JDBC驅(qū)動(dòng)程序: " +
					driverClassName + ", 錯(cuò)誤: " + e);
			}
		}
	}

	/**
	 * 將文本信息寫(xiě)入日志文件
	 */
	private void log(String msg)
	{
		log.println(new Date() + ": " + msg);
	}

	/**
	 * 將文本信息與異常寫(xiě)入日志文件
	 */
	private void log(Throwable e, String msg)
	{
		log.println(new Date() + ": " + msg);
		e.printStackTrace(log);
	}

	/**
	 * 此內(nèi)部類定義了一個(gè)連接池.它能夠根據(jù)要求創(chuàng)建新連接,直到預(yù)定的最
	 * 大連接數(shù)為止.在返回連接給客戶程序之前,它能夠驗(yàn)證連接的有效性.
	 */
	class DBConnectionPool
	{
		private int sum;
		private int checkedOut;
		private Vector freeConnections = new Vector();
		private int maxConn;
		private int max;
		private String name;
		private String password;
		private String URL;
		private String user;
		private int isNullPool;
		private int isOracleErr ;

		/**
		 * 創(chuàng)建新的連接池
		 *
		 * @param name 連接池名字
		 * @param URL 數(shù)據(jù)庫(kù)的JDBC URL
		 * @param user 數(shù)據(jù)庫(kù)帳號(hào),或 null
		 * @param password 密碼,或 null
		 * @param maxConn 此連接池允許建立的最大連接數(shù)
		 */
		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)
		{
			testConn(con);
			if(con!=null)
			{
				// 將指定連接加入到向量末尾
				freeConnections.addElement(con);
				checkedOut--;
			}
			notifyAll();
		}

		/**
		 * 從連接池獲得一個(gè)可用連接.如沒(méi)有空閑的連接且當(dāng)前連接數(shù)小于最大連接
		 * 數(shù)限制,則創(chuàng)建新連接.如原來(lái)登記為可用的連接不再有效,則從向量刪除之,
		 * 然后遞歸調(diào)用自己以嘗試新的可用連接.
		 */
		public synchronized Connection getConnection()
		{
			Connection con = null;
			if(freeConnections.size() > 0)
			{
				// 獲取向量中第一個(gè)可用連接
				con = (Connection)freeConnections.firstElement();
				freeConnections.removeElementAt(0);
				try
				{
					if(con.isClosed())
					{
						log("從連接池" + name + "刪除一個(gè)無(wú)效連接");
						// 遞歸調(diào)用自己,嘗試再次獲取可用連接
						con = getConnection();
					}
				}
				catch(SQLException e)
				{
					log("從連接池" + name + "刪除一個(gè)無(wú)效連接");
					// 遞歸調(diào)用自己,嘗試再次獲取可用連接
					con = getConnection();
				}
			}
			else if(maxConn == 0 || checkedOut < maxConn)
			{
				con = newConnection();
			}
			else
			{
				//System.out.println("  連接池取空,等待回收!");
				isNullPool++ ;
			}
			if(con != null)
			{
				checkedOut++;
				sum++;
			}
			testConn(con);
			return con;
		}

		/**
		 * 從連接池獲取可用連接.可以指定客戶程序能夠等待的最長(zhǎng)時(shí)間
		 * 參見(jiàn)前一個(gè)getConnection()方法.
		 *
		 * @param timeout 以毫秒計(jì)的等待時(shí)間限制
		 */
		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()返回的原因是超時(shí)
					return null;
				}
			}
			return con;
		}

		/**
		 * 關(guān)閉所有連接
		 */
		public synchronized void release()
		{
			Enumeration allConnections = freeConnections.elements();
			while(allConnections.hasMoreElements())
			{
				Connection con = (Connection)allConnections.nextElement();
				try
				{
					con.close();
					log("關(guān)閉連接池" + name + "中的一個(gè)連接");
				}
				catch(SQLException e)
				{
					log(e, "無(wú)法關(guān)閉連接池" + name + "中的連接");
				}
			}
			freeConnections.removeAllElements();
		}

		/**
		 * 創(chuàng)建新的連接
		 */
		private Connection newConnection()
		{
			Connection con = null;
			try
			{
				if(user == null)
				{
					con = DriverManager.getConnection(URL);
				}
				else
				{
					con = DriverManager.getConnection(URL, user, password);
				}
				max++;
				log("連接池" + name + "創(chuàng)建一個(gè)新的連接");
			}
			catch(SQLException e)
			{
				//以下注釋實(shí)在數(shù)據(jù)庫(kù)連接調(diào)試正常的情況下，因?yàn)橐韵碌那闆r概率最大，所以沒(méi)有提示連接地址錯(cuò)誤
				log(e, "Oracle來(lái)不及響應(yīng),無(wú)法創(chuàng)建下列URL的連接: " + URL);
				//System.out.println("  Oracle來(lái)不及響應(yīng)!");
				isOracleErr ++ ;
				return null;
			}
			return con;
		}

		public int getCurConns()
		{
			return checkedOut;
		}

		public int getSumConns()
		{
			return sum ;
		}

		public int getMaxConns()
		{
			return max;
		}

		public int getNullPool()
		{
			return isNullPool;
		}

		public int getOracleErr()
		{
			return isOracleErr ;
		}

		public void test()
		{
			System.out.println("\r\n\r\n--------------------vect.size="+freeConnections.size()+"\r\n\r\n");
			for(int i=0;i<freeConnections.size();i++)
			{
				Connection conn = (Connection)freeConnections.get(i);
				testConn(conn);
			}
		}

		public void testConn(Connection c)
		{
			try
			{
				if(c.isClosed())System.out.println("連接池錯(cuò)誤：當(dāng)前連接有問(wèn)題:該連接破壞！");

				Statement stm = c.createStatement();
				ResultSet rs = stm.executeQuery("select count(*) from sms");
				rs.next();
				rs.close();stm.close();
				System.out.println("=========="+rs.getInt(1));
			}
			catch(SQLException s){System.out.println("連接池錯(cuò)誤：當(dāng)前連接有問(wèn)題:"+s);}
		}
	}

	
}