erik/SimplePool
erik/SimplePool
1
0
Fork 0
Code Issues Pull requests Releases Activity

Initial checkin.

Browse source
This commit is contained in:
Erik C. Thauvin 2004-03-28 02:05:00 +00:00
parent 7e5f191232
commit d5b0a2f3b7
32 changed files with 4320 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

571
src/net/java/dev/simplepool/SimplePool.java Normal file
View file

@ -0,0 +1,571 @@
/*
* $Source: /zpool01/javanet/scm/svn/tmp/cvs2svn/simplepool/src/net/java/dev/simplepool/SimplePool.java,v $
* $Revision: 1.1 $
* $Date: 2004-03-28 02:04:57 $
*
* Copyright (c) 2002, Marc A. Mnich (http://www.javaexchange.com/)
* All rights reserved.
*
* Copyright (c) 2004, Russell Beattie (http://www.russellbeattie.com/)
* All rights reserved.
*
* Copyright (c) 2004, Erik C. Thauvin (http://www.thauvin.net/erik/)
* All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License, please see:
*
* http://www.javaexchange.com/GPL.html
*/
package net.java.dev.simplepool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.IOException;
import java.sql.*;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* Creates and manages a pool of database connections.
*
* @author <a href="http://www.javaexchange.com/">Marc A. Mnich</a>
* @author <a href="http://www.russellbeattie.com/">Russell Beattie</a>
* @author <a href="http://www.thauvin.net/erik/">Erik C. Thauvin</a>
* @version $Revision: 1.1 $, $Date: 2004-03-28 02:04:57 $
* @since 1.0
*/
public class SimplePool implements Runnable {
private static final Log log = LogFactory.getLog(SimplePool.class);
private Thread runner;
private Connection[] connPool;
private int[] connStatus;
private long[] connLockTime;
private long[] connCreateDate;
private String[] connID;
private String driver;
private String jdbcUrl;
private String user;
private String password;
private int currConnections;
private int connLast;
private int maxConns;
private int maxConnMSec;
private int maxCheckoutSeconds = 60;
//available: set to false on destroy, checked by getConnection()
private boolean available = true;
private SQLWarning currSQLWarning;
/**
* Creates a new Connection Pool.
*
* @param driver JDBC driver. e.g. 'oracle.jdbc.driver.OracleDriver'
* @param jdbcUrl JDBC connect string. e.g. 'jdbc:oracle:thin:@203.92.21.109:1526:orcl'
* @param user Database login name. e.g. 'Scott'
* @param password Database password. e.g. 'Tiger'
* @param minConns Minimum number of connections to start with.
* @param maxConns Maximum number of connections in dynamic pool.
* @param maxConnTime Time in days between connection resets. (Reset does a basic cleanup)
* @param maxCheckoutSeconds Max time a connection can be checked out before being recycled. Zero value turns option
* off, default is 60 seconds.
*
* @throws IOException If the pool cannot be created.
*/
public SimplePool(String driver, String jdbcUrl, String user, String password, int minConns, int maxConns,
double maxConnTime, int maxCheckoutSeconds)
throws IOException {
this.connPool = new Connection[maxConns];
this.connStatus = new int[maxConns];
this.connLockTime = new long[maxConns];
this.connCreateDate = new long[maxConns];
this.connID = new String[maxConns];
this.currConnections = minConns;
this.maxConns = maxConns;
this.driver = driver;
this.jdbcUrl = jdbcUrl;
this.user = user;
this.password = password;
this.maxCheckoutSeconds = maxCheckoutSeconds;
this.maxConnMSec = (int) (maxConnTime * 86400000.0); //86400 sec/day
if (this.maxConnMSec < 30000) { // Recycle no less than 30 seconds.
this.maxConnMSec = 30000;
}
log.info("-----------------------------------------");
log.info("Starting Connection Pool:");
log.info("driver = " + driver);
log.info("jdbcUrl = " + jdbcUrl);
log.info("user = " + user);
log.info("minconnections = " + minConns);
log.info("maxconnections = " + maxConns);
log.info("Total refresh interval = " + maxConnTime + " days");
log.info("maxCheckoutSeconds = " + maxCheckoutSeconds);
log.info("-----------------------------------------");
// Initialize the pool of connections with the mininum connections:
// Problems creating connections may be caused during reboot when the
// servlet is started before the database is ready. Handle this
// by waiting and trying again. The loop allows 5 minutes for
// db reboot.
boolean connectionsSucceeded = false;
int dbLoop = 20;
try {
for (int i = 1; i < dbLoop; i++) {
try {
for (int j = 0; j < currConnections; j++) {
createConn(j);
}
connectionsSucceeded = true;
break;
} catch (SQLException e) {
log.error("Attempt (" + String.valueOf(i) + " of " + String.valueOf(dbLoop) +
") failed to create new connections set at startup.", e);
log.warn("Will try again in 15 seconds...");
try {
Thread.sleep(15000L);
} catch (InterruptedException ignore) {
;
}
}
}
if (!connectionsSucceeded) { // All attempts at connecting to db exhausted
throw new IOException("All attempts at connecting to Database exhausted.");
}
} catch (Exception e) {
log.fatal(e.getMessage(), e);
throw new IOException(e.getMessage());
}
// Fire up the background housekeeping thread
runner = new Thread(this);
runner.start();
}
/**
* Housekeeping thread. Runs in the background with low CPU overhead. Connections are checked for warnings and
* closure and are periodically restarted.
* <p/>
* This thread is a catchall for corrupted connections and prevents the buildup of open cursors. (Open cursors
* result when the application fails to close a Statement).
* <p/>
* This method acts as fault tolerance for bad connection/statement programming.
*/
public void run() {
boolean forever = true;
Statement stmt = null;
long maxCheckoutMillis = (long) (maxCheckoutSeconds * 1000);
while (forever) {
// Get any Warnings on connections and print to event file
for (int i = 0; i < currConnections; i++) {
try {
currSQLWarning = connPool[i].getWarnings();
if (currSQLWarning != null) {
log.debug("Warnings on connection [" + String.valueOf(i) + "]: " + currSQLWarning);
connPool[i].clearWarnings();
}
} catch (SQLException e) {
log.debug("Cannot access connection [" + String.valueOf(i) + "] warnings.", e);
}
}
for (int i = 0; i < currConnections; i++) { // Do for each connection
long age = System.currentTimeMillis() - connCreateDate[i];
try { // Test the connection with createStatement call
synchronized (connStatus) {
if (connStatus[i] > 0) { // In use, catch it next time!
// Check the time it's been checked out and recycle
long timeInUse = System.currentTimeMillis() - connLockTime[i];
log.warn("Connection [" + i + "] in use for " + timeInUse + " ms.");
if (maxCheckoutMillis != 0) {
if (timeInUse > maxCheckoutMillis) {
log.warn("Connection [" + i + "] failed to be returned in time. Recycling...");
throw new SQLException();
}
}
continue;
}
connStatus[i] = 2; // Take offline (2 indicates housekeeping lock)
}
if (age > maxConnMSec) { // Force a reset at the max conn time
throw new SQLException();
}
stmt = connPool[i].createStatement();
connStatus[i] = 0; // Connection is O.K.
log.trace("Connection [" + String.valueOf(i) + "] confirmed.");
// Some DBs return an object even if DB is shut down
if (connPool[i].isClosed()) {
throw new SQLException();
}
// Connection has a problem, restart it
} catch (SQLException e) {
log.debug("Recycling connection [" + String.valueOf(i) + ']');
try {
connPool[i].close();
} catch (SQLException e0) {
log.warn("Can't close connection [" + String.valueOf(i) +
"]. Might have been closed already. Trying to recycle anyway...", e);
}
try {
createConn(i);
} catch (SQLException e1) {
log.warn("Failed to create connection [" + String.valueOf(i) + ']', e1);
connStatus[i] = 0; // Can't open, try again next time
}
} finally {
try {
if (stmt != null) {
stmt.close();
}
} catch (SQLException ignore) {
;
}
}
}
try {
Thread.sleep(20000L);
} // Wait 20 seconds for next cycle
catch (InterruptedException e) {
// Returning from the run method sets the internal
// flag referenced by Thread.isAlive() to false.
// This is required because we don't use stop() to
// shutdown this thread.
return;
}
}
} // End run
/**
* This method hands out the connections in round-robin order. This prevents a faulty connection from locking up an
* application entirely. A browser 'refresh' will get the next connection while the faulty connection is cleaned up
* by the housekeeping thread.
* <p/>
* If the min number of threads are ever exhausted, new threads are added up the the max thread count. Finally, if
* all threads are in use, this method waits 2 seconds and tries again, up to ten times. After that, it returns a
* null.
*
* @return A connection from the pool.
*/
public Connection getConnection() {
Connection conn = null;
if (available) {
boolean gotOne = false;
for (int outerloop = 1; outerloop <= 10; outerloop++) {
try {
int loop = 0;
int roundRobin = connLast + 1;
if (roundRobin >= currConnections) {
roundRobin = 0;
}
do {
synchronized (connStatus) {
if ((connStatus[roundRobin] < 1) && (!connPool[roundRobin].isClosed())) {
conn = connPool[roundRobin];
connStatus[roundRobin] = 1;
connLockTime[roundRobin] = System.currentTimeMillis();
connLast = roundRobin;
gotOne = true;
break;
} else {
loop++;
roundRobin++;
if (roundRobin >= currConnections) {
roundRobin = 0;
}
}
}
} while ((!gotOne) && (loop < currConnections));
} catch (SQLException e1) {
log.debug(e1.getMessage(), e1);
}
if (gotOne) {
break;
} else {
synchronized (this) { // Add new connections to the pool
if (currConnections < maxConns) {
try {
createConn(currConnections);
currConnections++;
} catch (SQLException e) {
log.error("Unable to create new connection.", e);
}
}
}
try {
Thread.sleep(2000L);
} catch (InterruptedException ignore) {
;
}
log.debug("Connections Exhausted. Will wait and try again in loop " + String.valueOf(outerloop));
}
} // End of try 10 times loop
} else {
log.debug("Unsuccessful getConnection() request during destroy()");
} // End if(available)
log.debug("Handing out connection [" + idOfConnection(conn) + "]: " +
(new SimpleDateFormat("MM/dd/yyyy hh:mm:ss a")).format(new Date()));
return conn;
}
/**
* Returns the local JDBC ID for a connection.
*
* @param conn The connection object.
*
* @return The local JDBC ID for the connection.
*/
public int idOfConnection(Connection conn) {
int match = -1;
String tag;
try {
tag = conn.toString();
} catch (NullPointerException e1) {
tag = "none";
}
for (int i = 0; i < currConnections; i++) {
if (connID[i].equals(tag)) {
match = i;
break;
}
}
return match;
}
/**
* Frees a connection. Replaces connection back into the main pool for reuse.
*
* @param conn The connection object.
*
* @return A status or empty string.
*/
public String freeConnection(Connection conn) {
String res = "";
int thisconn = idOfConnection(conn);
if (thisconn >= 0) {
connStatus[thisconn] = 0;
res = "freed " + conn.toString();
log.debug("Freed connection [" + String.valueOf(thisconn) + ']');
} else {
log.error("Could not free connection [" + String.valueOf(thisconn) + ']');
}
return res;
}
/**
* Returns the age of a connection -- the time since it was handed out to an application.
*
* @param conn The connection object.
*
* @return The age of the connection.
*/
public long getAge(Connection conn) { // Returns the age of the connection in millisec.
int thisconn = idOfConnection(conn);
return System.currentTimeMillis() - connLockTime[thisconn];
}
private void createConn(int i)
throws SQLException {
Date now = new Date();
try {
Class.forName(driver);
connPool[i] = DriverManager.getConnection
(jdbcUrl, user, password);
connStatus[i] = 0;
connID[i] = connPool[i].toString();
connLockTime[i] = 0L;
connCreateDate[i] = now.getTime();
} catch (ClassNotFoundException e2) {
log.debug("Error creating connection. The driver could not be loaded.", e2);
}
log.debug("Opening connection [" + String.valueOf(i) + "]: " + connPool[i].toString());
}
/**
* Shuts down the housekeeping thread and closes all connections in the pool. Call this method from the destroy()
* method of the servlet.
* <p/>
* Multi-phase shutdown having following sequence:
* </p>
* <ol>
* <li><code>getConnection()</code> will refuse to return connections.</li>
* <li>The housekeeping thread is shut down.<br>
* Up to the time of <code>millis</code> milliseconds after shutdown of the housekeeping thread,
* <code>freeConnection()</code> can still be called to return used connections.<br>
* After <code>millis</code> milliseconds after the shutdown of the housekeeping thread, all connections in the pool
* are closed.</li>
* <li>If any connections were in use while being closed then a <code>SQLException</code> is thrown.</li>
* <li>The log is closed.</li>
* </ol>
* <p/>
* Call this method from a servlet destroy() method.
*
* @param millis the time to wait in milliseconds.
*
* @throws SQLException if connections were in use after <code>millis</code>.
*/
public void destroy(int millis) throws SQLException {
log.info("Shutting down SimplePool.");
// Checking for invalid negative arguments is not necessary,
// Thread.join() does this already in runner.join().
// Stop issuing connections
available = false;
// Shut down the background housekeeping thread
runner.interrupt();
// Wait until the housekeeping thread has died.
try {
runner.join((long) millis);
} catch (InterruptedException ignore) {
;
}
// The housekeeping thread could still be running
// (e.g. if millis is too small). This case is ignored.
// At worst, this method will throw an exception with the
// clear indication that the timeout was too short.
long startTime = System.currentTimeMillis();
// Wait for freeConnection() to return any connections
// that are still used at this time.
int useCount;
while ((useCount = getUseCount()) > 0 && System.currentTimeMillis() - startTime <= millis) {
try {
Thread.sleep(500L);
} catch (InterruptedException ignore) {
;
}
}
// Close all connections, whether safe or not
for (int i = 0; i < currConnections; i++) {
try {
connPool[i].close();
} catch (SQLException e1) {
log.debug("Cannot close connections on Destroy.");
}
}
if (useCount > 0) {
//bt-test successful
String msg = "Unsafe shutdown: Had to close " + useCount + " active DB connections after " + millis +
"ms.";
log.error(msg);
// Throwing following Exception is essential because servlet authors
// are likely to have their own error logging requirements.
throw new SQLException(msg);
}
}//End destroy()
/**
* Less safe shutdown. Uses default timeout value.
* <p/>
* This method simply calls the <code>destroy()</code> method with a <code>millis</code> value of 10000 (10 seconds)
* and ignores <code>SQLException</code> thrown by that method.
*
* @see #destroy(int)
*/
public void destroy() {
try {
destroy(10000);
} catch (SQLException e) {
;
}
}
/**
* Returns the number of connections in use.
* <p/>
* This method could be reduced to return a counter that is maintained by all methods that update connStatus.
* However, it is more efficient to do it this way because: Updating the counter would put an additional burden on
* the most frequently used methods; in comparison, this method is rarely used (although essential).
*
* @return The number of connections in use.
*/
public int getUseCount() {
int useCount = 0;
synchronized (connStatus) {
for (int i = 0; i < currConnections; i++) {
if (connStatus[i] > 0) { // In use
useCount++;
}
}
}
return useCount;
}//End getUseCount()
/**
* Returns the number of connections in the dynamic pool.
*
* @return The number of connections in the pool.
*/
public int getSize() {
return currConnections;
}//End getSize()
}// End class

357
src/net/java/dev/simplepool/SimplePoolConnection.java Normal file
View file

@ -0,0 +1,357 @@
/*
* $Source: /zpool01/javanet/scm/svn/tmp/cvs2svn/simplepool/src/net/java/dev/simplepool/SimplePoolConnection.java,v $
* $Revision: 1.1 $
* $Date: 2004-03-28 02:04:57 $
*
* Copyright (c) 2004, Russell Beattie (http://www.russellbeattie.com/)
* All rights reserved.
*
* Copyright (c) 2004, Erik C. Thauvin (http://www.thauvin.net/erik/)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the authors nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.java.dev.simplepool;
import java.sql.*;
import java.util.Map;
/**
* Basic implementation of {@link java.sql.Connection}.
*
* @author <a href="http://www.russellbeattie.com/">Russell Beattie</a>
* @author <a href="http://www.thauvin.net/erik/">Erik C. Thauvin</a>
* @version $Revision: 1.1 $, $Date: 2004-03-28 02:04:57 $
* @since 1.0
*/
public class SimplePoolConnection implements Connection {
private Connection conn;
private SimplePool pool;
/**
* Creates a new SimplePoolConnection object.
*
* @param pool The connection pool.
*/
public SimplePoolConnection(SimplePool pool) {
this.pool = pool;
conn = pool.getConnection();
}
/**
* See {@link java.sql.Connection#setAutoCommit(boolean)}.
*/
public void setAutoCommit(boolean autoCommit)
throws SQLException {
conn.setAutoCommit(autoCommit);
}
/**
* See {@link java.sql.Connection#getAutoCommit}.
*/
public boolean getAutoCommit()
throws SQLException {
return conn.getAutoCommit();
}
/**
* See {@link java.sql.Connection#setCatalog(String)}.
*/
public void setCatalog(String catalog)
throws SQLException {
conn.setCatalog(catalog);
}
/**
* See {@link java.sql.Connection#getCatalog()}.
*/
public String getCatalog()
throws SQLException {
return conn.getCatalog();
}
/**
* See {@link java.sql.Connection#isClosed}.
*/
public boolean isClosed()
throws SQLException {
return conn.isClosed();
}
/**
* See {@link java.sql.Connection#setHoldability(int)}.
*/
public void setHoldability(int holdability)
throws SQLException {
conn.setHoldability(holdability);
}
/**
* See {@link java.sql.Connection#getHoldability}.
*/
public int getHoldability()
throws SQLException {
return conn.getHoldability();
}
/**
* See {@link java.sql.Connection#getMetaData}.
*/
public DatabaseMetaData getMetaData()
throws SQLException {
return conn.getMetaData();
}
/**
* See {@link java.sql.Connection#setReadOnly(boolean)}.
*/
public void setReadOnly(boolean readOnly)
throws SQLException {
conn.setReadOnly(readOnly);
}
/**
* See {@link java.sql.Connection#isReadOnly}.
*/
public boolean isReadOnly()
throws SQLException {
return conn.isReadOnly();
}
/**
* See {@link java.sql.Connection#setSavepoint}.
*/
public Savepoint setSavepoint()
throws SQLException {
return conn.setSavepoint();
}
/**
* See {@link java.sql.Connection#setSavepoint(String)}.
*/
public Savepoint setSavepoint(String savepoint)
throws SQLException {
return conn.setSavepoint(savepoint);
}
/**
* See {@link java.sql.Connection#setTransactionIsolation(int)}.
*/
public void setTransactionIsolation(int level)
throws SQLException {
conn.setTransactionIsolation(level);
}
/**
* See {@link java.sql.Connection#getTransactionIsolation}.
*/
public int getTransactionIsolation()
throws SQLException {
return conn.getTransactionIsolation();
}
/**
* See {@link java.sql.Connection#setTypeMap(Map)}.
*/
public void setTypeMap(Map map)
throws SQLException {
conn.setTypeMap(map);
}
/**
* See {@link java.sql.Connection#getTypeMap}.
*/
public Map getTypeMap()
throws SQLException {
return conn.getTypeMap();
}
/**
* See {@link java.sql.Connection#getWarnings}.
*/
public SQLWarning getWarnings()
throws SQLException {
return conn.getWarnings();
}
/**
* See {@link java.sql.Connection#clearWarnings}.
*/
public void clearWarnings()
throws SQLException {
conn.clearWarnings();
}
/**
* See {@link java.sql.Connection#close}.
*/
public void close()
throws SQLException {
pool.freeConnection(conn);
}
/**
* See {@link java.sql.Connection#commit}.
*/
public void commit()
throws SQLException {
conn.commit();
}
/**
* See {@link java.sql.Connection#createStatement}.
*/
public Statement createStatement()
throws SQLException {
return conn.createStatement();
}
/**
* See {@link java.sql.Connection#createStatement(int, int)}.
*/
public Statement createStatement(int resultSetType, int resultSetConcurrency)
throws SQLException {
return conn.createStatement(resultSetType, resultSetConcurrency);
}
/**
* See {@link java.sql.Connection#createStatement(int, int, int)}.
*/
public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
return conn.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
* See {@link java.sql.Connection#nativeSQL(String)}.
*/
public String nativeSQL(String sql)
throws SQLException {
return conn.nativeSQL(sql);
}
/**
* See {@link java.sql.Connection#prepareCall(String)}.
*/
public CallableStatement prepareCall(String sql)
throws SQLException {
return conn.prepareCall(sql);
}
/**
* See {@link java.sql.Connection#prepareCall(String, int, int)}.
*/
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency)
throws SQLException {
return conn.prepareCall(sql, resultSetType, resultSetConcurrency);
}
/**
* See {@link java.sql.Connection#prepareCall(String, int, int, int)}.
*/
public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency,
int resultSetHoldability)
throws SQLException {
return conn.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
* See {@link java.sql.Connection#prepareStatement(String)}.
*/
public PreparedStatement prepareStatement(String sql)
throws SQLException {
return conn.prepareStatement(sql);
}
/**
* See {@link java.sql.Connection#prepareStatement(String)}.
*/
public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
throws SQLException {
return conn.prepareStatement(sql);
}
/**
* See {@link java.sql.Connection#prepareStatement(String, int, int)}.
*/
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency)
throws SQLException {
return conn.prepareStatement(sql, resultSetType, resultSetConcurrency);
}
/**
* See {@link java.sql.Connection#prepareStatement(String, int, int, int)}.
*/
public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency,
int resultSetHoldability)
throws SQLException {
return conn.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
* See {@link java.sql.Connection#prepareStatement(String, int[])}.
*/
public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
throws SQLException {
return conn.prepareStatement(sql, columnIndexes);
}
/**
* See {@link java.sql.Connection#prepareStatement(String, String[])}.
*/
public PreparedStatement prepareStatement(String sql, String[] columnNames)
throws SQLException {
return conn.prepareStatement(sql, columnNames);
}
/**
* See {@link java.sql.Connection#releaseSavepoint(Savepoint)}.
*/
public void releaseSavepoint(Savepoint savepoint)
throws SQLException {
conn.releaseSavepoint(savepoint);
}
/**
* See {@link java.sql.Connection#rollback}.
*/
public void rollback()
throws SQLException {
conn.rollback();
}
/**
* See {@link java.sql.Connection#rollback(Savepoint)}.
*/
public void rollback(Savepoint savepoint)
throws SQLException {
conn.rollback(savepoint);
}
}

319
src/net/java/dev/simplepool/SimplePoolDataSource.java Normal file
View file

@ -0,0 +1,319 @@
/*
* $Source: /zpool01/javanet/scm/svn/tmp/cvs2svn/simplepool/src/net/java/dev/simplepool/SimplePoolDataSource.java,v $
* $Revision: 1.1 $
* $Date: 2004-03-28 02:04:57 $
*
* Copyright (c) 2004, Russell Beattie (http://www.russellbeattie.com/)
* All rights reserved.
*
* Copyright (c) 2004, Erik C. Thauvin (http://www.thauvin.net/erik/)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the authors nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.java.dev.simplepool;
import javax.sql.DataSource;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
/**
* Basic implementation of {@link javax.sql.DataSource}.
*
* @author <a href="http://www.russellbeattie.com/">Russell Beattie</a>
* @author <a href="http://www.thauvin.net/erik/">Erik C. Thauvin</a>
* @version $Revision: 1.1 $, $Date: 2004-03-28 02:04:57 $
* @since 1.0
*/
public class SimplePoolDataSource implements DataSource {
private PrintWriter logWriter = new PrintWriter(System.out);
private SimplePool pool = null;
private String driver = "";
private String jdbcUrl = "";
private String user = "";
private String password = "";
private String minConns = "";
private String maxConns = "";
private String maxConnTime = "";
private String maxCheckoutSeconds = "";
/**
* Initializes the connection pool.
*
* @throws Exception if the pool could not be intialized.
*/
protected void init() throws Exception {
pool = new SimplePool(driver, jdbcUrl, user, password,
Integer.parseInt(minConns), Integer.parseInt(maxConns),
Double.parseDouble(maxConnTime), Integer.parseInt(maxCheckoutSeconds));
}
/**
* See {@link javax.sql.DataSource#getConnection()}.
*/
public Connection getConnection() throws SQLException {
if (pool == null) {
try {
init();
} catch (Exception e) {
throw new SQLException("Error initializing Connection Broker.");
}
}
return new SimplePoolConnection(pool);
}
/**
* See {@link javax.sql.DataSource#getConnection(String, String)}.
*/
public Connection getConnection(String username, String password)
throws SQLException {
throw new SQLException("Not supported in this DataSource.");
}
/**
* See {@link javax.sql.DataSource#setLogWriter(PrintWriter)}.
*/
public void setLogWriter(PrintWriter out) throws SQLException {
logWriter = out;
}
/**
* See {@link javax.sql.DataSource#getLogWriter}.
*/
public PrintWriter getLogWriter() {
return logWriter;
}
/**
* See {@link javax.sql.DataSource#setLoginTimeout(int)}.
*/
public void setLoginTimeout(int seconds) throws SQLException {
}
/**
* See {@link javax.sql.DataSource#getLoginTimeout}.
*/
public int getLoginTimeout() {
return 0;
}
/**
* Closes the connection pool.
*/
public void close() {
pool.destroy();
pool = null;
}
/**
* Sets the JDBC driver.
*
* @param driver The JDBC driver. e.g. 'com.mysql.jdbc.Driver'
*
* @see #getDriver()
*/
public void setDriver(String driver) {
this.driver = driver;
}
/**
* Gets the JDBC driver.
*
* @return The JDBC driver string.
*
* @see #setDriver(String)
*/
public String getDriver() {
return driver;
}
/**
* Sets the JDBC connect string.
*
* @param jdbcUrl The JDBC connection URL string. e.g. 'jdbc:mysql://localhost:3306/dbname'
*
* @see #getJdbcUrl()
*/
public void setJdbcUrl(String jdbcUrl) {
this.jdbcUrl = jdbcUrl;
}
/**
* Gets the JDBC connect string.
*
* @return The JDBC connection URL string.
*
* @see #setJdbcUrl(String)
*/
public String getJdbcUrl() {
return jdbcUrl;
}
/**
* Sets the database login name.
*
* @param user The database login name. e.g. 'Scott'
*
* @see #getUser()
*/
public void setUser(String user) {
this.user = user;
}
/**
* Gets the database login name.
*
* @return The login name string.
*
* @see #setUser(String)
*/
public String getUser() {
return user;
}
/**
* Sets the database password.
*
* @param password The database password. e.g. 'Tiger'
*
* @see #getPassword()
*/
public void setPassword(String password) {
this.password = password;
}
/**
* Gets the database password.
*
* @return The password string.
*
* @see #setPassword(String)
*/
public String getPassword() {
return password;
}
/**
* Sets the minimum number of connections to start with.
*
* @param minConns The minimum number of connections.
*
* @see #getMinConns()
*/
public void setMinConns(String minConns) {
this.minConns = minConns;
}
/**
* Gets the minimum number of connections to start with.
*
* @return The minimum number of connections string.
*
* @see #setMinConns(String)
*/
public String getMinConns() {
return minConns;
}
/**
* Sets the maximum number of connections in dynamic pool.
*
* @param maxConns The maximum number of connections.
*
* @see #getMaxConns()
*/
public void setMaxConns(String maxConns) {
this.maxConns = maxConns;
}
/**
* Gets the maximum number of connections in dynamic pool.
*
* @return The maximum number of connection string.
*
* @see #setMaxConns(String)
*/
public String getMaxConns() {
return maxConns;
}
/**
* Sets the time in days between connection resets.
*
* @param maxConnTime The maximum connection time.
*
* @see #getMaxConnTime()
*/
public void setMaxConnTime(String maxConnTime) {
this.maxConnTime = maxConnTime;
}
/**
* Gets the time in days between connection resets.
*
* @return The maximum connection time string.
*
* @see #setMaxConnTime(String)
*/
public String getMaxConnTime() {
return maxConnTime;
}
/**
* Sets the max time a connection can be checked out before being recycled.
*
* @param maxCheckoutSeconds The maximum number of seconds to wait before recycling a connection.
*
* @see #getMaxCheckoutSeconds()
*/
public void setMaxCheckoutSeconds(String maxCheckoutSeconds) {
this.maxCheckoutSeconds = maxCheckoutSeconds;
}
/**
* Gets the max time a connection can be checked out before being recycled.
*
* @return The maximum checkout time string.
*
* @see #setMaxCheckoutSeconds(String)
*/
public String getMaxCheckoutSeconds() {
return maxCheckoutSeconds;
}
}

141
src/net/java/dev/simplepool/SimplePoolDataSourceFactory.java Normal file
View file

@ -0,0 +1,141 @@
/*
* $Source: /zpool01/javanet/scm/svn/tmp/cvs2svn/simplepool/src/net/java/dev/simplepool/SimplePoolDataSourceFactory.java,v $
* $Revision: 1.1 $
* $Date: 2004-03-28 02:04:58 $
*
* Copyright (c) 2004, Russell Beattie (http://www.russellbeattie.com/)
* All rights reserved.
*
* Copyright (c) 2004, Erik C. Thauvin (http://www.thauvin.net/erik/)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the authors nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.java.dev.simplepool;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.Reference;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
/**
* JNDI object factory that creates an instance of {@link SimplePoolDataSource}.
*
* @author <a href="http://www.russellbeattie.com/">Russell Beattie</a>
* @author <a href="http://www.thauvin.net/erik/">Erik C. Thauvin</a>
* @version $Revision: 1.1 $, $Date: 2004-03-28 02:04:58 $
* @since 1.0
*/
public class SimplePoolDataSourceFactory implements ObjectFactory {
/**
* Creates a {@link SimplePoolDataSource} instance.
*
* @param obj The object containing location or reference information that is used in creating the
* <code>DataSource</code>.
* @param name The name of this object relative to <code>ctx</code>, or null if no name is specified.
* @param ctx The context relative to which the <code>name</code> parameter is specified, or null if
* <code>name</code> is relative to the default initial context.
* @param env The possibly null environment that is used in creating the <code>DataSource</code>.
*
* @return The <code>DataSource</code>; null if it cannot be created.
*
* @throws Exception if the factory encountered an exception while attempting to create the <code>DataSource</code>,
* and no other object factories are to be tried.
*/
public Object getObjectInstance(Object obj, Name name, Context ctx, Hashtable env)
throws Exception {
Reference ref = (Reference) obj;
SimplePoolDataSource dataSource = new SimplePoolDataSource();
/*
driver: JDBC driver. e.g. 'oracle.jdbc.driver.OracleDriver'<br>
jdbcUrl: JDBC connect string. e.g. 'jdbc:oracle:thin:@203.92.21.109:1526:orcl'<br>
user: Database login name. e.g. 'Scott'<br>
password: Database password. e.g. 'Tiger'<br>
minConns: Minimum number of connections to start with.<br>
maxConns: Maximum number of connections in dynamic pool.<br>
maxConnTime: Time in days between connection resets. (Reset does a basic cleanup)<br>
maxCheckoutSeconds: Max time a connection can be checked out before being recycled. Zero value turns option
off, default is 60 seconds.
*/
String driver = (String) ref.get("driver").getContent();
if (driver != null) {
dataSource.setDriver(driver);
}
String user = (String) ref.get("user").getContent();
if (user != null) {
dataSource.setUser(user);
}
String password = (String) ref.get("password").getContent();
if (password != null) {
dataSource.setPassword(password);
}
String jdbcUrl = (String) ref.get("jdbcUrl").getContent();
if (jdbcUrl != null) {
dataSource.setJdbcUrl(jdbcUrl);
}
String minConns = (String) ref.get("minConns").getContent();
if (minConns != null) {
dataSource.setMinConns(minConns);
}
String maxConns = (String) ref.get("maxConns").getContent();
if (maxConns != null) {
dataSource.setMaxConns(maxConns);
}
String maxConnTime = (String) ref.get("maxConnTime").getContent();
if (maxConnTime != null) {
dataSource.setMaxConnTime(maxConnTime);
}
String maxCheckoutSeconds = (String) ref.get("maxCheckoutSeconds").getContent();
if (maxCheckoutSeconds != null) {
dataSource.setMaxCheckoutSeconds(maxCheckoutSeconds);
}
dataSource.init();
return dataSource;
}
}

141
src/net/java/dev/simplepool/SimplePoolServlet.java Normal file
View file

@ -0,0 +1,141 @@
/*
* $Source: /zpool01/javanet/scm/svn/tmp/cvs2svn/simplepool/src/net/java/dev/simplepool/SimplePoolServlet.java,v $
* $Revision: 1.1 $
* $Date: 2004-03-28 02:04:58 $
*
* Copyright (c) 2004, Russell Beattie (http://www.russellbeattie.com/)
* All rights reserved.
*
* Copyright (c) 2004, Erik C. Thauvin (http://www.thauvin.net/erik/)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* Neither the name of the authors nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package net.java.dev.simplepool;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
/**
* Creates a pool of database connection based on the specific intialization parameters.
*
* @author <a href="http://www.russellbeattie.com/">Russell Beattie</a>
* @author <a href="http://www.thauvin.net/erik/">Erik C. Thauvin</a>
* @version $Revision: 1.1 $, $Date: 2004-03-28 02:04:58 $
* @since 1.0
*/
public class SimplePoolServlet extends HttpServlet {
private static final Log log = LogFactory.getLog(SimplePoolServlet.class);
private static SimplePoolDataSource dataSource;
/**
* Closes the connection pool.
*
* @see javax.servlet.http.HttpServlet#destroy
*/
public void destroy() {
if (dataSource != null) {
dataSource.close();
}
}
/**
* Initializes the connection pool.
* <p/>
* The required intialization parameters are:
* <p/>
* <ul>
* <li><code>varName</code> &ndash; Name of the variable used to hold a reference to the
* {@link SimplePoolDataSource}.</li>
* <li><code>driver</code> &ndash; JDBC driver. e.g. 'oracle.jdbc.driver.OracleDriver'</li>
* <li><code>jdbcUrl</code> &ndash; JDBC connect string. e.g. 'jdbc:oracle:thin:@203.92.21.109:1526:orcl'</li>
* <li><code>user</code> &ndash; Database login name. e.g. 'Scott'</li>
* <li><code>password</code> &ndash; Database password. e.g. 'Tiger'</li>
* <li><code>minConns</code> &ndash; Minimum number of connections to start with.</li>
* <li><code>maxConns</code> &ndash; Maximum number of connections in dynamic pool.</li>
* <li><code>maxConnTime</code> &ndash; Time in days between connection resets.</li>
* <li><code>maxCheckoutSeconds</code> &ndash; Max time a connection can be checked out before being recycled.</li>
* </ul>
*
* @see javax.servlet.http.HttpServlet#init(ServletConfig)
*/
public void init(ServletConfig servletConfig)
throws ServletException {
log.info("Initializing " + servletConfig.getServletName() + " Servlet");
String varName = servletConfig.getInitParameter("varName");
String driver = servletConfig.getInitParameter("driver");
String jdbcUrl = servletConfig.getInitParameter("jdbcUrl");
String user = servletConfig.getInitParameter("user");
String password = servletConfig.getInitParameter("password");
String minConns = servletConfig.getInitParameter("minConns");
String maxConns = servletConfig.getInitParameter("maxConns");
String maxConnTime = servletConfig.getInitParameter("maxConnTime");
String maxCheckoutSeconds = servletConfig.getInitParameter("maxCheckoutSeconds");
if (isValid(varName) && isValid(driver) && isValid(jdbcUrl) && (user != null) && (password != null)
&& isValid(minConns) && isValid(maxConns) && isValid(maxConnTime) && isValid(maxCheckoutSeconds)) {
dataSource = new SimplePoolDataSource();
dataSource.setDriver(driver);
dataSource.setJdbcUrl(jdbcUrl);
dataSource.setUser(user);
dataSource.setPassword(password);
dataSource.setMinConns(minConns);
dataSource.setMaxConns(maxConns);
dataSource.setMaxConnTime(maxConnTime);
dataSource.setMaxCheckoutSeconds(maxCheckoutSeconds);
try {
dataSource.init();
servletConfig.getServletContext().setAttribute(varName, dataSource);
} catch (Exception e) {
log.error("An error occurred while starting the connection pool.", e);
throw new ServletException("Error starting the connection pool.");
}
} else {
log.error("One or more intialization parameter is invalid or missing.");
throw new ServletException("Invalid or missing initialization parameter.");
}
}
private boolean isValid(String s) {
if ((s != null) && (s.length() > 0)) {
return true;
}
return false;
}
}

13
src/net/java/dev/simplepool/package.html Normal file
View file

@ -0,0 +1,13 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<title>SimplePool API</title>
</head>
<body>
This package contains a simple database connection pool implementation for web applications, specifically those using JSTL.
<p/>
The connection pool can be created, accessed and managed via JNDI or through the {@link net.java.dev.simplepool.SimplePoolServlet}.
@since 1.0
</body>
</html>