以前在网上看到一个别人写的连接池，很收启发，但是不记得那位仁兄的名字了，：）今天把它拿出来，改了下，还希望那位仁兄不要“骂”我啊。。嘿嘿。。。
/*
* Created on 2006-5-24 9:23:26
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
* ===============Version 1.0.0.0======================
*/
package com;
import java.sql.*;
import java.util.*;
import java.io.*;
import com.log.Logger;
/**
* @author 李国庆
*
* Project: Test Package: com ClassName: ConnectionPool
*/
public class ConnectionPool implements TimerListener {
// Keep a static ConnectionPool for singleton
private static ConnectionPool connectionPool;
// Driver name
String jdbcDriver;
// Connection URL
String jdbcConnectionURL;
// Minimum size of the pool
int connectionPoolSize;
// Maximum size of the pool
int connectionPoolMax;
// Maximum number of uses for a single connection, or -1 for
// none
int connectionUseCount;
// Maximum connection idle time (in minutes)
int connectionTimeout;
// The connection pool scan interval;
int scanInterval;
// Additional JDBC properties
Properties jdbcProperties;
// The Connection pool. This is a vector of ConnectionObject
// objects
Vector pool;
// The maximum number of simultaneous connections as reported
// by the JDBC driver
int maxConnections = -1;
// Our Timer object
Timer timer;
/**
* Empty Constructor
*/
private ConnectionPool() throws Exception {
initialize();
}
/**
* <p&rt;Initializes the ConnectionPool object using ´database.conf´ under
* the WEB-INF/classes as the configuration file
*
* @return true if the ConnectionPool was initialized properly
*/
private boolean initialize() throws Exception {
return initialize("database.conf");
}
/**
* <p&rt;Initializes the ConnectionPool object with the specified
* configuration file
*
* @param config
* Configuration file name
* @return true if the ConnectionPool was initialized properly
*/
private boolean initialize(String config) throws Exception {
boolean rc = loadConfig(config);
if (rc) {
Logger.println("Creating the pool....");
createPool();
timer = new Timer(this, scanInterval);
timer.start();
}
return rc;
}
{
}
/**
* <p&rt;Destroys the pool and it´s contents. Closes any open JDBC
* connections and frees all resources
*/
public void destroy() {
try {
if (timer != null) {
timer.destroy();
timer = null;
}
if (pool != null) {
for (int i = 0; i < pool.size(); i++) {
close((ConnectionObject) pool.elementAt(i));
}
}
pool = null;
}
catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Create single ConnectionPool if there is not ConnectionPool
*
* @param none
* @return Static ConnectionPool
*/
public static ConnectionPool getInstance() throws Exception {
if (connectionPool == null) {
connectionPool = new ConnectionPool();
}
return connectionPool;
}
/**
* <p&rt;Gets an available JDBC Connection. Connections will be created if
* necessary, up to the maximum number of connections as specified in the
* configuration file.
*
* @return JDBC Connection, or null if the maximum number of connections has
* been exceeded
*/
public synchronized Connection getConnection()
{
if (pool == null)
{
return null;
}
java.sql.Connection con = null;
ConnectionObject connectionObject = null;
ConnectionObject co = null;
int poolSize = pool.size();
for (int i = 0; i < poolSize; i++)
{
co = (ConnectionObject) pool.elementAt(i);
if (co.isAvailable())
{
connectionObject = co;
break;
}
}
if (connectionObject == null)
{
if ((connectionPoolMax < 0) || ((connectionPoolMax &rt; 0) && (poolSize < connectionPoolMax)))
{
int i = addConnection();
if (i &rt;= 0) {
connectionObject = (ConnectionObject)pool.elementAt(i);
}
}
else {
Logger.println("Maximum number of connections exceeded");
}
}
if (connectionObject != null)
{
connectionObject.inUse = true;
connectionObject.useCount++;
touch(connectionObject);
con = connectionObject.con;
}
return con;
}
/**
* <p&rt;Places the connection back into the connection pool, or closes the
* connection if the maximum use count has been reached
*
* @param Connection
* object to close
*/
public synchronized void close(Connection aCon)
{
int index = find(aCon);
if (index != -1)
{
ConnectionObject co = (ConnectionObject)pool.elementAt(index);
if ((connectionUseCount &rt; 0) && (co.useCount &rt;= connectionUseCount))
{
Logger.println("Connection use count exceeded");
removeFromPool(index);
}
else
{
touch(co);
co.inUse = false;
}
}
}
/**
* <p&rt;Prints the contents of the connection pool to the standard output
* device, test the Pool content
*/
public void printPool() {
System.out.println("--ConnectionPool--");
if (pool != null) {
for (int i = 0; i < pool.size(); i++) {
ConnectionObject co = (ConnectionObject) pool.elementAt(i);
System.out.println("" + i + "=" + co);
}
}
}
/**
* <p&rt;Removes the ConnectionObject from the pool at the given index
*
* @param index
* Index into the pool vector
*/
private synchronized void removeFromPool(int index)
{
if (pool != null)
{
if (index < pool.size() && (index &rt;= 0))
{
ConnectionObject co = (ConnectionObject)pool.elementAt(index);
close(co);
pool.removeElementAt(index);
}
}
}
/**
* <p&rt;Closes the connection in the given ConnectionObject
*
* @param connectObject
* ConnectionObject
*/
private void close(ConnectionObject connectionObject) {
if (connectionObject != null) {
if (connectionObject.con != null) {
try {
connectionObject.con.close();
}
catch (Exception ex) {
}
connectionObject.con = null;
}
}
}
/**
* <p&rt;Loads the given configuration file. All global properties (such as
* JDBCDriver) will be read and removed from the properties list. Any
* leftover properties will be returned. Returns null if the properties
* could not be loaded
*
* @param name
* Configuration file name
* @return true if the configuration file was loaded
*/
private boolean loadConfig(String name)
throws Exception{
boolean rc = false;
try {
jdbcProperties = lc.getConfigProperties(name);
if (jdbcProperties == null)
rc = false;
else {
jdbcDriver = consume(jdbcProperties, "DriverName");
jdbcConnectionURL = consume(jdbcProperties, "URL");
connectionPoolSize = consumeInt(jdbcProperties,
"ConnectionPoolSize");
connectionPoolMax = consumeInt(jdbcProperties,
"ConnectionPoolMax");
connectionUseCount = consumeInt(jdbcProperties,
"ConnectionUseCount");
connectionTimeout = consumeInt(jdbcProperties,
"ConnectionTimeout");
scanInterval = consumeInt(jdbcProperties, "ScanInterval");
rc = true;
}
}
catch (Exception e) {
Logger
.println("<Exception&rt;[ConnectionPool]Exception occured while loading config"); // Clean
// memory
throw new Exception (
"Exception while loading the config");
}
return rc;
}
/**
* <p&rt;Consumes the given property and returns the value.
*
* @param properties
* Properties table
* @param key
* Key of the property to retrieve and remove from the properties
* table
* @return Value of the property, or null if not found
*/
private String consume(java.util.Properties p, String key) {
String s = null;
if ((p != null) && (key != null)) {
s = p.getProperty(key);
if (s != null) {
p.remove(key);
}
}
return s;
}
/**
* <p&rt;Consumes the given property and returns the integer value.
*
* @param properties
* Properties table
* @param key
* Key of the property to retrieve and remove from the properties
* table
* @return Value of the property, or -1 if not found
*/
private int consumeInt(java.util.Properties p, String key) {
int n = -1;
String value = consume(p, key);
if (value != null) {
try {
n = Integer.parseInt(value);
}
catch (NumberFormatException ex) {
ex.printStackTrace();
}
}
return n;
}
/**
* <p&rt;Creates the initial connection pool. A timer thread is also created
* so that connection timeouts can be handled.
*
* @return true if the pool was created
*/
private void createPool() throws Exception {
if (jdbcDriver == null) {
throw new Exception("JDBCDriver property not found");
}
if (jdbcConnectionURL == null) {
throw new Exception("JDBCConnectionURL property not found");
}
if (connectionPoolSize < 0) {
throw new Exception("ConnectionPoolSize property not found");
}
if (connectionPoolSize == 0) {
throw new Exception("ConnectionPoolSize invalid");
}
if (connectionPoolMax < connectionPoolSize) {
Logger.println("WARNING - ConnectionPoolMax is invalid and will "
+ "be ignored");
connectionPoolMax = -1;
}
if (connectionTimeout < 0) {
connectionTimeout = 30;
}
Logger.println("JDBCDriver = " + jdbcDriver);
Logger.println("JDBCConnectionURL = " + jdbcConnectionURL);
Logger.println("ConnectionPoolSize = " + connectionPoolSize);
Logger.println("ConnectionPoolMax = " + connectionPoolMax);
Logger.println("ConnectionUseCount = " + connectionUseCount);
Logger.println("ConnectionTimeout = " + connectionTimeout + " seconds");
Logger.println("ScanInterval = " + scanInterval + " seconds");
Logger.println("Registering " + jdbcDriver);
java.sql.Driver d = (java.sql.Driver) Class.forName(jdbcDriver)
.newInstance();
pool = new java.util.Vector();
fillPool(connectionPoolSize);
}
/**
* <p&rt;Adds a new connection to the pool
*
* @return Index of the new pool entry, or -1 if an error has occurred
*/
private int addConnection() {
int index = -1;
try {
int size = pool.size() + 1;
fillPool(size);
if (size == pool.size()) {
index = size - 1;
}
}
catch (Exception ex) {
ex.printStackTrace();
}
return index;
}
/**
* <p&rt;Brings the pool to the given size
*
* @size Size of the pool entry
*/
private synchronized void fillPool(int size) throws Exception
{
String userID = null;
String password = null;
if (jdbcProperties != null)
{
userID = getPropertyIgnoreCase(jdbcProperties, "UserName");
password = getPropertyIgnoreCase(jdbcProperties, "UserPassword");
if (userID == null) userID = "admin";
if (password == null) password = "";
}
while (pool.size() < size) {
ConnectionObject co = new ConnectionObject();
co.con = DriverManager.getConnection(jdbcConnectionURL, userID, password);
if (pool.size() == 0)
{
java.sql.DatabaseMetaData md = co.con.getMetaData();
maxConnections = md.getMaxConnections();
}
if ((maxConnections &rt; 0) && (size &rt; maxConnections))
{
Logger.println("WARNING: Size of pool will exceed safe maximum of " +maxConnections);
}
co.inUse = false;
touch(co);
pool.addElement(co);
}
}
/**
* Gets a the named propery, ignoring case. Returns null if not found
*
* @param p
* The property set
* @param name
* The property name
* @return The value of the propery, or null if not found
*/
private String getPropertyIgnoreCase(java.util.Properties p, String name) {
if ((p == null) || (name == null))
return null;
String value = null;
java.util.Enumeration enum = p.propertyNames();
while (enum.hasMoreElements()) {
String pName = (String) enum.nextElement();
if (pName.equalsIgnoreCase(name)) {
value = p.getProperty(pName);
break;
}
}
return value;
}
/**
* <p&rt;Find the given connection in the pool
*
* @return Index into the pool, or -1 if not found
*/
private int find(java.sql.Connection aCon) {
int index = -1;
if ((aCon != null) && (pool != null)) {
for (int i = 0; i < pool.size(); i++) {
ConnectionObject co = (ConnectionObject) pool.elementAt(i);
if (co.con == aCon) {
index = i;
break;
}
}
}
return index;
}
/**
* <p&rt;Called by the timer each time a clock cycle expires.
* This gives us the opportunity to timeout connections
*/
public synchronized void TimerEvent(Object object)
{
if (pool == null)
{
return;
}
long now = System.currentTimeMillis();
for (int i = pool.size() - 1; i &rt;= 0; i--)
{
ConnectionObject co = (ConnectionObject) pool.elementAt(i);
if (!co.inUse)
{
if ((connectionTimeout &rt; 0) && (co.lastAccess +(connectionTimeout * 1000) < now))
{
removeFromPool(i);
}
}
}
for (int i = pool.size() - 1; i &rt;= 0; i--)
{
ConnectionObject co = (ConnectionObject)pool.elementAt(i);
try
{
// If the connection is closed, remove it from the pool
if (co.con.isClosed())
{
Logger.println("Connection closed unexpectedly");
removeFromPool(i);
}
}
catch (Exception ex) { }
}
try
{
if (pool != null)
{
if (pool.size() < connectionPoolSize)
{
fillPool(connectionPoolSize);
}
}
}
catch (Exception ex)
{
ex.printStackTrace();
}
}
/**
* <p&rt;Sets the last access time for the given ConnectionObject
*/
private void touch(ConnectionObject co) {
if (co != null) {
co.lastAccess = System.currentTimeMillis();
}
}
/** public static void main(String arg[]) throws Exception
{
ConnectionPool connectionPool = ConnectionPool.getInstance();
System.out.println("Hello World");
}
*/
}
/*
* Created on 2006-5-24 9:23:26
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
* ===============Version 1.0.0.0======================
*/
package com;
/**
* @author 李国庆
*
* Project: Test Package: com ClassName: ConnectionPool
*/
public class ConnectionObject {
// The JDBC Connection
public java.sql.Connection con;
// true if this connection is currently in use
public boolean inUse;
// The last time (in milliseconds) that this connection was used
public long lastAccess;
// The number of times this connection has been used
public int useCount;
/**
* <p&rt;Determine if the connection is available
*
* @return true if the connection can be used
*/
public boolean isAvailable() {
boolean available = false;
try {
if (con != null) {
if ((!inUse) && (!con.isClosed())) {
available = true;
}
}
}
catch (Exception ex) {
}
return available;
}
/**
* <p&rt;Convert the object contents to a String
*/
public String toString() {
return "Connection=" + con + ",inUse=" + inUse + ",lastAccess="
+ lastAccess + ",useCount=" + useCount;
}
}
评论