在操作数据库连接的时候有些时候可能要要跟踪连接的生命周期,如要建立基于连接的临时表,要修改该连接中的某些连接参数(如时间的默认格式)。但是jdbc规范中没有这类规范，所以只能自己实现。
下面是通过修改commons-dbcp获得的功能.
@SuppressWarnings("unchecked")
public class BasicDataSourceExtendListenerImpl extends BasicDataSource {
private List<ListenerConfig> listeners;
// ------------------------------------------------------------- Properties
/**
* The default auto-commit state of connections created by this pool.
*/
protected boolean defaultAutoCommit = true;
public BasicDataSourceExtendListenerImpl(
}
public void setListeners(List<ListenerConfig> listeners){
this.listeners = listeners;
}
@Override
public synchronized boolean getDefaultAutoCommit() {
return this.defaultAutoCommit;
}
@Override
public synchronized void setDefaultAutoCommit(boolean defaultAutoCommit) {
this.defaultAutoCommit = defaultAutoCommit;
this.restartNeeded = true;
}
/**
* The default read-only state of connections created by this pool.
*/
protected Boolean defaultReadOnly = null;
@Override
public synchronized boolean getDefaultReadOnly() {
if (this.defaultReadOnly != null) {
return this.defaultReadOnly.booleanValue();
}
return false;
}
@Override
public synchronized void setDefaultReadOnly(boolean defaultReadOnly) {
this.defaultReadOnly = defaultReadOnly ? Boolean.TRUE : Boolean.FALSE;
this.restartNeeded = true;
}
/**
* The default TransactionIsolation state of connections created by this
* pool.
*/
protected int defaultTransactionIsolation = -1;
@Override
public synchronized int getDefaultTransactionIsolation() {
return this.defaultTransactionIsolation;
}
@Override
public synchronized void setDefaultTransactionIsolation(
int defaultTransactionIsolation) {
this.defaultTransactionIsolation = defaultTransactionIsolation;
this.restartNeeded = true;
}
/**
* The default "catalog" of connections created by this pool.
*/
protected String defaultCatalog = null;
@Override
public synchronized String getDefaultCatalog() {
return this.defaultCatalog;
}
@Override
public synchronized void setDefaultCatalog(String defaultCatalog) {
if ((defaultCatalog != null) && (defaultCatalog.trim().length() > 0)) {
this.defaultCatalog = defaultCatalog;
} else {
this.defaultCatalog = null;
}
this.restartNeeded = true;
}
/**
* The fully qualified Java class name of the JDBC driver to be used.
*/
protected String driverClassName = null;
@Override
public synchronized String getDriverClassName() {
return this.driverClassName;
}
@Override
public synchronized void setDriverClassName(String driverClassName) {
if ((driverClassName != null) && (driverClassName.trim().length() > 0)) {
this.driverClassName = driverClassName;
} else {
this.driverClassName = null;
}
this.restartNeeded = true;
}
/**
* The maximum number of active connections that can be allocated from this
* pool at the same time, or zero for no limit.
*/
protected int maxActive = GenericObjectPool.DEFAULT_MAX_ACTIVE;
@Override
public synchronized int getMaxActive() {
return this.maxActive;
}
@Override
public synchronized void setMaxActive(int maxActive) {
this.maxActive = maxActive;
if (connectionPool != null) {
connectionPool.setMaxActive(maxActive);
}
}
/**
* The maximum number of active connections that can remain idle in the
* pool, without extra ones being released, or zero for no limit.
*/
protected int maxIdle = GenericObjectPool.DEFAULT_MAX_IDLE;;
@Override
public synchronized int getMaxIdle() {
return this.maxIdle;
}
@Override
public synchronized void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
if (connectionPool != null) {
connectionPool.setMaxIdle(maxIdle);
}
}
/**
* The minimum number of active connections that can remain idle in the
* pool, without extra ones being created, or 0 to create none.
*/
protected int minIdle = GenericObjectPool.DEFAULT_MIN_IDLE;;
@Override
public synchronized int getMinIdle() {
return this.minIdle;
}
@Override
public synchronized void setMinIdle(int minIdle) {
this.minIdle = minIdle;
if (connectionPool != null) {
connectionPool.setMinIdle(minIdle);
}
}
/**
* The initial number of connections that are created when the pool is
* started.
*
* @since 1.2
*/
protected int initialSize = 0;
@Override
public synchronized int getInitialSize() {
return this.initialSize;
}
@Override
public synchronized void setInitialSize(int initialSize) {
this.initialSize = initialSize;
this.restartNeeded = true;
}
/**
* The maximum number of milliseconds that the pool will wait (when there
* are no available connections) for a connection to be returned before
* throwing an exception, or -1 to wait indefinitely.
*/
protected long maxWait = GenericObjectPool.DEFAULT_MAX_WAIT;
@Override
public synchronized long getMaxWait() {
return this.maxWait;
}
@Override
public synchronized void setMaxWait(long maxWait) {
this.maxWait = maxWait;
if (connectionPool != null) {
connectionPool.setMaxWait(maxWait);
}
}
/**
* Prepared statement pooling for this pool.
*/
protected boolean poolPreparedStatements = false;
/**
* Returns true if we are pooling statements.
*
* @return boolean
*/
@Override
public synchronized boolean isPoolPreparedStatements() {
return this.poolPreparedStatements;
}
/**
* Sets whether to pool statements or not.
*
* @param poolPreparedStatements pooling on or off
*/
@Override
public synchronized void setPoolPreparedStatements(boolean poolingStatements) {
this.poolPreparedStatements = poolingStatements;
this.restartNeeded = true;
}
/**
* The maximum number of open statements that can be allocated from the
* statement pool at the same time, or zero for no limit. Since a connection
* usually only uses one or two statements at a time, this is mostly used to
* help detect resource leaks.
*/
protected int maxOpenPreparedStatements = GenericKeyedObjectPool.DEFAULT_MAX_TOTAL;
@Override
public synchronized int getMaxOpenPreparedStatements() {
return this.maxOpenPreparedStatements;
}
@Override
public synchronized void setMaxOpenPreparedStatements(int maxOpenStatements) {
this.maxOpenPreparedStatements = maxOpenStatements;
this.restartNeeded = true;
}
/**
* The indication of whether objects will be validated before being borrowed
* from the pool. If the object fails to validate, it will be dropped from
* the pool, and we will attempt to borrow another.
*/
protected boolean testOnBorrow = true;
@Override
public synchronized boolean getTestOnBorrow() {
return this.testOnBorrow;
}
@Override
public synchronized void setTestOnBorrow(boolean testOnBorrow) {
this.testOnBorrow = testOnBorrow;
if (connectionPool != null) {
connectionPool.setTestOnBorrow(testOnBorrow);
}
}
/**
* The indication of whether objects will be validated before being returned
* to the pool.
*/
protected boolean testOnReturn = false;
@Override
public synchronized boolean getTestOnReturn() {
return this.testOnReturn;
}
@Override
public synchronized void setTestOnReturn(boolean testOnReturn) {
this.testOnReturn = testOnReturn;
if (connectionPool != null) {
connectionPool.setTestOnReturn(testOnReturn);
}
}
/**
* The number of milliseconds to sleep between runs of the idle object
* evictor thread. When non-positive, no idle object evictor thread will be
* run.
*/
protected long timeBetweenEvictionRunsMillis = GenericObjectPool.DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
@Override
public synchronized long getTimeBetweenEvictionRunsMillis() {
return this.timeBetweenEvictionRunsMillis;
}
@Override
public synchronized void setTimeBetweenEvictionRunsMillis(
long timeBetweenEvictionRunsMillis) {
this.timeBetweenEvictionRunsMillis = timeBetweenEvictionRunsMillis;
if (connectionPool != null) {
connectionPool
.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
}
}
/**
* The number of objects to examine during each run of the idle object
* evictor thread (if any).
*/
protected int numTestsPerEvictionRun = GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
@Override
public synchronized int getNumTestsPerEvictionRun() {
return this.numTestsPerEvictionRun;
}
@Override
public synchronized void setNumTestsPerEvictionRun(
int numTestsPerEvictionRun) {
this.numTestsPerEvictionRun = numTestsPerEvictionRun;
if (connectionPool != null) {
connectionPool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
}
}
/**
* The minimum amount of time an object may sit idle in the pool before it
* is eligable for eviction by the idle object evictor (if any).
*/
protected long minEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
@Override
public synchronized long getMinEvictableIdleTimeMillis() {
return this.minEvictableIdleTimeMillis;
}
@Override
public synchronized void setMinEvictableIdleTimeMillis(
long minEvictableIdleTimeMillis) {
this.minEvictableIdleTimeMillis = minEvictableIdleTimeMillis;
if (connectionPool != null) {
connectionPool
.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
}
}
/**
* The indication of whether objects will be validated by the idle object
* evictor (if any). If an object fails to validate, it will be dropped from
* the pool.
*/
protected boolean testWhileIdle = false;
@Override
public synchronized boolean getTestWhileIdle() {
return this.testWhileIdle;
}
@Override
public synchronized void setTestWhileIdle(boolean testWhileIdle) {
this.testWhileIdle = testWhileIdle;
if (connectionPool != null) {
connectionPool.setTestWhileIdle(testWhileIdle);
}
}
/**
* [Read Only] The current number of active connections that have been
* allocated from this data source.
*/
@Override
public synchronized int getNumActive() {
if (connectionPool != null) {
return connectionPool.getNumActive();
} else {
return 0;
}
}
/**
* [Read Only] The current number of idle connections that are waiting to be
* allocated from this data source.
*/
@Override
public synchronized int getNumIdle() {
if (connectionPool != null) {
return connectionPool.getNumIdle();
} else {
return 0;
}
}
/**
* The connection password to be passed to our JDBC driver to establish a
* connection.
*/
protected String password = null;
@Override
public synchronized String getPassword() {
return this.password;
}
@Override
public synchronized void setPassword(String password) {
this.password = password;
this.restartNeeded = true;
}
/**
* The connection URL to be passed to our JDBC driver to establish a
* connection.
*/
protected String url = null;
@Override
public synchronized String getUrl() {
return this.url;
}
@Override
public synchronized void setUrl(String url) {
this.url = url;
this.restartNeeded = true;
}
/**
* The connection username to be passed to our JDBC driver to establish a
* connection.
*/
protected String username = null;
@Override
public synchronized String getUsername() {
return this.username;
}
@Override
public synchronized void setUsername(String username) {
this.username = username;
this.restartNeeded = true;
}
/**
* The SQL query that will be used to validate connections from this pool
* before returning them to the caller. If specified, this query
* <strong>MUST</strong> be an SQL SELECT statement that returns at least
* one row.
*/
protected String validationQuery = null;
@Override
public synchronized String getValidationQuery() {
return this.validationQuery;
}
@Override
public synchronized void setValidationQuery(String validationQuery) {
if ((validationQuery != null) && (validationQuery.trim().length() > 0)) {
this.validationQuery = validationQuery;
} else {
this.validationQuery = null;
}
this.restartNeeded = true;
}
/**
* Controls access to the underlying connection
*/
private boolean accessToUnderlyingConnectionAllowed = false;
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
* @return true if access to the underlying is allowed, false otherwise.
*/
@Override
public synchronized boolean isAccessToUnderlyingConnectionAllowed() {
return this.accessToUnderlyingConnectionAllowed;
}
/**
* Sets the value of the accessToUnderlyingConnectionAllowed property. It
* controls if the PoolGuard allows access to the underlying connection.
* (Default: false)
*
* @param allow Access to the underlying connection is granted when true.
*/
@Override
public synchronized void setAccessToUnderlyingConnectionAllowed(
boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
this.restartNeeded = true;
}
// ----------------------------------------------------- Instance Variables
// TODO: review & make isRestartNeeded() public, restartNeeded protected
private boolean restartNeeded = false;
/**
* Returns whether or not a restart is needed.
*
* @return true if a restart is needed
*/
private synchronized boolean isRestartNeeded() {
return restartNeeded;
}
/**
* The object pool that internally manages our connections.
*/
protected GenericObjectPool connectionPool = null;
/**
* The connection properties that will be sent to our JDBC driver when
* establishing new connections. <strong>NOTE</strong> - The "user" and
* "password" properties will be passed explicitly, so they do not need to
* be included here.
*/
protected Properties connectionProperties = new Properties();
/**
* The data source we will use to manage connections. This object should be
* acquired <strong>ONLY</strong> by calls to the
* <code>createDataSource()</code> method.
*/
protected DataSource dataSource = null;
/**
* The PrintWriter to which log messages should be directed.
*/
protected PrintWriter logWriter = new PrintWriter(System.out);
// ----------------------------------------------------- DataSource Methods
/**
* Create (if necessary) and return a connection to the database.
*
* @exception SQLException if a database access error occurs
*/
@Override
public Connection getConnection() throws SQLException {
return createDataSource().getConnection();
}
/**
* Create (if necessary) and return a connection to the database.
*
* @param username Database user on whose behalf the Connection is being
* made
* @param password The database user's password
*
* @exception SQLException if a database access error occurs
*/
@Override
public Connection getConnection(String username, String password)
throws SQLException {
return createDataSource().getConnection(username, password);
}
/**
* Return the login timeout (in seconds) for connecting to the database.
*
* @exception SQLException if a database access error occurs
*/
@Override
public int getLoginTimeout() throws SQLException {
return createDataSource().getLoginTimeout();
}
/**
* Return the log writer being used by this data source.
*
* @exception SQLException if a database access error occurs
*/
@Override
public PrintWriter getLogWriter() throws SQLException {
return createDataSource().getLogWriter();
}
/**
* Set the login timeout (in seconds) for connecting to the database.
*
* @param loginTimeout The new login timeout, or zero for no timeout
*
* @exception SQLException if a database access error occurs
*/
@Override
public void setLoginTimeout(int loginTimeout) throws SQLException {
createDataSource().setLoginTimeout(loginTimeout);
}
/**
* Set the log writer being used by this data source.
*
* @param logWriter The new log writer
*
* @exception SQLException if a database access error occurs
*/
@Override
public void setLogWriter(PrintWriter logWriter) throws SQLException {
createDataSource().setLogWriter(logWriter);
this.logWriter = logWriter;
}
private AbandonedConfig abandonedConfig;
/**
* Flag to remove abandoned connections if they exceed the
* removeAbandonedTimout.
*
* Set to true or false, default false. If set to true a connection is
* considered abandoned and eligible for removal if it has been idle longer
* than the removeAbandonedTimeout. Setting this to true can recover db
* connections from poorly written applications which fail to close a
* connection.
*
* @deprecated
*/
@Override
public boolean getRemoveAbandoned() {
if (abandonedConfig != null) {
return abandonedConfig.getRemoveAbandoned();
}
return false;
}
/**
* @deprecated
* @param removeAbandoned
*/
public void setRemoveAbandoned(boolean removeAbandoned) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setRemoveAbandoned(removeAbandoned);
this.restartNeeded = true;
}
/**
* Timeout in seconds before an abandoned connection can be removed.
*
* Defaults to 300 seconds.
*
* @deprecated
*/
public int getRemoveAbandonedTimeout() {
if (abandonedConfig != null) {
return abandonedConfig.getRemoveAbandonedTimeout();
}
return 300;
}
/**
* @deprecated
* @param removeAbandonedTimeout
*/
public void setRemoveAbandonedTimeout(int removeAbandonedTimeout) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setRemoveAbandonedTimeout(removeAbandonedTimeout);
this.restartNeeded = true;
}
/**
* Flag to log stack traces for application code which abandoned a Statement
* or Connection.
*
* Defaults to false.
*
* Logging of abandoned Statements and Connections adds overhead for every
* Connection open or new Statement because a stack trace has to be
* generated.
*
* @deprecated
*/
public boolean getLogAbandoned() {
if (abandonedConfig != null) {
return abandonedConfig.getLogAbandoned();
}
return false;
}
/**
* @deprecated
* @param logAbandoned
*/
public void setLogAbandoned(boolean logAbandoned) {
if (abandonedConfig == null) {
abandonedConfig = new AbandonedConfig();
}
abandonedConfig.setLogAbandoned(logAbandoned);
this.restartNeeded = true;
}
// --------------------------------------------------------- Public Methods
/**
* Add a custom connection property to the set that will be passed to our
* JDBC driver. This <strong>MUST</strong> be called before the first
* connection is retrieved (along with all the other configuration property
* setters).
*
* @param name Name of the custom connection property
* @param value Value of the custom connection property
*/
@Override
public void addConnectionProperty(String name, String value) {
connectionProperties.put(name, value);
this.restartNeeded = true;
}
@Override
public void removeConnectionProperty(String name) {
connectionProperties.remove(name);
this.restartNeeded = true;
}
/**
* Close and release all connections that are currently stored in the
* connection pool associated with our data source.
*
* @exception SQLException if a database error occurs
*/
@Override
public synchronized void close() throws SQLException {
GenericObjectPool oldpool = connectionPool;
connectionPool = null;
dataSource = null;
try {
if (oldpool != null) {
oldpool.close();
}
} catch (SQLException e) {
throw e;
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new SQLNestedException("Cannot close connection pool", e);
}
}
// ------------------------------------------------------ Protected Methods
/**
* <p>
* Create (if necessary) and return the internal data source we are using to
* manage our connections.
* </p>
*
* <p>
* <strong>IMPLEMENTATION NOTE</strong> - It is tempting to use the "double
* checked locking" idiom in an attempt to avoid synchronizing on every
* single call to this method. However, this idiom fails to work correctly
* in the face of some optimizations that are legal for a JVM to perform.
* </p>
*
* @exception SQLException if the object pool cannot be created.
*/
@Override
protected synchronized DataSource createDataSource() throws SQLException {
// Return the pool if we have already created it
if (dataSource != null) {
return (dataSource);
}
// Load the JDBC driver class
if (driverClassName != null) {
try {
Class.forName(driverClassName);
} catch (Throwable t) {
String message = "Cannot load JDBC driver class '"
+ driverClassName + "'";
logWriter.println(message);
t.printStackTrace(logWriter);
throw new SQLNestedException(message, t);
}
}
// Create a JDBC driver instance
Driver driver = null;
try {
driver = DriverManager.getDriver(url);
} catch (Throwable t) {
String message = "Cannot create JDBC driver of class '"
+ (driverClassName != null ? driverClassName : "")
+ "' for connect URL '" + url + "'";
logWriter.println(message);
t.printStackTrace(logWriter);
throw new SQLNestedException(message, t);
}
// Can't test without a validationQuery
if (validationQuery == null) {
setTestOnBorrow(false);
setTestOnReturn(false);
setTestWhileIdle(false);
}
// Create an object pool to contain our active connections
if ((abandonedConfig != null)
&& (abandonedConfig.getRemoveAbandoned() == true)) {
connectionPool = new AbandonedObjectPool(null, abandonedConfig);
} else {
connectionPool = new GenericObjectPool();
}
connectionPool.setMaxActive(maxActive);
connectionPool.setMaxIdle(maxIdle);
connectionPool.setMinIdle(minIdle);
connectionPool.setMaxWait(maxWait);
connectionPool.setTestOnBorrow(testOnBorrow);
connectionPool.setTestOnReturn(testOnReturn);
connectionPool
.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
connectionPool.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
connectionPool
.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
connectionPool.setTestWhileIdle(testWhileIdle);
// Set up statement pool, if desired
GenericKeyedObjectPoolFactory statementPoolFactory = null;
if (isPoolPreparedStatements()) {
statementPoolFactory = new GenericKeyedObjectPoolFactory(null, -1, // unlimited
// maxActive
// (per
// key)
GenericKeyedObjectPool.WHEN_EXHAUSTED_FAIL, 0, // maxWait
1, // maxIdle (per key)
maxOpenPreparedStatements);
}
// Set up the driver connection factory we will use
if (username != null) {
connectionProperties.put("user", username);
} else {
log("DBCP DataSource configured without a 'username'");
}
if (password != null) {
connectionProperties.put("password", password);
} else {
log("DBCP DataSource configured without a 'password'");
}
DriverConnectionFactory driverConnectionFactory = new DriverConnectionFactoryExtendListeerImpl(
listeners, driver, url, connectionProperties);
// Set up the poolable connection factory we will use
PoolableConnectionFactory connectionFactory = null;
try {
connectionFactory = new PoolableConnectionFactory(
driverConnectionFactory, connectionPool,
statementPoolFactory, validationQuery, defaultReadOnly,
defaultAutoCommit, defaultTransactionIsolation,
defaultCatalog, abandonedConfig);
if (connectionFactory == null) {
throw new SQLException(
"Cannot create PoolableConnectionFactory");
}
validateConnectionFactory(connectionFactory);
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new SQLNestedException(
"Cannot create PoolableConnectionFactory ("
+ e.getMessage() + ")", e);
}
// Create and return the pooling data source to manage the connections
dataSource = new PoolingDataSource(connectionPool);
((PoolingDataSource) dataSource)
.setAccessToUnderlyingConnectionAllowed(isAccessToUnderlyingConnectionAllowed());
dataSource.setLogWriter(logWriter);
try {
for (int i = 0; i < initialSize; i++) {
connectionPool.addObject();
}
} catch (Exception e) {
throw new SQLNestedException(
"Error preloading the connection pool", e);
}
return dataSource;
}
private static void validateConnectionFactory(
PoolableConnectionFactory connectionFactory) throws Exception {
Connection conn = null;
try {
conn = (Connection) connectionFactory.makeObject();
connectionFactory.activateObject(conn);
connectionFactory.validateConnection(conn);
connectionFactory.passivateObject(conn);
} finally {
connectionFactory.destroyObject(conn);
}
}
private void restart() {
try {
close();
} catch (SQLException e) {
log("Could not restart DataSource, cause: " + e.getMessage());
}
}
private void log(String message) {
if (logWriter != null) {
logWriter.println(message);
}
}
}
public class DriverConnectionFactoryExtendListeerImpl extends
DriverConnectionFactory {
private List<ListenerConfig> listeners;
public DriverConnectionFactoryTempTableImpl(List<ListenerConfig> listeners,
Driver driver, String connectUri, Properties props) {
super(driver, connectUri, props);
this.listeners = listeners;
}
@Override
public Connection createConnection() throws SQLException {
Connection connect = _driver.connect(_connectUri, _props);
System.out.println("获取数据库连接");
for (ListenerConfig config : listeners) {
try {
IConnectionListener listenerImpl = (IConnectionListener) Class
.forName(config.getClassName()).newInstance();
listenerImpl.createConnection(connect, config);
} catch (Throwable e) {
return null;
}
}
return connect;
}
}
public interface IConnectionListener {
void createConnection(Connection con, ListenerConfig config)
throws SQLException;
}
public class ListenerConfig {
private Map<String, String> attributes = new HashMap<String, String>();
private String className;
@SuppressWarnings("unchecked")
public ListenerConfig(Element listenerElement) {
className = listenerElement.elementText("class");
Iterator attributeElements = listenerElement
.elementIterator("attribute");
while (attributeElements.hasNext()) {
Element attributeElement = (Element) attributeElements.next();
attributes.put(attributeElement.elementText("name"),
attributeElement.elementText("value"));
}
}
public void setAttribute(String name, String value) {
attributes.put(name, value);
}
public String getAttribute(String name) {
return attributes.get(name);
}
public Set<String> getAttributeNames() {
return attributes.keySet();
}
public String getClassName() {
return className;
}
}
使用的时候根据实际情况将Listener传进BasicDataSourceExtendListenerImpl，或者在初始化BasicDataSourceExtendListenerImpl时直接读取。
扫一扫
3244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
