poolmanager.java

该压缩文件包含有多个连接池管理包

/**
 * Title:
 * Description:
 * Copyright:    Copyright (c) 2001
 * Company:      CSU
 * @author       chenlong
 * @version 1.0
 */



import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;
/**
 *  	\u52A0\u8F7D\u548C\u6CE8\u518C\u6240\u6709JDBC\u9A71\u52A8\u7A0B\u5E8F
 *      \u6839\u636E\u4E00\u4E2A\u7279\u6027\u6587\u4EF6\u4E2D\u5B9A\u4E49\u7684\u7279\u6027\uFF0C\u521B\u5EFAConnectionPool\u5BF9\u8C61
 *      \u5C06\u8FDE\u63A5\u6C60\u540D\u79F0\u6620\u5C04\u5230ConnectionPool\u5BF9\u8C61\u4E0A
 *      \u5C06\u5BA2\u6237\u8BF7\u6C42\u4F20\u9012\u5230\u4E00\u4E2A\u540D\u79F0\u4E3AConnectionPool\u7684\u7279\u5B9A\u5BF9\u8C61
 *	\u8DDF\u8E2A\u8FDE\u63A5\u6C60\u4E2D\u7684\u5BA2\u6237\uFF0C\u5F53\u6700\u540E\u4E00\u4E2A\u5BA2\u6237\u5B8C\u6210\u5DE5\u4F5C\u65F6\u5173\u95ED\u8FDE\u63A5\u6C60
 *
 * PoolManager\u80FD\u591F\u83B7\u5F97\u6709\u5173\u4F7F\u7528JDBC\u9A71\u52A8\u7A0B\u5E8F\u7684\u4FE1\u606F\uFF0C
 * \u540C\u65F6\u4E5F\u53EF\u4EE5\u83B7\u5F97\u4ECE\u540D\u79F0\u4E3Adb.properties\u7279\u6027\u6587\u4EF6\u4E2D\u521B\u5EFA\u8FDE\u63A5\u6C60\uFF0C\u8BE5\u7279\u6027\u6587\u4EF6\u5FC5\u987B\u4E3A\u670D\u52A1\u5668\u653E\u7F6E\u5728CLASSPATH\u4E2D\u3002
 */

public class PoolManager
{

   static private PoolManager instance;
   static private int clients;

   private LogWriter logWriter;
   private PrintWriter pw;

   private Vector drivers = new Vector();
   private Hashtable pools = new Hashtable();

   private PoolManager()
   {
      init();
   }

/**
 *\u5F97\u5230PoolManager\u7684\u552F\u4E00\u5B9E\u4F8B
 */

   static synchronized public PoolManager getInstance()
   {
      if (instance == null)
      {
         instance = new PoolManager();
      }
      clients++;
      return instance;
   }

   private void init()
   {
      // Log to System.err until we have read the logfile property
      pw = new PrintWriter(System.err, true);
      logWriter = new LogWriter("PoolManager", LogWriter.INFO, pw);
      InputStream is = getClass().getResourceAsStream("db.properties");
      Properties dbProps = new Properties();
      try
      {
         dbProps.load(is);
      }
      catch (Exception e)
      {
         logWriter.log("Can't read the properties file. " +
            "Make sure db.properties is in the CLASSPATH",
            LogWriter.ERROR);
         return;
      }
      String logFile = dbProps.getProperty("logfile");
      if (logFile != null)
      {
         try
         {
            pw = new PrintWriter(new FileWriter(logFile, true), true);
            logWriter.setPrintWriter(pw);
         }
         catch (IOException e)
         {
            logWriter.log("Can't open the log file: " + logFile +
               ". Using System.err instead", LogWriter.ERROR);
         }
      }
      loadDrivers(dbProps);
      createPools(dbProps);
   }
/**
 * \u4ECEdb.properties\u4E2D\u5F97\u5230\u5404\u79CD\u53C2\u6570
 * \u7136\u540E\u521B\u5EFA\u8FDE\u63A5\u6C60
 */

   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);
            logWriter.log("Registered JDBC driver " + driverClassName,
               LogWriter.INFO);
         }
         catch (Exception e)
         {
            logWriter.log(e, "Can't register JDBC driver: " +
               driverClassName, LogWriter.ERROR);
         }
      }
   }
/**
 * \u521B\u5EFA\u8FDE\u63A5\u6C60
 */

   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)
            {
               logWriter.log("No URL specified for " + poolName,
                  LogWriter.ERROR);
               continue;
            }

            String user = props.getProperty(poolName + ".user");
            String password = props.getProperty(poolName + ".password");

            String maxConns = props.getProperty(poolName +
               ".maxconns", "0");
            int max;
            try
            {
               max = Integer.valueOf(maxConns).intValue();
            }
            catch (NumberFormatException e)
            {
               logWriter.log("Invalid maxconns value " + maxConns +
                               " for " + poolName, LogWriter.ERROR);
               max = 0;
            }

            String initConns = props.getProperty(poolName +
                              ".initconns", "0");
            int init;
            try
            {
               init = Integer.valueOf(initConns).intValue();
            }
            catch (NumberFormatException e)
            {
               logWriter.log("Invalid initconns value " + initConns +
                             " for " + poolName, LogWriter.ERROR);
               init = 0;
            }

            String loginTimeOut = props.getProperty(poolName +
               ".logintimeout", "5");
            int timeOut;
            try
            {
               timeOut = Integer.valueOf(loginTimeOut).intValue();
            }
            catch (NumberFormatException e)
            {
               logWriter.log("Invalid logintimeout value " + loginTimeOut +
                            " for " + poolName, LogWriter.ERROR);
               timeOut = 5;
            }

            String logLevelProp = props.getProperty(poolName +
                           ".loglevel", String.valueOf(LogWriter.ERROR));
            int logLevel = LogWriter.INFO;
            if (logLevelProp.equalsIgnoreCase("none"))
            {
               logLevel = LogWriter.NONE;
            }
            else if (logLevelProp.equalsIgnoreCase("error"))
            {
               logLevel = LogWriter.ERROR;
            }
            else if (logLevelProp.equalsIgnoreCase("debug"))
            {
               logLevel = LogWriter.DEBUG;
            }

            ConnectionPool pool =
                           new ConnectionPool(poolName, url, user, password,
                                            max, init, timeOut, pw, logLevel);
            pools.put(poolName, pool);
         }
      }
   }
/**
 * \u901A\u8FC7\u8BBF\u95EEConnectionPool\u5F97\u5230\u8FDE\u63A5
 */

   public Connection getConnection(String name)
   {
      Connection conn = null;
      ConnectionPool pool = (ConnectionPool) pools.get(name);
      if (pool != null)
      {
         try
         {
            conn = pool.getConnection();
         }
         catch (SQLException e)
         {
            e.printStackTrace();
            logWriter.log(e, "Exception getting connection from " +
               name, LogWriter.ERROR);
         }
      }
      return conn;
   }
/**
 * \u91CA\u653E\u8FDE\u63A5
 */

   public void freeConnection(String name, Connection con)
   {
      ConnectionPool pool = (ConnectionPool) pools.get(name);
      if (pool != null)
      {
         pool.freeConnection(con);
      }
   }
/**
 * \u8C03\u7528ConnectionPool
 * \u91CA\u653E\u6240\u6709\u8FDE\u63A5
 */

   public synchronized void release()
   {
      // Wait until called by the last client
      if (--clients != 0)
      {
         return;
      }

      Enumeration allPools = pools.elements();
      while (allPools.hasMoreElements())
      {
         ConnectionPool pool = (ConnectionPool)allPools.nextElement();
         pool.release();
      }

      Enumeration allDrivers = drivers.elements();
      while (allDrivers.hasMoreElements())
      {
         Driver driver = (Driver) allDrivers.nextElement();
         try
         {
            DriverManager.deregisterDriver(driver);
            logWriter.log("Deregistered JDBC driver " +
                          driver.getClass().getName(), LogWriter.INFO);
         }
         catch (SQLException e)
         {
            logWriter.log(e, "Couldn't deregister JDBC driver: " +
                             driver.getClass().getName(), LogWriter.ERROR);
         }
      }
   }
}