You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@tomcat.apache.org by ma...@apache.org on 2018/06/19 10:30:31 UTC
svn commit: r1833804 [11/16] - in /tomcat/tc8.5.x/trunk: ./
java/org/apache/tomcat/dbcp/dbcp2/
java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/
java/org/apache/tomcat/dbcp/dbcp2/datasources/ webapps/docs/
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingConnection.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingConnection.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingConnection.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingConnection.java Tue Jun 19 10:30:31 2018
@@ -31,58 +31,79 @@ import org.apache.tomcat.dbcp.pool2.impl
/**
* A {@link DelegatingConnection} that pools {@link PreparedStatement}s.
* <p>
- * The {@link #prepareStatement} and {@link #prepareCall} methods, rather than
- * creating a new PreparedStatement each time, may actually pull the statement
- * from a pool of unused statements.
- * The {@link PreparedStatement#close} method of the returned statement doesn't
- * actually close the statement, but rather returns it to the pool.
- * (See {@link PoolablePreparedStatement}, {@link PoolableCallableStatement}.)
- *
+ * The {@link #prepareStatement} and {@link #prepareCall} methods, rather than creating a new PreparedStatement each
+ * time, may actually pull the statement from a pool of unused statements. The {@link PreparedStatement#close} method of
+ * the returned statement doesn't actually close the statement, but rather returns it to the pool. (See
+ * {@link PoolablePreparedStatement}, {@link PoolableCallableStatement}.)
+ * </p>
*
* @see PoolablePreparedStatement
- * @author Rodney Waldhoff
- * @author Dirk Verbeeck
* @since 2.0
*/
public class PoolingConnection extends DelegatingConnection<Connection>
- implements KeyedPooledObjectFactory<PStmtKey,DelegatingPreparedStatement> {
+ implements KeyedPooledObjectFactory<PStmtKey, DelegatingPreparedStatement> {
/**
- * Pool of {@link PreparedStatement}s. and {@link CallableStatement}s
+ * Statement types.
+ *
+ * @since 2.0 protected enum.
+ * @since 2.4.0 public enum.
*/
- private KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> _pstmtPool = null;
+ public enum StatementType {
+
+ /**
+ * Callable statement.
+ */
+ CALLABLE_STATEMENT,
+
+ /**
+ * Prepared statement.
+ */
+ PREPARED_STATEMENT
+ }
+
+ /** Pool of {@link PreparedStatement}s. and {@link CallableStatement}s */
+ private KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> pstmtPool;
/**
* Constructor.
- * @param c the underlying {@link Connection}.
+ *
+ * @param connection
+ * the underlying {@link Connection}.
*/
- public PoolingConnection(final Connection c) {
- super(c);
+ public PoolingConnection(final Connection connection) {
+ super(connection);
}
-
- public void setStatementPool(
- final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> pool) {
- _pstmtPool = pool;
+ /**
+ * {@link KeyedPooledObjectFactory} method for activating pooled statements.
+ *
+ * @param key
+ * ignored
+ * @param pooledObject
+ * wrapped pooled statement to be activated
+ */
+ @Override
+ public void activateObject(final PStmtKey key, final PooledObject<DelegatingPreparedStatement> pooledObject)
+ throws Exception {
+ pooledObject.getObject().activate();
}
-
/**
- * Close and free all {@link PreparedStatement}s or
- * {@link CallableStatement}s from the pool, and close the underlying
- * connection.
+ * Closes and frees all {@link PreparedStatement}s or {@link CallableStatement}s from the pool, and close the
+ * underlying connection.
*/
@Override
public synchronized void close() throws SQLException {
try {
- if (null != _pstmtPool) {
- final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> oldpool = _pstmtPool;
- _pstmtPool = null;
+ if (null != pstmtPool) {
+ final KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> oldpool = pstmtPool;
+ pstmtPool = null;
try {
oldpool.close();
- } catch(final RuntimeException e) {
+ } catch (final RuntimeException e) {
throw e;
- } catch(final Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Cannot close connection", e);
}
}
@@ -96,348 +117,166 @@ public class PoolingConnection extends D
}
/**
- * Create or obtain a {@link PreparedStatement} from the pool.
- * @param sql the sql string used to define the PreparedStatement
- * @return a {@link PoolablePreparedStatement}
- */
- @Override
- public PreparedStatement prepareStatement(final String sql) throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql));
- } catch(final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(final RuntimeException e) {
- throw e;
- } catch(final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- @Override
- public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql, autoGeneratedKeys));
- }
- catch (final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- }
- catch (final RuntimeException e) {
- throw e;
- }
- catch (final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link PreparedStatement} from the pool.
- * @param sql the sql string used to define the PreparedStatement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @return a {@link PoolablePreparedStatement}
- * @throws SQLException An error occurred
- */
- @Override
- public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency) throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql,resultSetType,resultSetConcurrency));
- } catch(final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(final RuntimeException e) {
- throw e;
- } catch(final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link CallableStatement} from the pool.
- * @param sql the sql string used to define the CallableStatement
- * @return a {@link PoolableCallableStatement}
- * @throws SQLException An error occurred
- */
- @Override
- public CallableStatement prepareCall(final String sql) throws SQLException {
- try {
- return (CallableStatement) _pstmtPool.borrowObject(createKey(sql, StatementType.CALLABLE_STATEMENT));
- } catch (final NoSuchElementException e) {
- throw new SQLException("MaxOpenCallableStatements limit reached", e);
- } catch (final RuntimeException e) {
- throw e;
- } catch (final Exception e) {
- throw new SQLException("Borrow callableStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link CallableStatement} from the pool.
- * @param sql the sql string used to define the CallableStatement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @return a {@link PoolableCallableStatement}
- * @throws SQLException An error occurred
- */
- @Override
- public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency) throws SQLException {
- try {
- return (CallableStatement) _pstmtPool.borrowObject(createKey(sql, resultSetType,
- resultSetConcurrency, StatementType.CALLABLE_STATEMENT));
- } catch (final NoSuchElementException e) {
- throw new SQLException("MaxOpenCallableStatements limit reached", e);
- } catch (final RuntimeException e) {
- throw e;
- } catch (final Exception e) {
- throw new SQLException("Borrow callableStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link PreparedStatement} from the pool.
- * @param sql the sql string used to define the PreparedStatement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @param resultSetHoldability result set holdability
- * @return a {@link PoolablePreparedStatement}
- */
- @Override
- public PreparedStatement prepareStatement(final String sql, final int resultSetType,
- final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
- } catch(final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(final RuntimeException e) {
- throw e;
- } catch(final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link PreparedStatement} from the pool.
- * @param sql the sql string used to define the PreparedStatement
- * @param columnIndexes column indexes
- * @return a {@link PoolablePreparedStatement}
- */
- @Override
- public PreparedStatement prepareStatement(final String sql, final int columnIndexes[])
- throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql, columnIndexes));
- } catch(final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(final RuntimeException e) {
- throw e;
- } catch(final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link PreparedStatement} from the pool.
- * @param sql the sql string used to define the PreparedStatement
- * @param columnNames column names
- * @return a {@link PoolablePreparedStatement}
- */
- @Override
- public PreparedStatement prepareStatement(final String sql, final String columnNames[])
- throws SQLException {
- if (null == _pstmtPool) {
- throw new SQLException(
- "Statement pool is null - closed or invalid PoolingConnection.");
- }
- try {
- return _pstmtPool.borrowObject(createKey(sql, columnNames));
- } catch(final NoSuchElementException e) {
- throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(final RuntimeException e) {
- throw e;
- } catch(final Exception e) {
- throw new SQLException("Borrow prepareStatement from pool failed", e);
- }
- }
-
- /**
- * Create or obtain a {@link CallableStatement} from the pool.
- * @param sql the sql string used to define the CallableStatement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @param resultSetHoldability result set holdability
- * @return a {@link PoolableCallableStatement}
- * @throws SQLException if a {@link CallableStatement} cannot be obtained
- * from the pool
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
*/
- @Override
- public CallableStatement prepareCall(final String sql, final int resultSetType,
- final int resultSetConcurrency, final int resultSetHoldability) throws SQLException {
- try {
- return (CallableStatement) _pstmtPool.borrowObject(createKey(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability, StatementType.CALLABLE_STATEMENT));
- } catch (final NoSuchElementException e) {
- throw new SQLException("MaxOpenCallableStatements limit reached", e);
- } catch (final RuntimeException e) {
- throw e;
- } catch (final Exception e) {
- throw new SQLException("Borrow callableStatement from pool failed", e);
- }
- }
-
- protected PStmtKey createKey(final String sql, final int autoGeneratedKeys) {
+ protected PStmtKey createKey(final String sql) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, autoGeneratedKeys);
+ return new PStmtKey(normalizeSQL(sql), catalog);
}
- /**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @return the key
- */
- protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
+ protected PStmtKey createKey(final String sql, final int autoGeneratedKeys) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency);
+ return new PStmtKey(normalizeSQL(sql), catalog, autoGeneratedKeys);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @param stmtType statement type
- * @return the key
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param columnIndexes
+ * column indexes
*/
- protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency, final StatementType stmtType) {
+ protected PStmtKey createKey(final String sql, final int columnIndexes[]) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, stmtType);
+ return new PStmtKey(normalizeSQL(sql), catalog, columnIndexes);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @return the key
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
*/
- protected PStmtKey createKey(final String sql) {
+ protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog);
+ return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the SQL string used to define the statement
- * @param stmtType statement type
- * @return the key
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @param resultSetHoldability
+ * result set holdability
*/
- protected PStmtKey createKey(final String sql, final StatementType stmtType) {
+ protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, stmtType, null);
+ return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, resultSetHoldability);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @param resultSetHoldability result set holdability
- * @return a newly created key for the given arguments
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @param resultSetHoldability
+ * result set holdability
+ * @param stmtType
+ * statement type
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
- final int resultSetHoldability) {
+ final int resultSetHoldability, final StatementType stmtType) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, resultSetHoldability);
+ return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, resultSetHoldability,
+ stmtType);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param resultSetType result set type
- * @param resultSetConcurrency result set concurrency
- * @param resultSetHoldability result set holdability
- * @param stmtType statement type
- * @return a newly created key for the given arguments
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @param stmtType
+ * statement type
*/
protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency,
- final int resultSetHoldability, final StatementType stmtType) {
+ final StatementType stmtType) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, resultSetHoldability, stmtType);
+ return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, stmtType);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param columnIndexes column indexes
- * @return a newly created key for the given arguments
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param stmtType
+ * statement type
*/
- protected PStmtKey createKey(final String sql, final int columnIndexes[]) {
+ protected PStmtKey createKey(final String sql, final StatementType stmtType) {
String catalog = null;
try {
catalog = getCatalog();
} catch (final SQLException e) {
// Ignored
}
- return new PStmtKey(normalizeSQL(sql), catalog, columnIndexes);
+ return new PStmtKey(normalizeSQL(sql), catalog, stmtType, null);
}
/**
- * Create a PStmtKey for the given arguments.
- * @param sql the sql string used to define the statement
- * @param columnNames column names
- * @return a newly created key for the given arguments
+ * Creates a PStmtKey for the given arguments.
+ *
+ * @param sql
+ * the SQL string used to define the statement
+ * @param columnNames
+ * column names
*/
protected PStmtKey createKey(final String sql, final String columnNames[]) {
String catalog = null;
@@ -450,119 +289,327 @@ public class PoolingConnection extends D
}
/**
- * Normalize the given SQL statement, producing a
- * canonical form that is semantically equivalent to the original.
- * @param sql The SQL statement
- * @return the trimmed SQL statement
+ * {@link KeyedPooledObjectFactory} method for destroying PoolablePreparedStatements and PoolableCallableStatements.
+ * Closes the underlying statement.
+ *
+ * @param key
+ * ignored
+ * @param pooledObject
+ * the wrapped pooled statement to be destroyed.
*/
- protected String normalizeSQL(final String sql) {
- return sql.trim();
+ @Override
+ public void destroyObject(final PStmtKey key, final PooledObject<DelegatingPreparedStatement> pooledObject)
+ throws Exception {
+ pooledObject.getObject().getInnermostDelegate().close();
}
/**
- * {@link KeyedPooledObjectFactory} method for creating
- * {@link PoolablePreparedStatement}s or {@link PoolableCallableStatement}s.
- * The <code>stmtType</code> field in the key determines whether
- * a PoolablePreparedStatement or PoolableCallableStatement is created.
- *
- * @param key the key for the {@link PreparedStatement} to be created
- * @return the object
- * @throws Exception An error occurred
+ * {@link KeyedPooledObjectFactory} method for creating {@link PoolablePreparedStatement}s or
+ * {@link PoolableCallableStatement}s. The <code>stmtType</code> field in the key determines whether a
+ * PoolablePreparedStatement or PoolableCallableStatement is created.
+ *
+ * @param key
+ * the key for the {@link PreparedStatement} to be created
* @see #createKey(String, int, int, StatementType)
*/
+ @SuppressWarnings("resource")
@Override
- public PooledObject<DelegatingPreparedStatement> makeObject(final PStmtKey key)
- throws Exception {
- if(null == key) {
+ public PooledObject<DelegatingPreparedStatement> makeObject(final PStmtKey key) throws Exception {
+ if (null == key) {
throw new IllegalArgumentException("Prepared statement key is null or invalid.");
}
- if (key.getStmtType() == StatementType.PREPARED_STATEMENT ) {
+ if (key.getStmtType() == StatementType.PREPARED_STATEMENT) {
final PreparedStatement statement = (PreparedStatement) key.createStatement(getDelegate());
- @SuppressWarnings({"rawtypes", "unchecked"}) // Unable to find way to avoid this
- final
- PoolablePreparedStatement pps = new PoolablePreparedStatement(statement, key, _pstmtPool, this);
+ @SuppressWarnings({"rawtypes", "unchecked" }) // Unable to find way to avoid this
+ final PoolablePreparedStatement pps = new PoolablePreparedStatement(statement, key, pstmtPool, this);
return new DefaultPooledObject<DelegatingPreparedStatement>(pps);
}
final CallableStatement statement = (CallableStatement) key.createStatement(getDelegate());
- final PoolableCallableStatement pcs = new PoolableCallableStatement(statement, key, _pstmtPool, this);
+ final PoolableCallableStatement pcs = new PoolableCallableStatement(statement, key, pstmtPool, this);
return new DefaultPooledObject<DelegatingPreparedStatement>(pcs);
}
/**
- * {@link KeyedPooledObjectFactory} method for destroying
- * PoolablePreparedStatements and PoolableCallableStatements.
- * Closes the underlying statement.
+ * Normalizes the given SQL statement, producing a canonical form that is semantically equivalent to the original.
+ */
+ protected String normalizeSQL(final String sql) {
+ return sql.trim();
+ }
+
+ /**
+ * {@link KeyedPooledObjectFactory} method for passivating {@link PreparedStatement}s or {@link CallableStatement}s.
+ * Invokes {@link PreparedStatement#clearParameters}.
*
- * @param key ignored
- * @param p the wrapped pooled statement to be destroyed.
- * @throws Exception An error occurred
+ * @param key
+ * ignored
+ * @param pooledObject
+ * a wrapped {@link PreparedStatement}
*/
@Override
- public void destroyObject(final PStmtKey key,
- final PooledObject<DelegatingPreparedStatement> p)
+ public void passivateObject(final PStmtKey key, final PooledObject<DelegatingPreparedStatement> pooledObject)
throws Exception {
- p.getObject().getInnermostDelegate().close();
+ @SuppressWarnings("resource")
+ final DelegatingPreparedStatement dps = pooledObject.getObject();
+ dps.clearParameters();
+ dps.passivate();
}
/**
- * {@link KeyedPooledObjectFactory} method for validating
- * pooled statements. Currently always returns true.
+ * Creates or obtains a {@link CallableStatement} from the pool.
*
- * @param key ignored
- * @param p ignored
- * @return {@code true}
+ * @param sql
+ * the SQL string used to define the CallableStatement
+ * @return a {@link PoolableCallableStatement}
+ * @throws SQLException
+ * Wraps an underlying exception.
*/
@Override
- public boolean validateObject(final PStmtKey key,
- final PooledObject<DelegatingPreparedStatement> p) {
- return true;
+ public CallableStatement prepareCall(final String sql) throws SQLException {
+ try {
+ return (CallableStatement) pstmtPool.borrowObject(createKey(sql, StatementType.CALLABLE_STATEMENT));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenCallableStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow callableStatement from pool failed", e);
+ }
}
/**
- * {@link KeyedPooledObjectFactory} method for activating
- * pooled statements.
+ * Creates or obtains a {@link CallableStatement} from the pool.
*
- * @param key ignored
- * @param p wrapped pooled statement to be activated
- * @throws Exception An error occurred
+ * @param sql
+ * the SQL string used to define the CallableStatement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @return a {@link PoolableCallableStatement}
+ * @throws SQLException
+ * Wraps an underlying exception.
*/
@Override
- public void activateObject(final PStmtKey key,
- final PooledObject<DelegatingPreparedStatement> p) throws Exception {
- p.getObject().activate();
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
+ throws SQLException {
+ try {
+ return (CallableStatement) pstmtPool.borrowObject(
+ createKey(sql, resultSetType, resultSetConcurrency, StatementType.CALLABLE_STATEMENT));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenCallableStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow callableStatement from pool failed", e);
+ }
}
/**
- * {@link KeyedPooledObjectFactory} method for passivating
- * {@link PreparedStatement}s or {@link CallableStatement}s.
- * Invokes {@link PreparedStatement#clearParameters}.
+ * Creates or obtains a {@link CallableStatement} from the pool.
*
- * @param key ignored
- * @param p a wrapped {@link PreparedStatement}
- * @throws Exception An error occurred
+ * @param sql
+ * the SQL string used to define the CallableStatement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @param resultSetHoldability
+ * result set holdability
+ * @return a {@link PoolableCallableStatement}
+ * @throws SQLException
+ * Wraps an underlying exception.
*/
@Override
- public void passivateObject(final PStmtKey key,
- final PooledObject<DelegatingPreparedStatement> p) throws Exception {
- final DelegatingPreparedStatement dps = p.getObject();
- dps.clearParameters();
- dps.passivate();
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
+ try {
+ return (CallableStatement) pstmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency,
+ resultSetHoldability, StatementType.CALLABLE_STATEMENT));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenCallableStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow callableStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Creates or obtains a {@link PreparedStatement} from the pool.
+ *
+ * @param sql
+ * the SQL string used to define the PreparedStatement
+ * @return a {@link PoolablePreparedStatement}
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql) throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql, autoGeneratedKeys));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Creates or obtains a {@link PreparedStatement} from the pool.
+ *
+ * @param sql
+ * the SQL string used to define the PreparedStatement
+ * @param columnIndexes
+ * column indexes
+ * @return a {@link PoolablePreparedStatement}
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final int columnIndexes[]) throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql, columnIndexes));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Creates or obtains a {@link PreparedStatement} from the pool.
+ *
+ * @param sql
+ * the SQL string used to define the PreparedStatement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @return a {@link PoolablePreparedStatement}
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
+ throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Creates or obtains a {@link PreparedStatement} from the pool.
+ *
+ * @param sql
+ * the SQL string used to define the PreparedStatement
+ * @param resultSetType
+ * result set type
+ * @param resultSetConcurrency
+ * result set concurrency
+ * @param resultSetHoldability
+ * result set holdability
+ * @return a {@link PoolablePreparedStatement}
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Creates or obtains a {@link PreparedStatement} from the pool.
+ *
+ * @param sql
+ * the SQL string used to define the PreparedStatement
+ * @param columnNames
+ * column names
+ * @return a {@link PoolablePreparedStatement}
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final String columnNames[]) throws SQLException {
+ if (null == pstmtPool) {
+ throw new SQLException("Statement pool is null - closed or invalid PoolingConnection.");
+ }
+ try {
+ return pstmtPool.borrowObject(createKey(sql, columnNames));
+ } catch (final NoSuchElementException e) {
+ throw new SQLException("MaxOpenPreparedStatements limit reached", e);
+ } catch (final RuntimeException e) {
+ throw e;
+ } catch (final Exception e) {
+ throw new SQLException("Borrow prepareStatement from pool failed", e);
+ }
+ }
+
+ /**
+ * Sets the prepared statement pool.
+ *
+ * @param pool
+ * the prepared statement pool.
+ */
+ public void setStatementPool(final KeyedObjectPool<PStmtKey, DelegatingPreparedStatement> pool) {
+ pstmtPool = pool;
}
@Override
public String toString() {
- if (_pstmtPool != null ) {
- return "PoolingConnection: " + _pstmtPool.toString();
+ if (pstmtPool != null) {
+ return "PoolingConnection: " + pstmtPool.toString();
}
return "PoolingConnection: null";
}
/**
- * The possible statement types.
- * @since 2.0
+ * {@link KeyedPooledObjectFactory} method for validating pooled statements. Currently always returns true.
+ *
+ * @param key
+ * ignored
+ * @param pooledObject
+ * ignored
+ * @return {@code true}
*/
- protected enum StatementType {
- CALLABLE_STATEMENT,
- PREPARED_STATEMENT
+ @Override
+ public boolean validateObject(final PStmtKey key, final PooledObject<DelegatingPreparedStatement> pooledObject) {
+ return true;
}
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDataSource.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDataSource.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDataSource.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDataSource.java Tue Jun 19 10:30:31 2018
@@ -21,6 +21,7 @@ import java.sql.Connection;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.NoSuchElementException;
+import java.util.Objects;
import java.util.logging.Logger;
import javax.sql.DataSource;
@@ -31,15 +32,11 @@ import org.apache.tomcat.dbcp.pool2.Obje
import org.apache.tomcat.dbcp.pool2.impl.GenericObjectPool;
/**
- * A simple {@link DataSource} implementation that obtains
- * {@link Connection}s from the specified {@link ObjectPool}.
+ * A simple {@link DataSource} implementation that obtains {@link Connection}s from the specified {@link ObjectPool}.
*
- * @param <C> The connection type
+ * @param <C>
+ * The connection type
*
- * @author Rodney Waldhoff
- * @author Glenn L. Nielsen
- * @author James House
- * @author Dirk Verbeeck
* @since 2.0
*/
public class PoolingDataSource<C extends Connection> implements DataSource, AutoCloseable {
@@ -47,40 +44,43 @@ public class PoolingDataSource<C extends
private static final Log log = LogFactory.getLog(PoolingDataSource.class);
/** Controls access to the underlying connection */
- private boolean accessToUnderlyingConnectionAllowed = false;
+ private boolean accessToUnderlyingConnectionAllowed;
+ /**
+ * Constructs a new instance backed by the given connection pool.
+ *
+ * @param pool
+ * the given connection pool.
+ */
public PoolingDataSource(final ObjectPool<C> pool) {
- if (null == pool) {
- throw new NullPointerException("Pool must not be null.");
- }
- _pool = pool;
- // Verify that _pool's factory refers back to it. If not, log a warning and try to fix.
- if (_pool instanceof GenericObjectPool<?>) {
- final PoolableConnectionFactory pcf = (PoolableConnectionFactory) ((GenericObjectPool<?>) _pool).getFactory();
- if (pcf == null) {
- throw new NullPointerException("PoolableConnectionFactory must not be null.");
- }
- if (pcf.getPool() != _pool) {
+ Objects.requireNonNull(pool, "Pool must not be null.");
+ this.pool = pool;
+ // Verify that pool's factory refers back to it. If not, log a warning and try to fix.
+ if (this.pool instanceof GenericObjectPool<?>) {
+ final PoolableConnectionFactory pcf = (PoolableConnectionFactory) ((GenericObjectPool<?>) this.pool)
+ .getFactory();
+ Objects.requireNonNull(pcf, "PoolableConnectionFactory must not be null.");
+ if (pcf.getPool() != this.pool) {
log.warn(Utils.getMessage("poolingDataSource.factoryConfig"));
@SuppressWarnings("unchecked") // PCF must have a pool of PCs
- final
- ObjectPool<PoolableConnection> p = (ObjectPool<PoolableConnection>) _pool;
+ final ObjectPool<PoolableConnection> p = (ObjectPool<PoolableConnection>) this.pool;
pcf.setPool(p);
}
}
}
/**
- * Close and free all {@link Connection}s from the pool.
+ * Closes and free all {@link Connection}s from the pool.
+ *
* @since 2.1
*/
@Override
public void close() throws Exception {
try {
- _pool.close();
- } catch(final RuntimeException rte) {
+ pool.close();
+ } catch (final RuntimeException rte) {
throw new RuntimeException(Utils.getMessage("pool.close.fail"), rte);
- } catch(final Exception e) {
+ } catch (final Exception e) {
throw new SQLException(Utils.getMessage("pool.close.fail"), e);
}
}
@@ -95,11 +95,11 @@ public class PoolingDataSource<C extends
}
/**
- * Sets the value of the accessToUnderlyingConnectionAllowed property.
- * It controls if the PoolGuard allows access to the underlying connection.
- * (Default: false)
+ * 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.
+ * @param allow
+ * Access to the underlying connection is granted when true.
*/
public void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
@@ -122,38 +122,40 @@ public class PoolingDataSource<C extends
throw new SQLFeatureNotSupportedException();
}
- //--- DataSource methods -----------------------------------------
+ // --- DataSource methods -----------------------------------------
/**
- * Return a {@link java.sql.Connection} from my pool,
- * according to the contract specified by {@link ObjectPool#borrowObject}.
+ * Returns a {@link java.sql.Connection} from my pool, according to the contract specified by
+ * {@link ObjectPool#borrowObject}.
*/
@Override
public Connection getConnection() throws SQLException {
try {
- final C conn = _pool.borrowObject();
+ final C conn = pool.borrowObject();
if (conn == null) {
return null;
}
return new PoolGuardConnectionWrapper<>(conn);
- } catch(final SQLException e) {
+ } catch (final SQLException e) {
throw e;
- } catch(final NoSuchElementException e) {
+ } catch (final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error " + e.getMessage(), e);
- } catch(final RuntimeException e) {
+ } catch (final RuntimeException e) {
throw e;
- } catch(final InterruptedException e) {
+ } catch (final InterruptedException e) {
// Reset the interrupt status so it is visible to callers
Thread.currentThread().interrupt();
throw new SQLException("Cannot get a connection, general error", e);
- } catch(final Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Cannot get a connection, general error", e);
}
}
/**
* Throws {@link UnsupportedOperationException}
- * @throws UnsupportedOperationException This is unsupported
+ *
+ * @throws UnsupportedOperationException
+ * always thrown
*/
@Override
public Connection getConnection(final String uname, final String passwd) throws SQLException {
@@ -162,18 +164,20 @@ public class PoolingDataSource<C extends
/**
* Returns my log writer.
+ *
* @return my log writer
* @see DataSource#getLogWriter
*/
@Override
public PrintWriter getLogWriter() {
- return _logWriter;
+ return logWriter;
}
/**
* Throws {@link UnsupportedOperationException}.
- * @throws UnsupportedOperationException As this
- * implementation does not support this feature.
+ *
+ * @throws UnsupportedOperationException
+ * As this implementation does not support this feature.
*/
@Override
public int getLoginTimeout() {
@@ -182,8 +186,9 @@ public class PoolingDataSource<C extends
/**
* Throws {@link UnsupportedOperationException}.
- * @throws UnsupportedOperationException As this
- * implementation does not support this feature.
+ *
+ * @throws UnsupportedOperationException
+ * As this implementation does not support this feature.
*/
@Override
public void setLoginTimeout(final int seconds) {
@@ -192,29 +197,29 @@ public class PoolingDataSource<C extends
/**
* Sets my log writer.
+ *
* @see DataSource#setLogWriter
*/
@Override
public void setLogWriter(final PrintWriter out) {
- _logWriter = out;
+ logWriter = out;
}
/** My log writer. */
- private PrintWriter _logWriter = null;
+ private PrintWriter logWriter = null;
- private final ObjectPool<C> _pool;
+ private final ObjectPool<C> pool;
protected ObjectPool<C> getPool() {
- return _pool;
+ return pool;
}
/**
- * PoolGuardConnectionWrapper is a Connection wrapper that makes sure a
- * closed connection cannot be used anymore.
+ * PoolGuardConnectionWrapper is a Connection wrapper that makes sure a closed connection cannot be used anymore.
+ *
* @since 2.0
*/
- private class PoolGuardConnectionWrapper<D extends Connection>
- extends DelegatingConnection<D> {
+ private class PoolGuardConnectionWrapper<D extends Connection> extends DelegatingConnection<D> {
PoolGuardConnectionWrapper(final D delegate) {
super(delegate);
@@ -225,10 +230,7 @@ public class PoolingDataSource<C extends
*/
@Override
public D getDelegate() {
- if (isAccessToUnderlyingConnectionAllowed()) {
- return super.getDelegate();
- }
- return null;
+ return isAccessToUnderlyingConnectionAllowed() ? super.getDelegate() : null;
}
/**
@@ -236,10 +238,7 @@ public class PoolingDataSource<C extends
*/
@Override
public Connection getInnermostDelegate() {
- if (isAccessToUnderlyingConnectionAllowed()) {
- return super.getInnermostDelegate();
- }
- return null;
+ return isAccessToUnderlyingConnectionAllowed() ? super.getInnermostDelegate() : null;
}
@Override
@@ -252,10 +251,7 @@ public class PoolingDataSource<C extends
@Override
public boolean isClosed() throws SQLException {
- if (getDelegateInternal() == null) {
- return true;
- }
- return super.isClosed();
+ return getDelegateInternal() == null ? true : super.isClosed();
}
}
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDriver.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDriver.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDriver.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolingDriver.java Tue Jun 19 10:30:31 2018
@@ -30,107 +30,120 @@ import java.util.logging.Logger;
import org.apache.tomcat.dbcp.pool2.ObjectPool;
-
/**
- * A {@link Driver} implementation that obtains
- * {@link Connection}s from a registered
- * {@link ObjectPool}.
+ * A {@link Driver} implementation that obtains {@link Connection}s from a registered {@link ObjectPool}.
*
- * @author Rodney Waldhoff
- * @author Dirk Verbeeck
* @since 2.0
*/
public class PoolingDriver implements Driver {
- /**
- * Register myself with the {@link DriverManager}.
- */
+
+ /** Register myself with the {@link DriverManager}. */
static {
try {
DriverManager.registerDriver(new PoolingDriver());
- } catch(final Exception e) {
+ } catch (final Exception e) {
+ // ignore
}
}
- /**
- * The map of registered pools.
- */
- protected static final HashMap<String,ObjectPool<? extends Connection>> pools =
- new HashMap<>();
+ /** The map of registered pools. */
+ protected static final HashMap<String, ObjectPool<? extends Connection>> pools = new HashMap<>();
- /**
- * Controls access to the underlying connection
- */
+ /** Controls access to the underlying connection */
private final boolean accessToUnderlyingConnectionAllowed;
+ /**
+ * Constructs a new driver with <code>accessToUnderlyingConnectionAllowed</code> enabled.
+ */
public PoolingDriver() {
this(true);
}
/**
* For unit testing purposes.
- * @param accessToUnderlyingConnectionAllowed The new flag
*/
protected PoolingDriver(final boolean accessToUnderlyingConnectionAllowed) {
this.accessToUnderlyingConnectionAllowed = accessToUnderlyingConnectionAllowed;
}
-
/**
* Returns the value of the accessToUnderlyingConnectionAllowed property.
*
- * @return <code>true</code> if access to the underlying is allowed,
- * <code>false</code> otherwise.
+ * @return true if access to the underlying is allowed, false otherwise.
*/
protected boolean isAccessToUnderlyingConnectionAllowed() {
return accessToUnderlyingConnectionAllowed;
}
- public synchronized ObjectPool<? extends Connection> getConnectionPool(final String name)
- throws SQLException {
+ /**
+ * Gets the connection pool for the given name.
+ *
+ * @param name
+ * The pool name
+ * @return The pool
+ * @throws SQLException
+ * Thrown when the named pool is not registered.
+ */
+ public synchronized ObjectPool<? extends Connection> getConnectionPool(final String name) throws SQLException {
final ObjectPool<? extends Connection> pool = pools.get(name);
if (null == pool) {
- throw new SQLException("Pool not registered.");
+ throw new SQLException("Pool not registered: " + name);
}
return pool;
}
- public synchronized void registerPool(final String name,
- final ObjectPool<? extends Connection> pool) {
- pools.put(name,pool);
+ /**
+ * Registers a named pool.
+ *
+ * @param name
+ * The pool name.
+ * @param pool
+ * The pool.
+ */
+ public synchronized void registerPool(final String name, final ObjectPool<? extends Connection> pool) {
+ pools.put(name, pool);
}
+ /**
+ * Closes a named pool.
+ *
+ * @param name
+ * The pool name.
+ * @throws SQLException
+ * Thrown when a problem is caught closing the pool.
+ */
public synchronized void closePool(final String name) throws SQLException {
+ @SuppressWarnings("resource")
final ObjectPool<? extends Connection> pool = pools.get(name);
if (pool != null) {
pools.remove(name);
try {
pool.close();
- }
- catch (final Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Error closing pool " + name, e);
}
}
}
- public synchronized String[] getPoolNames(){
+ /**
+ * Gets the pool names.
+ *
+ * @return the pool names.
+ */
+ public synchronized String[] getPoolNames() {
final Set<String> names = pools.keySet();
return names.toArray(new String[names.size()]);
}
@Override
public boolean acceptsURL(final String url) throws SQLException {
- try {
- return url.startsWith(URL_PREFIX);
- } catch(final NullPointerException e) {
- return false;
- }
+ return url == null ? false : url.startsWith(URL_PREFIX);
}
@Override
public Connection connect(final String url, final Properties info) throws SQLException {
- if(acceptsURL(url)) {
- final ObjectPool<? extends Connection> pool =
- getConnectionPool(url.substring(URL_PREFIX_LEN));
+ if (acceptsURL(url)) {
+ final ObjectPool<? extends Connection> pool = getConnectionPool(url.substring(URL_PREFIX_LEN));
try {
final Connection conn = pool.borrowObject();
@@ -138,13 +151,13 @@ public class PoolingDriver implements Dr
return null;
}
return new PoolGuardConnectionWrapper(pool, conn);
- } catch(final SQLException e) {
+ } catch (final SQLException e) {
throw e;
- } catch(final NoSuchElementException e) {
+ } catch (final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error: " + e.getMessage(), e);
- } catch(final RuntimeException e) {
+ } catch (final RuntimeException e) {
throw e;
- } catch(final Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Cannot get a connection, general error: " + e.getMessage(), e);
}
}
@@ -159,24 +172,23 @@ public class PoolingDriver implements Dr
/**
* Invalidates the given connection.
*
- * @param conn connection to invalidate
- * @throws SQLException if the connection is not a
- * <code>PoolGuardConnectionWrapper</code> or an error occurs invalidating
- * the connection
+ * @param conn
+ * connection to invalidate
+ * @throws SQLException
+ * if the connection is not a <code>PoolGuardConnectionWrapper</code> or an error occurs invalidating
+ * the connection
*/
public void invalidateConnection(final Connection conn) throws SQLException {
if (conn instanceof PoolGuardConnectionWrapper) { // normal case
final PoolGuardConnectionWrapper pgconn = (PoolGuardConnectionWrapper) conn;
@SuppressWarnings("unchecked")
- final
- ObjectPool<Connection> pool = (ObjectPool<Connection>) pgconn.pool;
+ final ObjectPool<Connection> pool = (ObjectPool<Connection>) pgconn.pool;
try {
pool.invalidateObject(pgconn.getDelegateInternal());
+ } catch (final Exception e) {
+ // Ignore.
}
- catch (final Exception e) {
- }
- }
- else {
+ } else {
throw new SQLException("Invalid connection class");
}
}
@@ -202,7 +214,7 @@ public class PoolingDriver implements Dr
}
/** My URL prefix */
- protected static final String URL_PREFIX = "jdbc:apache:commons:dbcp:";
+ public static final String URL_PREFIX = "jdbc:apache:commons:dbcp:";
protected static final int URL_PREFIX_LEN = URL_PREFIX.length();
// version numbers
@@ -210,16 +222,15 @@ public class PoolingDriver implements Dr
protected static final int MINOR_VERSION = 0;
/**
- * PoolGuardConnectionWrapper is a Connection wrapper that makes sure a
- * closed connection cannot be used anymore.
+ * PoolGuardConnectionWrapper is a Connection wrapper that makes sure a closed connection cannot be used anymore.
+ *
* @since 2.0
*/
private class PoolGuardConnectionWrapper extends DelegatingConnection<Connection> {
private final ObjectPool<? extends Connection> pool;
- PoolGuardConnectionWrapper(final ObjectPool<? extends Connection> pool,
- final Connection delegate) {
+ PoolGuardConnectionWrapper(final ObjectPool<? extends Connection> pool, final Connection delegate) {
super(delegate);
this.pool = pool;
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/SwallowedExceptionLogger.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/SwallowedExceptionLogger.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/SwallowedExceptionLogger.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/SwallowedExceptionLogger.java Tue Jun 19 10:30:31 2018
@@ -21,29 +21,31 @@ import org.apache.tomcat.dbcp.pool2.Swal
/**
* Class for logging swallowed exceptions.
+ *
* @since 2.0
*/
-public class SwallowedExceptionLogger implements SwallowedExceptionListener{
+public class SwallowedExceptionLogger implements SwallowedExceptionListener {
private final Log log;
private final boolean logExpiredConnections;
/**
- * Create a SwallowedExceptionLogger with the given logger. By default,
- * expired connection logging is turned on.
+ * Create a SwallowedExceptionLogger with the given logger. By default, expired connection logging is turned on.
*
- * @param log logger
+ * @param log
+ * logger
*/
public SwallowedExceptionLogger(final Log log) {
this(log, true);
}
/**
- * Create a SwallowedExceptionLogger with the given logger and expired
- * connection logging property.
+ * Create a SwallowedExceptionLogger with the given logger and expired connection logging property.
*
- * @param log logger
- * @param logExpiredConnections false suppresses logging of expired connection events
+ * @param log
+ * logger
+ * @param logExpiredConnections
+ * false suppresses logging of expired connection events
*/
public SwallowedExceptionLogger(final Log log, final boolean logExpiredConnections) {
this.log = log;
@@ -53,8 +55,7 @@ public class SwallowedExceptionLogger im
@Override
public void onSwallowException(final Exception e) {
if (logExpiredConnections || !(e instanceof LifetimeExceededException)) {
- log.warn(Utils.getMessage(
- "swallowedExceptionLogger.onSwallowedException"), e);
+ log.warn(Utils.getMessage("swallowedExceptionLogger.onSwallowedException"), e);
}
}
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/Utils.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/Utils.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/Utils.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/Utils.java Tue Jun 19 10:30:31 2018
@@ -28,15 +28,18 @@ import java.util.Set;
/**
* Utility methods.
+ *
* @since 2.0
*/
public final class Utils {
- private static final ResourceBundle messages = ResourceBundle.getBundle(
- Utils.class.getPackage().getName() + ".LocalStrings");
+ private static final ResourceBundle messages = ResourceBundle
+ .getBundle(Utils.class.getPackage().getName() + ".LocalStrings");
- public static final boolean IS_SECURITY_ENABLED =
- System.getSecurityManager() != null;
+ /**
+ * Whether the security manager is enabled.
+ */
+ public static final boolean IS_SECURITY_ENABLED = System.getSecurityManager() != null;
/** Any SQL_STATE starting with this value is considered a fatal disconnect */
public static final String DISCONNECTION_SQL_CODE_PREFIX = "08";
@@ -44,12 +47,12 @@ public final class Utils {
/**
* SQL codes of fatal connection errors.
* <ul>
- * <li>57P01 (ADMIN SHUTDOWN)</li>
- * <li>57P02 (CRASH SHUTDOWN)</li>
- * <li>57P03 (CANNOT CONNECT NOW)</li>
- * <li>01002 (SQL92 disconnect error)</li>
- * <li>JZ0C0 (Sybase disconnect error)</li>
- * <li>JZ0C1 (Sybase disconnect error)</li>
+ * <li>57P01 (ADMIN SHUTDOWN)</li>
+ * <li>57P02 (CRASH SHUTDOWN)</li>
+ * <li>57P03 (CANNOT CONNECT NOW)</li>
+ * <li>01002 (SQL92 disconnect error)</li>
+ * <li>JZ0C0 (Sybase disconnect error)</li>
+ * <li>JZ0C1 (Sybase disconnect error)</li>
* </ul>
*/
public static final Set<String> DISCONNECTION_SQL_CODES;
@@ -71,12 +74,13 @@ public final class Utils {
/**
* Closes the ResultSet (which may be null).
*
- * @param rset a ResultSet, may be {@code null}
+ * @param resultSet
+ * a ResultSet, may be {@code null}
*/
- public static void closeQuietly(final ResultSet rset) {
- if (rset != null) {
+ public static void closeQuietly(final ResultSet resultSet) {
+ if (resultSet != null) {
try {
- rset.close();
+ resultSet.close();
} catch (final Exception e) {
// ignored
}
@@ -86,12 +90,13 @@ public final class Utils {
/**
* Closes the Connection (which may be null).
*
- * @param conn a Connection, may be {@code null}
+ * @param connection
+ * a Connection, may be {@code null}
*/
- public static void closeQuietly(final Connection conn) {
- if (conn != null) {
+ public static void closeQuietly(final Connection connection) {
+ if (connection != null) {
try {
- conn.close();
+ connection.close();
} catch (final Exception e) {
// ignored
}
@@ -101,42 +106,67 @@ public final class Utils {
/**
* Closes the Statement (which may be null).
*
- * @param stmt a Statement, may be {@code null}
+ * @param statement
+ * a Statement, may be {@code null}.
*/
- public static void closeQuietly(final Statement stmt) {
- if (stmt != null) {
+ public static void closeQuietly(final Statement statement) {
+ if (statement != null) {
try {
- stmt.close();
+ statement.close();
} catch (final Exception e) {
// ignored
}
}
}
-
/**
- * Obtain the correct i18n message for the given key.
- * @param key The message key
- * @return the message
+ * Gets the correct i18n message for the given key.
+ *
+ * @param key
+ * The key to look up an i18n message.
+ * @return The i18n message.
*/
public static String getMessage(final String key) {
return getMessage(key, (Object[]) null);
}
-
/**
- * Obtain the correct i18n message for the given key with placeholders
- * replaced by the supplied arguments.
- * @param key The message key
- * @param args The arguments
- * @return the message
+ * Gets the correct i18n message for the given key with placeholders replaced by the supplied arguments.
+ *
+ * @param key
+ * A message key.
+ * @param args
+ * The message arguments.
+ * @return An i18n message.
*/
public static String getMessage(final String key, final Object... args) {
- final String msg = messages.getString(key);
+ final String msg = messages.getString(key);
if (args == null || args.length == 0) {
return msg;
}
final MessageFormat mf = new MessageFormat(msg);
return mf.format(args, new StringBuffer(), null).toString();
}
+
+ /**
+ * Converts the given String to a char[].
+ *
+ * @param value
+ * may be null.
+ * @return a char[] or null.
+ */
+ public static char[] toCharArray(final String value) {
+ return value != null ? value.toCharArray() : null;
+ }
+
+ /**
+ * Converts the given char[] to a String.
+ *
+ * @param value
+ * may be null.
+ * @return a String or null.
+ */
+ public static String toString(final char[] value) {
+ return value == null ? null : String.valueOf(value);
+ }
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/ConnectionImpl.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/ConnectionImpl.java?rev=1833804&r1=1833803&r2=1833804&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/ConnectionImpl.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/cpdsadapter/ConnectionImpl.java Tue Jun 19 10:30:31 2018
@@ -17,26 +17,25 @@
package org.apache.tomcat.dbcp.dbcp2.cpdsadapter;
+import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
+import org.apache.tomcat.dbcp.dbcp2.DelegatingCallableStatement;
import org.apache.tomcat.dbcp.dbcp2.DelegatingConnection;
import org.apache.tomcat.dbcp.dbcp2.DelegatingPreparedStatement;
/**
- * This class is the <code>Connection</code> that will be returned
- * from <code>PooledConnectionImpl.getConnection()</code>.
- * Most methods are wrappers around the JDBC 1.x <code>Connection</code>.
- * A few exceptions include preparedStatement and close.
- * In accordance with the JDBC specification this Connection cannot
- * be used after closed() is called. Any further usage will result in an
+ * This class is the <code>Connection</code> that will be returned from
+ * <code>PooledConnectionImpl.getConnection()</code>. Most methods are wrappers around the JDBC 1.x
+ * <code>Connection</code>. A few exceptions include preparedStatement and close. In accordance with the JDBC
+ * specification this Connection cannot be used after closed() is called. Any further usage will result in an
* SQLException.
+ * <p>
+ * ConnectionImpl extends DelegatingConnection to enable access to the underlying connection.
+ * </p>
*
- * ConnectionImpl extends DelegatingConnection to enable access to the
- * underlying connection.
- *
- * @author John D. McNally
* @since 2.0
*/
class ConnectionImpl extends DelegatingConnection<Connection> {
@@ -44,32 +43,34 @@ class ConnectionImpl extends DelegatingC
private final boolean accessToUnderlyingConnectionAllowed;
/** The object that instantiated this object */
- private final PooledConnectionImpl pooledConnection;
+ private final PooledConnectionImpl pooledConnection;
/**
* Creates a <code>ConnectionImpl</code>.
*
- * @param pooledConnection The PooledConnection that is calling the ctor.
- * @param connection The JDBC 1.x Connection to wrap.
- * @param accessToUnderlyingConnectionAllowed if true, then access is allowed to the underlying connection
+ * @param pooledConnection
+ * The PooledConnection that is calling the ctor.
+ * @param connection
+ * The JDBC 1.x Connection to wrap.
+ * @param accessToUnderlyingConnectionAllowed
+ * if true, then access is allowed to the underlying connection
*/
- ConnectionImpl(final PooledConnectionImpl pooledConnection,
- final Connection connection,
+ ConnectionImpl(final PooledConnectionImpl pooledConnection, final Connection connection,
final boolean accessToUnderlyingConnectionAllowed) {
super(connection);
this.pooledConnection = pooledConnection;
- this.accessToUnderlyingConnectionAllowed =
- accessToUnderlyingConnectionAllowed;
+ this.accessToUnderlyingConnectionAllowed = accessToUnderlyingConnectionAllowed;
}
/**
- * Marks the Connection as closed, and notifies the pool that the
- * pooled connection is available.
- * In accordance with the JDBC specification this Connection cannot
- * be used after closed() is called. Any further usage will result in an
- * SQLException.
+ * Marks the Connection as closed, and notifies the pool that the pooled connection is available.
+ * <p>
+ * In accordance with the JDBC specification this Connection cannot be used after closed() is called. Any further
+ * usage will result in an SQLException.
+ * </p>
*
- * @throws SQLException The database connection couldn't be closed.
+ * @throws SQLException
+ * The database connection couldn't be closed.
*/
@Override
public void close() throws SQLException {
@@ -84,106 +85,179 @@ class ConnectionImpl extends DelegatingC
}
/**
- * If pooling of <code>PreparedStatement</code>s is turned on in the
- * {@link DriverAdapterCPDS}, a pooled object may be returned, otherwise
- * delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
+ * If pooling of <code>CallableStatement</code>s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
+ * be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
- * @param sql SQL statement to be prepared
- * @return the prepared statement
- * @throws SQLException if this connection is closed or an error occurs
- * in the wrapped connection.
+ * @param sql
+ * an SQL statement that may contain one or more '?' parameter placeholders. Typically this statement is
+ * specified using JDBC call escape syntax.
+ * @return a default <code>CallableStatement</code> object containing the pre-compiled SQL statement.
+ * @exception SQLException
+ * Thrown if a database access error occurs or this method is called on a closed connection.
+ * @since 2.4.0
*/
@Override
- public PreparedStatement prepareStatement(final String sql) throws SQLException {
+ public CallableStatement prepareCall(final String sql) throws SQLException {
checkOpen();
try {
- return new DelegatingPreparedStatement
- (this, pooledConnection.prepareStatement(sql));
- }
- catch (final SQLException e) {
+ return new DelegatingCallableStatement(this, pooledConnection.prepareCall(sql));
+ } catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
}
/**
- * If pooling of <code>PreparedStatement</code>s is turned on in the
- * {@link DriverAdapterCPDS}, a pooled object may be returned, otherwise
- * delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
+ * If pooling of <code>CallableStatement</code>s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
+ * be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
- * @throws SQLException if this connection is closed or an error occurs
- * in the wrapped connection.
+ * @param sql
+ * a <code>String</code> object that is the SQL statement to be sent to the database; may contain on or
+ * more '?' parameters.
+ * @param resultSetType
+ * a result set type; one of <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>.
+ * @param resultSetConcurrency
+ * a concurrency type; one of <code>ResultSet.CONCUR_READ_ONLY</code> or
+ * <code>ResultSet.CONCUR_UPDATABLE</code>.
+ * @return a <code>CallableStatement</code> object containing the pre-compiled SQL statement that will produce
+ * <code>ResultSet</code> objects with the given type and concurrency.
+ * @throws SQLException
+ * Thrown if a database access error occurs, this method is called on a closed connection or the given
+ * parameters are not <code>ResultSet</code> constants indicating type and concurrency.
+ * @since 2.4.0
*/
@Override
- public PreparedStatement prepareStatement(final String sql, final int resultSetType,
- final int resultSetConcurrency)
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
- return new DelegatingPreparedStatement
- (this, pooledConnection.prepareStatement
- (sql,resultSetType,resultSetConcurrency));
- }
- catch (final SQLException e) {
- handleException(e);
+ return new DelegatingCallableStatement(this,
+ pooledConnection.prepareCall(sql, resultSetType, resultSetConcurrency));
+ } catch (final SQLException e) {
+ handleException(e); // Does not return
return null;
}
}
+ /**
+ * If pooling of <code>CallableStatement</code>s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
+ * be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
+ *
+ * @param sql
+ * a <code>String</code> object that is the SQL statement to be sent to the database; may contain on or
+ * more '?' parameters.
+ * @param resultSetType
+ * one of the following <code>ResultSet</code> constants: <code>ResultSet.TYPE_FORWARD_ONLY</code>,
+ * <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>.
+ * @param resultSetConcurrency
+ * one of the following <code>ResultSet</code> constants: <code>ResultSet.CONCUR_READ_ONLY</code> or
+ * <code>ResultSet.CONCUR_UPDATABLE</code>.
+ * @param resultSetHoldability
+ * one of the following <code>ResultSet</code> constants: <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code>
+ * or <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>.
+ * @return a new <code>CallableStatement</code> object, containing the pre-compiled SQL statement, that will
+ * generate <code>ResultSet</code> objects with the given type, concurrency, and holdability.
+ * @throws SQLException
+ * Thrown if a database access error occurs, this method is called on a closed connection or the given
+ * parameters are not <code>ResultSet</code> constants indicating type, concurrency, and holdability.
+ * @since 2.4.0
+ */
@Override
- public PreparedStatement prepareStatement(final String sql, final int resultSetType,
- final int resultSetConcurrency,
- final int resultSetHoldability)
- throws SQLException {
+ public CallableStatement prepareCall(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
checkOpen();
try {
- return new DelegatingPreparedStatement(this,
- pooledConnection.prepareStatement(sql, resultSetType,
- resultSetConcurrency, resultSetHoldability));
+ return new DelegatingCallableStatement(this,
+ pooledConnection.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
+ } catch (final SQLException e) {
+ handleException(e); // Does not return
+ return null;
}
- catch (final SQLException e) {
- handleException(e);
+ }
+
+ /**
+ * If pooling of <code>PreparedStatement</code>s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
+ * be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
+ *
+ * @param sql
+ * SQL statement to be prepared
+ * @return the prepared statement
+ * @throws SQLException
+ * if this connection is closed or an error occurs in the wrapped connection.
+ */
+ @Override
+ public PreparedStatement prepareStatement(final String sql) throws SQLException {
+ checkOpen();
+ try {
+ return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql));
+ } catch (final SQLException e) {
+ handleException(e); // Does not return
return null;
}
}
+ /**
+ * If pooling of <code>PreparedStatement</code>s is turned on in the {@link DriverAdapterCPDS}, a pooled object may
+ * be returned, otherwise delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
+ *
+ * @throws SQLException
+ * if this connection is closed or an error occurs in the wrapped connection.
+ */
@Override
- public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys)
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
- pooledConnection.prepareStatement(sql, autoGeneratedKeys));
- }
- catch (final SQLException e) {
+ pooledConnection.prepareStatement(sql, resultSetType, resultSetConcurrency));
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(final String sql, final int columnIndexes[])
- throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType, final int resultSetConcurrency,
+ final int resultSetHoldability) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
- pooledConnection.prepareStatement(sql, columnIndexes));
+ pooledConnection.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability));
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
}
- catch (final SQLException e) {
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys) throws SQLException {
+ checkOpen();
+ try {
+ return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, autoGeneratedKeys));
+ } catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(final String sql, final String columnNames[])
- throws SQLException {
+ public PreparedStatement prepareStatement(final String sql, final int columnIndexes[]) throws SQLException {
checkOpen();
try {
- return new DelegatingPreparedStatement(this,
- pooledConnection.prepareStatement(sql, columnNames));
+ return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, columnIndexes));
+ } catch (final SQLException e) {
+ handleException(e);
+ return null;
}
- catch (final SQLException e) {
+ }
+
+ @Override
+ public PreparedStatement prepareStatement(final String sql, final String columnNames[]) throws SQLException {
+ checkOpen();
+ try {
+ return new DelegatingPreparedStatement(this, pooledConnection.prepareStatement(sql, columnNames));
+ } catch (final SQLException e) {
handleException(e);
return null;
}
@@ -195,6 +269,7 @@ class ConnectionImpl extends DelegatingC
/**
* If false, getDelegate() and getInnermostDelegate() will return null.
+ *
* @return true if access is allowed to the underlying connection
* @see ConnectionImpl
*/
@@ -204,6 +279,7 @@ class ConnectionImpl extends DelegatingC
/**
* Get the delegated connection, if allowed.
+ *
* @return the internal connection, or null if access is not allowed.
* @see #isAccessToUnderlyingConnectionAllowed()
*/
@@ -217,6 +293,7 @@ class ConnectionImpl extends DelegatingC
/**
* Get the innermost connection, if allowed.
+ *
* @return the innermost internal connection, or null if access is not allowed.
* @see #isAccessToUnderlyingConnectionAllowed()
*/
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org