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 2016/05/13 18:49:32 UTC
svn commit: r1743719 [6/8] - 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/DelegatingStatement.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingStatement.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingStatement.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DelegatingStatement.java Fri May 13 18:49:32 2016
@@ -56,7 +56,7 @@ public class DelegatingStatement extends
* @param s the {@link Statement} to delegate all calls to.
* @param c the {@link DelegatingConnection} that created this statement.
*/
- public DelegatingStatement(DelegatingConnection<?> c, Statement s) {
+ public DelegatingStatement(final DelegatingConnection<?> c, final Statement s) {
super(c);
_stmt = s;
_conn = c;
@@ -104,7 +104,7 @@ public class DelegatingStatement extends
* Sets my delegate.
* @param s The statement
*/
- public void setDelegate(Statement s) {
+ public void setDelegate(final Statement s) {
_stmt = s;
}
@@ -114,7 +114,7 @@ public class DelegatingStatement extends
return _closed;
}
- protected void setClosedInternal(boolean closed) {
+ protected void setClosedInternal(final boolean closed) {
this._closed = closed;
}
@@ -146,10 +146,10 @@ public class DelegatingStatement extends
// ResultSet's when it is closed.
// FIXME The PreparedStatement we're wrapping should handle this for us.
// See bug 17301 for what could happen when ResultSets are closed twice.
- List<AbandonedTrace> resultSets = getTrace();
+ final List<AbandonedTrace> resultSets = getTrace();
if( resultSets != null) {
- ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
- for (ResultSet element : set) {
+ final ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
+ for (final ResultSet element : set) {
element.close();
}
clearTrace();
@@ -159,7 +159,7 @@ public class DelegatingStatement extends
_stmt.close();
}
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -169,7 +169,7 @@ public class DelegatingStatement extends
}
}
- protected void handleException(SQLException e) throws SQLException {
+ protected void handleException(final SQLException e) throws SQLException {
if (_conn != null) {
_conn.handleException(e);
}
@@ -201,7 +201,7 @@ public class DelegatingStatement extends
}
@Override
- public ResultSet executeQuery(String sql) throws SQLException {
+ public ResultSet executeQuery(final String sql) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
@@ -209,7 +209,7 @@ public class DelegatingStatement extends
try {
return DelegatingResultSet.wrapResultSet(this,_stmt.executeQuery(sql));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -221,78 +221,78 @@ public class DelegatingStatement extends
try {
return DelegatingResultSet.wrapResultSet(this,_stmt.getResultSet());
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public int executeUpdate(String sql) throws SQLException {
+ public int executeUpdate(final String sql) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.executeUpdate(sql);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e); return 0;
}
}
@Override
public int getMaxFieldSize() throws SQLException
- { checkOpen(); try { return _stmt.getMaxFieldSize(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getMaxFieldSize(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
- public void setMaxFieldSize(int max) throws SQLException
- { checkOpen(); try { _stmt.setMaxFieldSize(max); } catch (SQLException e) { handleException(e); } }
+ public void setMaxFieldSize(final int max) throws SQLException
+ { checkOpen(); try { _stmt.setMaxFieldSize(max); } catch (final SQLException e) { handleException(e); } }
@Override
public int getMaxRows() throws SQLException
- { checkOpen(); try { return _stmt.getMaxRows(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getMaxRows(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
- public void setMaxRows(int max) throws SQLException
- { checkOpen(); try { _stmt.setMaxRows(max); } catch (SQLException e) { handleException(e); } }
+ public void setMaxRows(final int max) throws SQLException
+ { checkOpen(); try { _stmt.setMaxRows(max); } catch (final SQLException e) { handleException(e); } }
@Override
- public void setEscapeProcessing(boolean enable) throws SQLException
- { checkOpen(); try { _stmt.setEscapeProcessing(enable); } catch (SQLException e) { handleException(e); } }
+ public void setEscapeProcessing(final boolean enable) throws SQLException
+ { checkOpen(); try { _stmt.setEscapeProcessing(enable); } catch (final SQLException e) { handleException(e); } }
@Override
public int getQueryTimeout() throws SQLException
- { checkOpen(); try { return _stmt.getQueryTimeout(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getQueryTimeout(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
- public void setQueryTimeout(int seconds) throws SQLException
- { checkOpen(); try { _stmt.setQueryTimeout(seconds); } catch (SQLException e) { handleException(e); } }
+ public void setQueryTimeout(final int seconds) throws SQLException
+ { checkOpen(); try { _stmt.setQueryTimeout(seconds); } catch (final SQLException e) { handleException(e); } }
@Override
public void cancel() throws SQLException
- { checkOpen(); try { _stmt.cancel(); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { _stmt.cancel(); } catch (final SQLException e) { handleException(e); } }
@Override
public SQLWarning getWarnings() throws SQLException
- { checkOpen(); try { return _stmt.getWarnings(); } catch (SQLException e) { handleException(e); throw new AssertionError(); } }
+ { checkOpen(); try { return _stmt.getWarnings(); } catch (final SQLException e) { handleException(e); throw new AssertionError(); } }
@Override
public void clearWarnings() throws SQLException
- { checkOpen(); try { _stmt.clearWarnings(); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { _stmt.clearWarnings(); } catch (final SQLException e) { handleException(e); } }
@Override
- public void setCursorName(String name) throws SQLException
- { checkOpen(); try { _stmt.setCursorName(name); } catch (SQLException e) { handleException(e); } }
+ public void setCursorName(final String name) throws SQLException
+ { checkOpen(); try { _stmt.setCursorName(name); } catch (final SQLException e) { handleException(e); } }
@Override
- public boolean execute(String sql) throws SQLException {
+ public boolean execute(final String sql) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.execute(sql);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
@@ -300,43 +300,43 @@ public class DelegatingStatement extends
@Override
public int getUpdateCount() throws SQLException
- { checkOpen(); try { return _stmt.getUpdateCount(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getUpdateCount(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public boolean getMoreResults() throws SQLException
- { checkOpen(); try { return _stmt.getMoreResults(); } catch (SQLException e) { handleException(e); return false; } }
+ { checkOpen(); try { return _stmt.getMoreResults(); } catch (final SQLException e) { handleException(e); return false; } }
@Override
- public void setFetchDirection(int direction) throws SQLException
- { checkOpen(); try { _stmt.setFetchDirection(direction); } catch (SQLException e) { handleException(e); } }
+ public void setFetchDirection(final int direction) throws SQLException
+ { checkOpen(); try { _stmt.setFetchDirection(direction); } catch (final SQLException e) { handleException(e); } }
@Override
public int getFetchDirection() throws SQLException
- { checkOpen(); try { return _stmt.getFetchDirection(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getFetchDirection(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
- public void setFetchSize(int rows) throws SQLException
- { checkOpen(); try { _stmt.setFetchSize(rows); } catch (SQLException e) { handleException(e); } }
+ public void setFetchSize(final int rows) throws SQLException
+ { checkOpen(); try { _stmt.setFetchSize(rows); } catch (final SQLException e) { handleException(e); } }
@Override
public int getFetchSize() throws SQLException
- { checkOpen(); try { return _stmt.getFetchSize(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getFetchSize(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getResultSetConcurrency() throws SQLException
- { checkOpen(); try { return _stmt.getResultSetConcurrency(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getResultSetConcurrency(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
public int getResultSetType() throws SQLException
- { checkOpen(); try { return _stmt.getResultSetType(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getResultSetType(); } catch (final SQLException e) { handleException(e); return 0; } }
@Override
- public void addBatch(String sql) throws SQLException
- { checkOpen(); try { _stmt.addBatch(sql); } catch (SQLException e) { handleException(e); } }
+ public void addBatch(final String sql) throws SQLException
+ { checkOpen(); try { _stmt.addBatch(sql); } catch (final SQLException e) { handleException(e); } }
@Override
public void clearBatch() throws SQLException
- { checkOpen(); try { _stmt.clearBatch(); } catch (SQLException e) { handleException(e); } }
+ { checkOpen(); try { _stmt.clearBatch(); } catch (final SQLException e) { handleException(e); } }
@Override
public int[] executeBatch() throws SQLException {
@@ -346,7 +346,7 @@ public class DelegatingStatement extends
}
try {
return _stmt.executeBatch();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
@@ -363,99 +363,99 @@ public class DelegatingStatement extends
}
@Override
- public boolean getMoreResults(int current) throws SQLException
- { checkOpen(); try { return _stmt.getMoreResults(current); } catch (SQLException e) { handleException(e); return false; } }
+ public boolean getMoreResults(final int current) throws SQLException
+ { checkOpen(); try { return _stmt.getMoreResults(current); } catch (final SQLException e) { handleException(e); return false; } }
@Override
public ResultSet getGeneratedKeys() throws SQLException {
checkOpen();
try {
return DelegatingResultSet.wrapResultSet(this, _stmt.getGeneratedKeys());
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
throw new AssertionError();
}
}
@Override
- public int executeUpdate(String sql, int autoGeneratedKeys) throws SQLException {
+ public int executeUpdate(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.executeUpdate(sql, autoGeneratedKeys);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
- public int executeUpdate(String sql, int columnIndexes[]) throws SQLException {
+ public int executeUpdate(final String sql, final int columnIndexes[]) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.executeUpdate(sql, columnIndexes);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
- public int executeUpdate(String sql, String columnNames[]) throws SQLException {
+ public int executeUpdate(final String sql, final String columnNames[]) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.executeUpdate(sql, columnNames);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return 0;
}
}
@Override
- public boolean execute(String sql, int autoGeneratedKeys) throws SQLException {
+ public boolean execute(final String sql, final int autoGeneratedKeys) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.execute(sql, autoGeneratedKeys);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
- public boolean execute(String sql, int columnIndexes[]) throws SQLException {
+ public boolean execute(final String sql, final int columnIndexes[]) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.execute(sql, columnIndexes);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
}
@Override
- public boolean execute(String sql, String columnNames[]) throws SQLException {
+ public boolean execute(final String sql, final String columnNames[]) throws SQLException {
checkOpen();
if (_conn != null) {
_conn.setLastUsed();
}
try {
return _stmt.execute(sql, columnNames);
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
@@ -463,7 +463,7 @@ public class DelegatingStatement extends
@Override
public int getResultSetHoldability() throws SQLException
- { checkOpen(); try { return _stmt.getResultSetHoldability(); } catch (SQLException e) { handleException(e); return 0; } }
+ { checkOpen(); try { return _stmt.getResultSetHoldability(); } catch (final SQLException e) { handleException(e); return 0; } }
/*
* Note was protected prior to JDBC 4
@@ -475,7 +475,7 @@ public class DelegatingStatement extends
@Override
- public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ public boolean isWrapperFor(final Class<?> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return true;
} else if (iface.isAssignableFrom(_stmt.getClass())) {
@@ -486,7 +486,7 @@ public class DelegatingStatement extends
}
@Override
- public <T> T unwrap(Class<T> iface) throws SQLException {
+ public <T> T unwrap(final Class<T> iface) throws SQLException {
if (iface.isAssignableFrom(getClass())) {
return iface.cast(this);
} else if (iface.isAssignableFrom(_stmt.getClass())) {
@@ -497,12 +497,12 @@ public class DelegatingStatement extends
}
@Override
- public void setPoolable(boolean poolable) throws SQLException {
+ public void setPoolable(final boolean poolable) throws SQLException {
checkOpen();
try {
_stmt.setPoolable(poolable);
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
}
}
@@ -513,7 +513,7 @@ public class DelegatingStatement extends
try {
return _stmt.isPoolable();
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return false;
}
@@ -524,7 +524,7 @@ public class DelegatingStatement extends
checkOpen();
try {
_stmt.closeOnCompletion();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
}
}
@@ -534,7 +534,7 @@ public class DelegatingStatement extends
checkOpen();
try {
return _stmt.isCloseOnCompletion();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
handleException(e);
return false;
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverConnectionFactory.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverConnectionFactory.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverConnectionFactory.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverConnectionFactory.java Fri May 13 18:49:32 2016
@@ -27,7 +27,7 @@ import java.util.Properties;
* @since 2.0
*/
public class DriverConnectionFactory implements ConnectionFactory {
- public DriverConnectionFactory(Driver driver, String connectUri, Properties props) {
+ public DriverConnectionFactory(final Driver driver, final String connectUri, final Properties props) {
_driver = driver;
_connectUri = connectUri;
_props = props;
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverManagerConnectionFactory.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverManagerConnectionFactory.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverManagerConnectionFactory.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/DriverManagerConnectionFactory.java Fri May 13 18:49:32 2016
@@ -47,7 +47,7 @@ public class DriverManagerConnectionFact
* <code> jdbc:<em>subprotocol</em>:<em>subname</em></code>
* @since 2.2
*/
- public DriverManagerConnectionFactory(String connectUri) {
+ public DriverManagerConnectionFactory(final String connectUri) {
_connectUri = connectUri;
_props = new Properties();
}
@@ -60,7 +60,7 @@ public class DriverManagerConnectionFact
* connection arguments; normally at least a "user" and "password"
* property should be included.
*/
- public DriverManagerConnectionFactory(String connectUri, Properties props) {
+ public DriverManagerConnectionFactory(final String connectUri, final Properties props) {
_connectUri = connectUri;
_props = props;
}
@@ -72,7 +72,7 @@ public class DriverManagerConnectionFact
* @param uname the database user
* @param passwd the user's password
*/
- public DriverManagerConnectionFactory(String connectUri, String uname, String passwd) {
+ public DriverManagerConnectionFactory(final String connectUri, final String uname, final String passwd) {
_connectUri = connectUri;
_uname = uname;
_passwd = passwd;
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/LifetimeExceededException.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/LifetimeExceededException.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/LifetimeExceededException.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/LifetimeExceededException.java Fri May 13 18:49:32 2016
@@ -37,7 +37,7 @@ package org.apache.tomcat.dbcp.dbcp2;
*
* @param message The message with which to create the exception
*/
- public LifetimeExceededException(String message) {
+ public LifetimeExceededException(final String message) {
super(message);
}
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PStmtKey.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PStmtKey.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PStmtKey.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PStmtKey.java Fri May 13 18:49:32 2016
@@ -43,19 +43,19 @@ public class PStmtKey {
private final StatementType _stmtType;
- public PStmtKey(String sql) {
+ public PStmtKey(final String sql) {
this(sql, null, StatementType.PREPARED_STATEMENT, null);
}
- public PStmtKey(String sql, String catalog) {
+ public PStmtKey(final String sql, final String catalog) {
this(sql, catalog, StatementType.PREPARED_STATEMENT, null);
}
- public PStmtKey(String sql, String catalog, int autoGeneratedKeys) {
+ public PStmtKey(final String sql, final String catalog, final int autoGeneratedKeys) {
this(sql, catalog, StatementType.PREPARED_STATEMENT, Integer.valueOf(autoGeneratedKeys));
}
- public PStmtKey(String sql, String catalog, StatementType stmtType, Integer autoGeneratedKeys) {
+ public PStmtKey(final String sql, final String catalog, final StatementType stmtType, final Integer autoGeneratedKeys) {
_sql = sql;
_catalog = catalog;
_stmtType = stmtType;
@@ -64,15 +64,15 @@ public class PStmtKey {
_resultSetConcurrency = null;
}
- public PStmtKey(String sql, int resultSetType, int resultSetConcurrency) {
+ public PStmtKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
this(sql, null, resultSetType, resultSetConcurrency, StatementType.PREPARED_STATEMENT);
}
- public PStmtKey(String sql, String catalog, int resultSetType, int resultSetConcurrency) {
+ public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency) {
this(sql, catalog, resultSetType, resultSetConcurrency, StatementType.PREPARED_STATEMENT);
}
- public PStmtKey(String sql, String catalog, int resultSetType, int resultSetConcurrency, StatementType stmtType) {
+ public PStmtKey(final String sql, final String catalog, final int resultSetType, final int resultSetConcurrency, final StatementType stmtType) {
_sql = sql;
_catalog = catalog;
_resultSetType = Integer.valueOf(resultSetType);
@@ -107,7 +107,7 @@ public class PStmtKey {
}
@Override
- public boolean equals(Object obj) {
+ public boolean equals(final Object obj) {
if (this == obj) {
return true;
}
@@ -117,7 +117,7 @@ public class PStmtKey {
if (getClass() != obj.getClass()) {
return false;
}
- PStmtKey other = (PStmtKey) obj;
+ final PStmtKey other = (PStmtKey) obj;
if (_catalog == null) {
if (other._catalog != null) {
return false;
@@ -174,7 +174,7 @@ public class PStmtKey {
@Override
public String toString() {
- StringBuffer buf = new StringBuffer();
+ final StringBuffer buf = new StringBuffer();
buf.append("PStmtKey: sql=");
buf.append(_sql);
buf.append(", catalog=");
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableCallableStatement.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableCallableStatement.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableCallableStatement.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableCallableStatement.java Fri May 13 18:49:32 2016
@@ -54,9 +54,9 @@ public class PoolableCallableStatement e
* @param pool the {@link KeyedObjectPool} from which this CallableStatement was obtained
* @param conn the {@link DelegatingConnection} that created this CallableStatement
*/
- public PoolableCallableStatement(CallableStatement stmt, PStmtKey key,
- KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> pool,
- DelegatingConnection<Connection> conn) {
+ public PoolableCallableStatement(final CallableStatement stmt, final PStmtKey key,
+ final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> pool,
+ final DelegatingConnection<Connection> conn) {
super(conn, stmt);
_pool = pool;
_key = key;
@@ -77,11 +77,11 @@ public class PoolableCallableStatement e
if (!isClosed()) {
try {
_pool.returnObject(_key,this);
- } catch(SQLException e) {
+ } catch(final SQLException e) {
throw e;
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot close CallableStatement (return to pool failed)", e);
}
}
@@ -115,10 +115,10 @@ public class PoolableCallableStatement e
// ResultSet's when it is closed.
// FIXME The PreparedStatement we're wrapping should handle this for us.
// See DBCP-10 for what could happen when ResultSets are closed twice.
- List<AbandonedTrace> resultSets = getTrace();
+ final List<AbandonedTrace> resultSets = getTrace();
if(resultSets != null) {
- ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
- for (ResultSet element : set) {
+ final ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
+ for (final ResultSet element : set) {
element.close();
}
clearTrace();
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnection.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnection.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnection.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnection.java Fri May 13 18:49:32 2016
@@ -90,9 +90,9 @@ public class PoolableConnection extends
* @param fastFailValidation true means fatal disconnection errors cause subsequent
* validations to fail immediately (no attempt to run query or isValid)
*/
- public PoolableConnection(Connection conn,
- ObjectPool<PoolableConnection> pool, ObjectName jmxName, Collection<String> disconnectSqlCodes,
- boolean fastFailValidation) {
+ public PoolableConnection(final Connection conn,
+ final ObjectPool<PoolableConnection> pool, final ObjectName jmxName, final Collection<String> disconnectSqlCodes,
+ final boolean fastFailValidation) {
super(conn);
_pool = pool;
_jmxName = jmxName;
@@ -115,8 +115,8 @@ public class PoolableConnection extends
* @param pool the pool to which I should return when closed
* @param jmxName JMX name
*/
- public PoolableConnection(Connection conn,
- ObjectPool<PoolableConnection> pool, ObjectName jmxName) {
+ public PoolableConnection(final Connection conn,
+ final ObjectPool<PoolableConnection> pool, final ObjectName jmxName) {
this(conn, pool, jmxName, null, false);
}
@@ -167,14 +167,14 @@ public class PoolableConnection extends
boolean isUnderlyingConectionClosed;
try {
isUnderlyingConectionClosed = getDelegateInternal().isClosed();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
try {
_pool.invalidateObject(this);
- } catch(IllegalStateException ise) {
+ } catch(final IllegalStateException ise) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
- } catch (Exception ie) {
+ } catch (final Exception ie) {
// DO NOTHING the original exception will be rethrown
}
throw new SQLException("Cannot close connection (isClosed check failed)", e);
@@ -191,11 +191,11 @@ public class PoolableConnection extends
// must destroy this proxy
try {
_pool.invalidateObject(this);
- } catch(IllegalStateException e) {
+ } catch(final IllegalStateException e) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
- } catch (Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Cannot close connection (invalidating pooled object failed)", e);
}
} else {
@@ -203,15 +203,15 @@ public class PoolableConnection extends
// simply need to return this proxy to the pool
try {
_pool.returnObject(this);
- } catch(IllegalStateException e) {
+ } catch(final IllegalStateException e) {
// pool is closed, so close the connection
passivate();
getInnermostDelegate().close();
- } catch(SQLException e) {
+ } catch(final SQLException e) {
throw e;
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot close connection (return to pool failed)", e);
}
}
@@ -234,7 +234,7 @@ public class PoolableConnection extends
if (validationPreparedStatement != null) {
try {
validationPreparedStatement.close();
- } catch (SQLException sqle) {
+ } catch (final SQLException sqle) {
// Ignore
}
}
@@ -270,7 +270,7 @@ public class PoolableConnection extends
* @param timeout validation timeout
* @throws SQLException if validation fails or an SQLException occurs during validation
*/
- public void validate(String sql, int timeout) throws SQLException {
+ public void validate(final String sql, int timeout) throws SQLException {
if (_fastFailValidation && _fatalSqlExceptionThrown) {
throw new SQLException(Utils.getMessage("poolableConnection.validate.fastFail"));
}
@@ -301,7 +301,7 @@ public class PoolableConnection extends
if(!rs.next()) {
throw new SQLException("validationQuery didn't return a row");
}
- } catch (SQLException sqle) {
+ } catch (final SQLException sqle) {
throw sqle;
}
}
@@ -318,9 +318,9 @@ public class PoolableConnection extends
* @param e SQLException to be examined
* @return true if the exception signals a disconnection
*/
- private boolean isDisconnectionSqlException(SQLException e) {
+ private boolean isDisconnectionSqlException(final SQLException e) {
boolean fatalException = false;
- String sqlState = e.getSQLState();
+ final String sqlState = e.getSQLState();
if (sqlState != null) {
fatalException = _disconnectionSqlCodes == null ? sqlState.startsWith(Utils.DISCONNECTION_SQL_CODE_PREFIX)
|| Utils.DISCONNECTION_SQL_CODES.contains(sqlState) : _disconnectionSqlCodes.contains(sqlState);
@@ -334,7 +334,7 @@ public class PoolableConnection extends
}
@Override
- protected void handleException(SQLException e) throws SQLException {
+ protected void handleException(final SQLException e) throws SQLException {
_fatalSqlExceptionThrown |= isDisconnectionSqlException(e);
super.handleException(e);
}
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnectionFactory.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnectionFactory.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnectionFactory.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolableConnectionFactory.java Fri May 13 18:49:32 2016
@@ -57,8 +57,8 @@ public class PoolableConnectionFactory
* @param dataSourceJmxName The JMX name
* base {@link Connection}s
*/
- public PoolableConnectionFactory(ConnectionFactory connFactory,
- ObjectName dataSourceJmxName) {
+ public PoolableConnectionFactory(final ConnectionFactory connFactory,
+ final ObjectName dataSourceJmxName) {
_connFactory = connFactory;
this.dataSourceJmxName = dataSourceJmxName;
}
@@ -70,7 +70,7 @@ public class PoolableConnectionFactory
*
* @param validationQuery a query to use to {@link #validateObject validate} {@link Connection}s.
*/
- public void setValidationQuery(String validationQuery) {
+ public void setValidationQuery(final String validationQuery) {
_validationQuery = validationQuery;
}
@@ -82,7 +82,7 @@ public class PoolableConnectionFactory
*
* @param timeout new validation query timeout value in seconds
*/
- public void setValidationQueryTimeout(int timeout) {
+ public void setValidationQueryTimeout(final int timeout) {
_validationQueryTimeout = timeout;
}
@@ -91,7 +91,7 @@ public class PoolableConnectionFactory
* Using {@code null} turns off connection initialization.
* @param connectionInitSqls SQL statement to initialize {@link Connection}s.
*/
- public void setConnectionInitSql(Collection<String> connectionInitSqls) {
+ public void setConnectionInitSql(final Collection<String> connectionInitSqls) {
_connectionInitSqls = connectionInitSqls;
}
@@ -99,11 +99,11 @@ public class PoolableConnectionFactory
* Sets the {@link ObjectPool} in which to pool {@link Connection}s.
* @param pool the {@link ObjectPool} in which to pool those {@link Connection}s
*/
- public synchronized void setPool(ObjectPool<PoolableConnection> pool) {
+ public synchronized void setPool(final ObjectPool<PoolableConnection> pool) {
if(null != _pool && pool != _pool) {
try {
_pool.close();
- } catch(Exception e) {
+ } catch(final Exception e) {
// ignored !?!
}
}
@@ -122,7 +122,7 @@ public class PoolableConnectionFactory
* Sets the default "read only" setting for borrowed {@link Connection}s
* @param defaultReadOnly the default "read only" setting for borrowed {@link Connection}s
*/
- public void setDefaultReadOnly(Boolean defaultReadOnly) {
+ public void setDefaultReadOnly(final Boolean defaultReadOnly) {
_defaultReadOnly = defaultReadOnly;
}
@@ -130,7 +130,7 @@ public class PoolableConnectionFactory
* Sets the default "auto commit" setting for borrowed {@link Connection}s
* @param defaultAutoCommit the default "auto commit" setting for borrowed {@link Connection}s
*/
- public void setDefaultAutoCommit(Boolean defaultAutoCommit) {
+ public void setDefaultAutoCommit(final Boolean defaultAutoCommit) {
_defaultAutoCommit = defaultAutoCommit;
}
@@ -138,7 +138,7 @@ public class PoolableConnectionFactory
* Sets the default "Transaction Isolation" setting for borrowed {@link Connection}s
* @param defaultTransactionIsolation the default "Transaction Isolation" setting for returned {@link Connection}s
*/
- public void setDefaultTransactionIsolation(int defaultTransactionIsolation) {
+ public void setDefaultTransactionIsolation(final int defaultTransactionIsolation) {
_defaultTransactionIsolation = defaultTransactionIsolation;
}
@@ -146,19 +146,19 @@ public class PoolableConnectionFactory
* Sets the default "catalog" setting for borrowed {@link Connection}s
* @param defaultCatalog the default "catalog" setting for borrowed {@link Connection}s
*/
- public void setDefaultCatalog(String defaultCatalog) {
+ public void setDefaultCatalog(final String defaultCatalog) {
_defaultCatalog = defaultCatalog;
}
- public void setCacheState(boolean cacheState) {
+ public void setCacheState(final boolean cacheState) {
this._cacheState = cacheState;
}
- public void setPoolStatements(boolean poolStatements) {
+ public void setPoolStatements(final boolean poolStatements) {
this.poolStatements = poolStatements;
}
- public void setMaxOpenPrepatedStatements(int maxOpenPreparedStatements) {
+ public void setMaxOpenPrepatedStatements(final int maxOpenPreparedStatements) {
this.maxOpenPreparedStatements = maxOpenPreparedStatements;
}
@@ -169,7 +169,7 @@ public class PoolableConnectionFactory
* is -1.
* @param maxConnLifetimeMillis The maximum connection lifetime
*/
- public void setMaxConnLifetimeMillis(long maxConnLifetimeMillis) {
+ public void setMaxConnLifetimeMillis(final long maxConnLifetimeMillis) {
this.maxConnLifetimeMillis = maxConnLifetimeMillis;
}
@@ -178,7 +178,7 @@ public class PoolableConnectionFactory
return enableAutoCommitOnReturn;
}
- public void setEnableAutoCommitOnReturn(boolean enableAutoCommitOnReturn) {
+ public void setEnableAutoCommitOnReturn(final boolean enableAutoCommitOnReturn) {
this.enableAutoCommitOnReturn = enableAutoCommitOnReturn;
}
@@ -187,7 +187,7 @@ public class PoolableConnectionFactory
return rollbackOnReturn;
}
- public void setRollbackOnReturn(boolean rollbackOnReturn) {
+ public void setRollbackOnReturn(final boolean rollbackOnReturn) {
this.rollbackOnReturn = rollbackOnReturn;
}
@@ -195,7 +195,7 @@ public class PoolableConnectionFactory
return defaultQueryTimeout;
}
- public void setDefaultQueryTimeout(Integer defaultQueryTimeout) {
+ public void setDefaultQueryTimeout(final Integer defaultQueryTimeout) {
this.defaultQueryTimeout = defaultQueryTimeout;
}
@@ -225,7 +225,7 @@ public class PoolableConnectionFactory
* @param disconnectionSqlCodes The disconnection codes
* @since 2.1
*/
- public void setDisconnectionSqlCodes(Collection<String> disconnectionSqlCodes) {
+ public void setDisconnectionSqlCodes(final Collection<String> disconnectionSqlCodes) {
_disconnectionSqlCodes = disconnectionSqlCodes;
}
@@ -248,7 +248,7 @@ public class PoolableConnectionFactory
* fast fail validation
* @since 2.1
*/
- public void setFastFailValidation(boolean fastFailValidation) {
+ public void setFastFailValidation(final boolean fastFailValidation) {
_fastFailValidation = fastFailValidation;
}
@@ -260,29 +260,29 @@ public class PoolableConnectionFactory
}
try {
initializeConnection(conn);
- } catch (SQLException sqle) {
+ } catch (final SQLException sqle) {
// Make sure the connection is closed
try {
conn.close();
- } catch (SQLException ignore) {
+ } catch (final SQLException ignore) {
// ignore
}
// Rethrow original exception so it is visible to caller
throw sqle;
}
- long connIndex = connectionIndex.getAndIncrement();
+ final long connIndex = connectionIndex.getAndIncrement();
if(poolStatements) {
conn = new PoolingConnection(conn);
- GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
+ final GenericKeyedObjectPoolConfig config = new GenericKeyedObjectPoolConfig();
config.setMaxTotalPerKey(-1);
config.setBlockWhenExhausted(false);
config.setMaxWaitMillis(0);
config.setMaxIdlePerKey(1);
config.setMaxTotal(maxOpenPreparedStatements);
if (dataSourceJmxName != null) {
- StringBuilder base = new StringBuilder(dataSourceJmxName.toString());
+ final StringBuilder base = new StringBuilder(dataSourceJmxName.toString());
base.append(Constants.JMX_CONNECTION_BASE_EXT);
base.append(Long.toString(connIndex));
config.setJmxNameBase(base.toString());
@@ -290,7 +290,7 @@ public class PoolableConnectionFactory
} else {
config.setJmxEnabled(false);
}
- KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> stmtPool =
+ final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> stmtPool =
new GenericKeyedObjectPool<>((PoolingConnection)conn, config);
((PoolingConnection)conn).setStatementPool(stmtPool);
((PoolingConnection) conn).setCacheState(_cacheState);
@@ -305,20 +305,21 @@ public class PoolableConnectionFactory
Constants.JMX_CONNECTION_BASE_EXT + connIndex);
}
- PoolableConnection pc = new PoolableConnection(conn,_pool, connJmxName,
+ final PoolableConnection pc = new PoolableConnection(conn, _pool, connJmxName,
_disconnectionSqlCodes, _fastFailValidation);
+ pc.setCacheState(_cacheState);
return new DefaultPooledObject<>(pc);
}
- protected void initializeConnection(Connection conn) throws SQLException {
- Collection<String> sqls = _connectionInitSqls;
+ protected void initializeConnection(final Connection conn) throws SQLException {
+ final Collection<String> sqls = _connectionInitSqls;
if(conn.isClosed()) {
throw new SQLException("initializeConnection: connection closed");
}
if(null != sqls) {
try (Statement stmt = conn.createStatement();) {
- for (String sql : sqls) {
+ for (final String sql : sqls) {
if (sql == null) {
throw new NullPointerException(
"null connectionInitSqls element");
@@ -330,19 +331,19 @@ public class PoolableConnectionFactory
}
@Override
- public void destroyObject(PooledObject<PoolableConnection> p)
+ public void destroyObject(final PooledObject<PoolableConnection> p)
throws Exception {
p.getObject().reallyClose();
}
@Override
- public boolean validateObject(PooledObject<PoolableConnection> p) {
+ public boolean validateObject(final PooledObject<PoolableConnection> p) {
try {
validateLifetime(p);
validateConnection(p.getObject());
return true;
- } catch (Exception e) {
+ } catch (final Exception e) {
if (log.isDebugEnabled()) {
log.debug(Utils.getMessage(
"poolableConnectionFactory.validateObject.fail"), e);
@@ -351,7 +352,7 @@ public class PoolableConnectionFactory
}
}
- public void validateConnection(PoolableConnection conn) throws SQLException {
+ public void validateConnection(final PoolableConnection conn) throws SQLException {
if(conn.isClosed()) {
throw new SQLException("validateConnection: connection closed");
}
@@ -359,12 +360,12 @@ public class PoolableConnectionFactory
}
@Override
- public void passivateObject(PooledObject<PoolableConnection> p)
+ public void passivateObject(final PooledObject<PoolableConnection> p)
throws Exception {
validateLifetime(p);
- PoolableConnection conn = p.getObject();
+ final PoolableConnection conn = p.getObject();
Boolean connAutoCommit = null;
if (rollbackOnReturn) {
connAutoCommit = Boolean.valueOf(conn.getAutoCommit());
@@ -390,12 +391,12 @@ public class PoolableConnectionFactory
}
@Override
- public void activateObject(PooledObject<PoolableConnection> p)
+ public void activateObject(final PooledObject<PoolableConnection> p)
throws Exception {
validateLifetime(p);
- PoolableConnection conn = p.getObject();
+ final PoolableConnection conn = p.getObject();
conn.activate();
if (_defaultAutoCommit != null &&
@@ -417,10 +418,10 @@ public class PoolableConnectionFactory
conn.setDefaultQueryTimeout(defaultQueryTimeout);
}
- private void validateLifetime(PooledObject<PoolableConnection> p)
+ private void validateLifetime(final PooledObject<PoolableConnection> p)
throws Exception {
if (maxConnLifetimeMillis > 0) {
- long lifetime = System.currentTimeMillis() - p.getCreateTime();
+ final long lifetime = System.currentTimeMillis() - p.getCreateTime();
if (lifetime > maxConnLifetimeMillis) {
throw new LifetimeExceededException(Utils.getMessage(
"connectionFactory.lifetimeExceeded",
Modified: tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolablePreparedStatement.java
URL: http://svn.apache.org/viewvc/tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolablePreparedStatement.java?rev=1743719&r1=1743718&r2=1743719&view=diff
==============================================================================
--- tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolablePreparedStatement.java (original)
+++ tomcat/tc8.5.x/trunk/java/org/apache/tomcat/dbcp/dbcp2/PoolablePreparedStatement.java Fri May 13 18:49:32 2016
@@ -43,7 +43,7 @@ public class PoolablePreparedStatement<K
/**
* The {@link KeyedObjectPool} from which I was obtained.
*/
- private final KeyedObjectPool<K,PoolablePreparedStatement<K>> _pool;
+ private final KeyedObjectPool<K, PoolablePreparedStatement<K>> _pool;
/**
* My "key" as used by {@link KeyedObjectPool}.
@@ -59,9 +59,9 @@ public class PoolablePreparedStatement<K
* @param pool the {@link KeyedObjectPool} from which I was obtained.
* @param conn the {@link java.sql.Connection Connection} from which I was created
*/
- public PoolablePreparedStatement(PreparedStatement stmt, K key,
- KeyedObjectPool<K, PoolablePreparedStatement<K>> pool,
- DelegatingConnection<?> conn) {
+ public PoolablePreparedStatement(final PreparedStatement stmt, final K key,
+ final KeyedObjectPool<K, PoolablePreparedStatement<K>> pool,
+ final DelegatingConnection<?> conn) {
super(conn, stmt);
_pool = pool;
_key = key;
@@ -100,11 +100,11 @@ public class PoolablePreparedStatement<K
if (!isClosed()) {
try {
_pool.returnObject(_key, this);
- } catch(SQLException e) {
+ } catch(final SQLException e) {
throw e;
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot close preparedstatement (return to pool failed)", e);
}
}
@@ -135,10 +135,10 @@ public class PoolablePreparedStatement<K
// ResultSet's when it is closed.
// FIXME The PreparedStatement we're wrapping should handle this for us.
// See bug 17301 for what could happen when ResultSets are closed twice.
- List<AbandonedTrace> resultSets = getTrace();
+ final List<AbandonedTrace> resultSets = getTrace();
if( resultSets != null) {
- ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
- for (ResultSet element : set) {
+ final ResultSet[] set = resultSets.toArray(new ResultSet[resultSets.size()]);
+ for (final ResultSet element : set) {
element.close();
}
clearTrace();
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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -56,13 +56,13 @@ public class PoolingConnection extends D
* Constructor.
* @param c the underlying {@link Connection}.
*/
- public PoolingConnection(Connection c) {
+ public PoolingConnection(final Connection c) {
super(c);
}
public void setStatementPool(
- KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> pool) {
+ final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> pool) {
_pstmtPool = pool;
}
@@ -76,13 +76,13 @@ public class PoolingConnection extends D
public synchronized void close() throws SQLException {
try {
if (null != _pstmtPool) {
- KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> oldpool = _pstmtPool;
+ final KeyedObjectPool<PStmtKey,DelegatingPreparedStatement> oldpool = _pstmtPool;
_pstmtPool = null;
try {
oldpool.close();
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot close connection", e);
}
}
@@ -101,24 +101,24 @@ public class PoolingConnection extends D
* @return a {@link PoolablePreparedStatement}
*/
@Override
- public PreparedStatement prepareStatement(String sql) throws SQLException {
+ 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(NoSuchElementException e) {
+ } catch(final NoSuchElementException e) {
throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@Override
- public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
+ 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.");
@@ -126,13 +126,13 @@ public class PoolingConnection extends D
try {
return _pstmtPool.borrowObject(createKey(sql, autoGeneratedKeys));
}
- catch (NoSuchElementException e) {
+ catch (final NoSuchElementException e) {
throw new SQLException("MaxOpenPreparedStatements limit reached", e);
}
- catch (RuntimeException e) {
+ catch (final RuntimeException e) {
throw e;
}
- catch (Exception e) {
+ catch (final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@@ -146,18 +146,18 @@ public class PoolingConnection extends D
* @throws SQLException An error occurred
*/
@Override
- public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ 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(NoSuchElementException e) {
+ } catch(final NoSuchElementException e) {
throw new SQLException("MaxOpenPreparedStatements limit reached", e);
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Borrow prepareStatement from pool failed", e);
}
}
@@ -169,14 +169,14 @@ public class PoolingConnection extends D
* @throws SQLException An error occurred
*/
@Override
- public CallableStatement prepareCall(String sql) throws SQLException {
+ public CallableStatement prepareCall(final String sql) throws SQLException {
try {
return (CallableStatement) _pstmtPool.borrowObject(createKey(sql, StatementType.CALLABLE_STATEMENT));
- } catch (NoSuchElementException e) {
+ } catch (final NoSuchElementException e) {
throw new SQLException("MaxOpenCallableStatements limit reached", e);
- } catch (RuntimeException e) {
+ } catch (final RuntimeException e) {
throw e;
- } catch (Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Borrow callableStatement from pool failed", e);
}
}
@@ -190,15 +190,15 @@ public class PoolingConnection extends D
* @throws SQLException An error occurred
*/
@Override
- public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {
+ 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 (NoSuchElementException e) {
+ } catch (final NoSuchElementException e) {
throw new SQLException("MaxOpenCallableStatements limit reached", e);
- } catch (RuntimeException e) {
+ } catch (final RuntimeException e) {
throw e;
- } catch (Exception e) {
+ } catch (final Exception e) {
throw new SQLException("Borrow callableStatement from pool failed", e);
}
}
@@ -224,11 +224,11 @@ public class PoolingConnection extends D
// return super.prepareStatement(sql, columnNames);
// }
- protected PStmtKey createKey(String sql, int autoGeneratedKeys) {
+ protected PStmtKey createKey(final String sql, final int autoGeneratedKeys) {
String catalog = null;
try {
catalog = getCatalog();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
// Ignored
}
return new PStmtKey(normalizeSQL(sql), catalog, autoGeneratedKeys);
@@ -241,11 +241,11 @@ public class PoolingConnection extends D
* @param resultSetConcurrency result set concurrency
* @return the key
*/
- protected PStmtKey createKey(String sql, int resultSetType, int resultSetConcurrency) {
+ protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency) {
String catalog = null;
try {
catalog = getCatalog();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
// Ignored
}
return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency);
@@ -259,11 +259,11 @@ public class PoolingConnection extends D
* @param stmtType statement type
* @return the key
*/
- protected PStmtKey createKey(String sql, int resultSetType, int resultSetConcurrency, StatementType stmtType) {
+ protected PStmtKey createKey(final String sql, final int resultSetType, final int resultSetConcurrency, final StatementType stmtType) {
String catalog = null;
try {
catalog = getCatalog();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
// Ignored
}
return new PStmtKey(normalizeSQL(sql), catalog, resultSetType, resultSetConcurrency, stmtType);
@@ -274,11 +274,11 @@ public class PoolingConnection extends D
* @param sql the sql string used to define the statement
* @return the key
*/
- protected PStmtKey createKey(String sql) {
+ protected PStmtKey createKey(final String sql) {
String catalog = null;
try {
catalog = getCatalog();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
// Ignored
}
return new PStmtKey(normalizeSQL(sql), catalog);
@@ -290,11 +290,11 @@ public class PoolingConnection extends D
* @param stmtType statement type
* @return the key
*/
- protected PStmtKey createKey(String sql, StatementType stmtType) {
+ protected PStmtKey createKey(final String sql, final StatementType stmtType) {
String catalog = null;
try {
catalog = getCatalog();
- } catch (SQLException e) {
+ } catch (final SQLException e) {
// Ignored
}
return new PStmtKey(normalizeSQL(sql), catalog, stmtType, null);
@@ -306,7 +306,7 @@ public class PoolingConnection extends D
* @param sql The SQL statement
* @return the trimmed SQL statement
*/
- protected String normalizeSQL(String sql) {
+ protected String normalizeSQL(final String sql) {
return sql.trim();
}
@@ -322,7 +322,7 @@ public class PoolingConnection extends D
* @see #createKey(String, int, int, StatementType)
*/
@Override
- public PooledObject<DelegatingPreparedStatement> makeObject(PStmtKey key)
+ public PooledObject<DelegatingPreparedStatement> makeObject(final PStmtKey key)
throws Exception {
if(null == key) {
throw new IllegalArgumentException("Prepared statement key is null or invalid.");
@@ -330,6 +330,7 @@ public class PoolingConnection extends D
if (null == key.getResultSetType() && null == key.getResultSetConcurrency() && null == key.getAutoGeneratedKeys()) {
if (key.getStmtType() == StatementType.PREPARED_STATEMENT ) {
@SuppressWarnings({"rawtypes", "unchecked"}) // Unable to find way to avoid this
+ final
PoolablePreparedStatement pps = new PoolablePreparedStatement(
getDelegate().prepareStatement(key.getSql()), key, _pstmtPool, this);
return new DefaultPooledObject<DelegatingPreparedStatement>(pps);
@@ -338,12 +339,14 @@ public class PoolingConnection extends D
new PoolableCallableStatement(getDelegate().prepareCall( key.getSql()), key, _pstmtPool, this));
} else if (null == key.getResultSetType() && null == key.getResultSetConcurrency()){
@SuppressWarnings({"rawtypes", "unchecked"}) // Unable to find way to avoid this
+ final
PoolablePreparedStatement pps = new PoolablePreparedStatement(
getDelegate().prepareStatement(key.getSql(), key.getAutoGeneratedKeys().intValue()), key, _pstmtPool, this);
return new DefaultPooledObject<DelegatingPreparedStatement>(pps);
} else { // Both _resultSetType and _resultSetConcurrency are non-null here (both or neither are set by constructors)
if(key.getStmtType() == StatementType.PREPARED_STATEMENT) {
@SuppressWarnings({"rawtypes", "unchecked"}) // Unable to find way to avoid this
+ final
PoolablePreparedStatement pps = new PoolablePreparedStatement(getDelegate().prepareStatement(
key.getSql(), key.getResultSetType().intValue(),key.getResultSetConcurrency().intValue()), key, _pstmtPool, this);
return new DefaultPooledObject<DelegatingPreparedStatement>(pps);
@@ -364,8 +367,8 @@ public class PoolingConnection extends D
* @throws Exception An error occurred
*/
@Override
- public void destroyObject(PStmtKey key,
- PooledObject<DelegatingPreparedStatement> p)
+ public void destroyObject(final PStmtKey key,
+ final PooledObject<DelegatingPreparedStatement> p)
throws Exception {
p.getObject().getInnermostDelegate().close();
}
@@ -379,8 +382,8 @@ public class PoolingConnection extends D
* @return {@code true}
*/
@Override
- public boolean validateObject(PStmtKey key,
- PooledObject<DelegatingPreparedStatement> p) {
+ public boolean validateObject(final PStmtKey key,
+ final PooledObject<DelegatingPreparedStatement> p) {
return true;
}
@@ -393,8 +396,8 @@ public class PoolingConnection extends D
* @throws Exception An error occurred
*/
@Override
- public void activateObject(PStmtKey key,
- PooledObject<DelegatingPreparedStatement> p) throws Exception {
+ public void activateObject(final PStmtKey key,
+ final PooledObject<DelegatingPreparedStatement> p) throws Exception {
p.getObject().activate();
}
@@ -408,9 +411,9 @@ public class PoolingConnection extends D
* @throws Exception An error occurred
*/
@Override
- public void passivateObject(PStmtKey key,
- PooledObject<DelegatingPreparedStatement> p) throws Exception {
- DelegatingPreparedStatement dps = p.getObject();
+ public void passivateObject(final PStmtKey key,
+ final PooledObject<DelegatingPreparedStatement> p) throws Exception {
+ final DelegatingPreparedStatement dps = p.getObject();
dps.clearParameters();
dps.passivate();
}
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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -49,20 +49,21 @@ public class PoolingDataSource<C extends
/** Controls access to the underlying connection */
private boolean accessToUnderlyingConnectionAllowed = false;
- public PoolingDataSource(ObjectPool<C> 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<?>) {
- PoolableConnectionFactory pcf = (PoolableConnectionFactory) ((GenericObjectPool<?>) _pool).getFactory();
+ final PoolableConnectionFactory pcf = (PoolableConnectionFactory) ((GenericObjectPool<?>) _pool).getFactory();
if (pcf == null) {
throw new NullPointerException("PoolableConnectionFactory must not be null.");
}
if (pcf.getPool() != _pool) {
log.warn(Utils.getMessage("poolingDataSource.factoryConfig"));
@SuppressWarnings("unchecked") // PCF must have a pool of PCs
+ final
ObjectPool<PoolableConnection> p = (ObjectPool<PoolableConnection>) _pool;
pcf.setPool(p);
}
@@ -77,9 +78,9 @@ public class PoolingDataSource<C extends
public void close() throws Exception {
try {
_pool.close();
- } catch(RuntimeException rte) {
+ } catch(final RuntimeException rte) {
throw new RuntimeException(Utils.getMessage("pool.close.fail"), rte);
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException(Utils.getMessage("pool.close.fail"), e);
}
}
@@ -100,18 +101,18 @@ public class PoolingDataSource<C extends
*
* @param allow Access to the underlying connection is granted when true.
*/
- public void setAccessToUnderlyingConnectionAllowed(boolean allow) {
+ public void setAccessToUnderlyingConnectionAllowed(final boolean allow) {
this.accessToUnderlyingConnectionAllowed = allow;
}
/* JDBC_4_ANT_KEY_BEGIN */
@Override
- public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ public boolean isWrapperFor(final Class<?> iface) throws SQLException {
return false;
}
@Override
- public <T> T unwrap(Class<T> iface) throws SQLException {
+ public <T> T unwrap(final Class<T> iface) throws SQLException {
throw new SQLException("PoolingDataSource is not a wrapper.");
}
/* JDBC_4_ANT_KEY_END */
@@ -130,18 +131,18 @@ public class PoolingDataSource<C extends
@Override
public Connection getConnection() throws SQLException {
try {
- C conn = _pool.borrowObject();
+ final C conn = _pool.borrowObject();
if (conn == null) {
return null;
}
return new PoolGuardConnectionWrapper<>(conn);
- } catch(SQLException e) {
+ } catch(final SQLException e) {
throw e;
- } catch(NoSuchElementException e) {
+ } catch(final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error " + e.getMessage(), e);
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot get a connection, general error", e);
}
}
@@ -151,7 +152,7 @@ public class PoolingDataSource<C extends
* @throws UnsupportedOperationException This is unsupported
*/
@Override
- public Connection getConnection(String uname, String passwd) throws SQLException {
+ public Connection getConnection(final String uname, final String passwd) throws SQLException {
throw new UnsupportedOperationException();
}
@@ -181,7 +182,7 @@ public class PoolingDataSource<C extends
* implementation does not support this feature.
*/
@Override
- public void setLoginTimeout(int seconds) {
+ public void setLoginTimeout(final int seconds) {
throw new UnsupportedOperationException("Login timeout is not supported.");
}
@@ -190,7 +191,7 @@ public class PoolingDataSource<C extends
* @see DataSource#setLogWriter
*/
@Override
- public void setLogWriter(PrintWriter out) {
+ public void setLogWriter(final PrintWriter out) {
_logWriter = out;
}
@@ -211,7 +212,7 @@ public class PoolingDataSource<C extends
private class PoolGuardConnectionWrapper<D extends Connection>
extends DelegatingConnection<D> {
- PoolGuardConnectionWrapper(D delegate) {
+ PoolGuardConnectionWrapper(final D delegate) {
super(delegate);
}
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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -47,7 +47,7 @@ public class PoolingDriver implements Dr
static {
try {
DriverManager.registerDriver(new PoolingDriver());
- } catch(Exception e) {
+ } catch(final Exception e) {
}
}
@@ -70,7 +70,7 @@ public class PoolingDriver implements Dr
* For unit testing purposes.
* @param accessToUnderlyingConnectionAllowed The new flag
*/
- protected PoolingDriver(boolean accessToUnderlyingConnectionAllowed) {
+ protected PoolingDriver(final boolean accessToUnderlyingConnectionAllowed) {
this.accessToUnderlyingConnectionAllowed = accessToUnderlyingConnectionAllowed;
}
@@ -85,66 +85,66 @@ public class PoolingDriver implements Dr
return accessToUnderlyingConnectionAllowed;
}
- public synchronized ObjectPool<? extends Connection> getConnectionPool(String name)
+ public synchronized ObjectPool<? extends Connection> getConnectionPool(final String name)
throws SQLException {
- ObjectPool<? extends Connection> pool = pools.get(name);
+ final ObjectPool<? extends Connection> pool = pools.get(name);
if (null == pool) {
throw new SQLException("Pool not registered.");
}
return pool;
}
- public synchronized void registerPool(String name,
- ObjectPool<? extends Connection> pool) {
+ public synchronized void registerPool(final String name,
+ final ObjectPool<? extends Connection> pool) {
pools.put(name,pool);
}
- public synchronized void closePool(String name) throws SQLException {
- ObjectPool<? extends Connection> pool = pools.get(name);
+ public synchronized void closePool(final String name) throws SQLException {
+ final ObjectPool<? extends Connection> pool = pools.get(name);
if (pool != null) {
pools.remove(name);
try {
pool.close();
}
- catch (Exception e) {
+ catch (final Exception e) {
throw new SQLException("Error closing pool " + name, e);
}
}
}
public synchronized String[] getPoolNames(){
- Set<String> names = pools.keySet();
+ final Set<String> names = pools.keySet();
return names.toArray(new String[names.size()]);
}
@Override
- public boolean acceptsURL(String url) throws SQLException {
+ public boolean acceptsURL(final String url) throws SQLException {
try {
return url.startsWith(URL_PREFIX);
- } catch(NullPointerException e) {
+ } catch(final NullPointerException e) {
return false;
}
}
@Override
- public Connection connect(String url, Properties info) throws SQLException {
+ public Connection connect(final String url, final Properties info) throws SQLException {
if(acceptsURL(url)) {
- ObjectPool<? extends Connection> pool =
+ final ObjectPool<? extends Connection> pool =
getConnectionPool(url.substring(URL_PREFIX_LEN));
try {
- Connection conn = pool.borrowObject();
+ final Connection conn = pool.borrowObject();
if (conn == null) {
return null;
}
return new PoolGuardConnectionWrapper(pool, conn);
- } catch(SQLException e) {
+ } catch(final SQLException e) {
throw e;
- } catch(NoSuchElementException e) {
+ } catch(final NoSuchElementException e) {
throw new SQLException("Cannot get a connection, pool error: " + e.getMessage(), e);
- } catch(RuntimeException e) {
+ } catch(final RuntimeException e) {
throw e;
- } catch(Exception e) {
+ } catch(final Exception e) {
throw new SQLException("Cannot get a connection, general error: " + e.getMessage(), e);
}
}
@@ -164,15 +164,16 @@ public class PoolingDriver implements Dr
* <code>PoolGuardConnectionWrapper</code> or an error occurs invalidating
* the connection
*/
- public void invalidateConnection(Connection conn) throws SQLException {
+ public void invalidateConnection(final Connection conn) throws SQLException {
if (conn instanceof PoolGuardConnectionWrapper) { // normal case
- PoolGuardConnectionWrapper pgconn = (PoolGuardConnectionWrapper) conn;
+ final PoolGuardConnectionWrapper pgconn = (PoolGuardConnectionWrapper) conn;
@SuppressWarnings("unchecked")
+ final
ObjectPool<Connection> pool = (ObjectPool<Connection>) pgconn.pool;
try {
pool.invalidateObject(pgconn.getDelegateInternal());
}
- catch (Exception e) {
+ catch (final Exception e) {
}
}
else {
@@ -196,7 +197,7 @@ public class PoolingDriver implements Dr
}
@Override
- public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
+ public DriverPropertyInfo[] getPropertyInfo(final String url, final Properties info) {
return new DriverPropertyInfo[0];
}
@@ -217,8 +218,8 @@ public class PoolingDriver implements Dr
private final ObjectPool<? extends Connection> pool;
- PoolGuardConnectionWrapper(ObjectPool<? extends Connection> pool,
- 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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -34,7 +34,7 @@ public class SwallowedExceptionLogger im
*
* @param log logger
*/
- public SwallowedExceptionLogger(Log log) {
+ public SwallowedExceptionLogger(final Log log) {
this(log, true);
}
@@ -45,13 +45,13 @@ public class SwallowedExceptionLogger im
* @param log logger
* @param logExpiredConnections false suppresses logging of expired connection events
*/
- public SwallowedExceptionLogger(Log log, boolean logExpiredConnections) {
+ public SwallowedExceptionLogger(final Log log, final boolean logExpiredConnections) {
this.log = log;
this.logExpiredConnections = logExpiredConnections;
}
@Override
- public void onSwallowException(Exception e) {
+ public void onSwallowException(final Exception e) {
if (logExpiredConnections || !(e instanceof LifetimeExceededException)) {
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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -73,11 +73,11 @@ public final class Utils {
*
* @param rset a ResultSet, may be {@code null}
*/
- public static void closeQuietly(ResultSet rset) {
+ public static void closeQuietly(final ResultSet rset) {
if (rset != null) {
try {
rset.close();
- } catch (Exception e) {
+ } catch (final Exception e) {
// ignored
}
}
@@ -88,11 +88,11 @@ public final class Utils {
*
* @param conn a Connection, may be {@code null}
*/
- public static void closeQuietly(Connection conn) {
+ public static void closeQuietly(final Connection conn) {
if (conn != null) {
try {
conn.close();
- } catch (Exception e) {
+ } catch (final Exception e) {
// ignored
}
}
@@ -103,11 +103,11 @@ public final class Utils {
*
* @param stmt a Statement, may be {@code null}
*/
- public static void closeQuietly(Statement stmt) {
+ public static void closeQuietly(final Statement stmt) {
if (stmt != null) {
try {
stmt.close();
- } catch (Exception e) {
+ } catch (final Exception e) {
// ignored
}
}
@@ -119,7 +119,7 @@ public final class Utils {
* @param key The message key
* @return the message
*/
- public static String getMessage(String key) {
+ public static String getMessage(final String key) {
return getMessage(key, (Object[]) null);
}
@@ -131,12 +131,12 @@ public final class Utils {
* @param args The arguments
* @return the message
*/
- public static String getMessage(String key, Object... args) {
- String msg = messages.getString(key);
+ public static String getMessage(final String key, final Object... args) {
+ final String msg = messages.getString(key);
if (args == null || args.length == 0) {
return msg;
}
- MessageFormat mf = new MessageFormat(msg);
+ final MessageFormat mf = new MessageFormat(msg);
return mf.format(args, new StringBuffer(), null).toString();
}
}
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=1743719&r1=1743718&r2=1743719&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 Fri May 13 18:49:32 2016
@@ -27,9 +27,9 @@ import org.apache.tomcat.dbcp.dbcp2.Dele
/**
* 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>.
+ * 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
+ * In accordance with the JDBC specification this Connection cannot
* be used after closed() is called. Any further usage will result in an
* SQLException.
*
@@ -53,9 +53,9 @@ class ConnectionImpl extends DelegatingC
* @param connection The JDBC 1.x Connection to wrap.
* @param accessToUnderlyingConnectionAllowed if true, then access is allowed to the underlying connection
*/
- ConnectionImpl(PooledConnectionImpl pooledConnection,
- Connection connection,
- boolean accessToUnderlyingConnectionAllowed) {
+ ConnectionImpl(final PooledConnectionImpl pooledConnection,
+ final Connection connection,
+ final boolean accessToUnderlyingConnectionAllowed) {
super(connection);
this.pooledConnection = pooledConnection;
this.accessToUnderlyingConnectionAllowed =
@@ -65,7 +65,7 @@ class ConnectionImpl extends DelegatingC
/**
* Marks the Connection as closed, and notifies the pool that the
* pooled connection is available.
- * In accordance with the jdbc specification this Connection cannot
+ * In accordance with the JDBC specification this Connection cannot
* be used after closed() is called. Any further usage will result in an
* SQLException.
*
@@ -86,7 +86,7 @@ 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}.
+ * delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @param sql SQL statement to be prepared
* @return the prepared statement
@@ -94,13 +94,13 @@ class ConnectionImpl extends DelegatingC
* in the wrapped connection.
*/
@Override
- public PreparedStatement prepareStatement(String sql) throws SQLException {
+ public PreparedStatement prepareStatement(final String sql) throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement
(this, pooledConnection.prepareStatement(sql));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e); // Does not return
return null;
}
@@ -109,14 +109,14 @@ 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}.
+ * delegate to the wrapped JDBC 1.x {@link java.sql.Connection}.
*
* @exception SQLException if this connection is closed or an error occurs
* in the wrapped connection.
*/
@Override
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency)
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType,
+ final int resultSetConcurrency)
throws SQLException {
checkOpen();
try {
@@ -124,16 +124,16 @@ class ConnectionImpl extends DelegatingC
(this, pooledConnection.prepareStatement
(sql,resultSetType,resultSetConcurrency));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(String sql, int resultSetType,
- int resultSetConcurrency,
- int resultSetHoldability)
+ public PreparedStatement prepareStatement(final String sql, final int resultSetType,
+ final int resultSetConcurrency,
+ final int resultSetHoldability)
throws SQLException {
checkOpen();
try {
@@ -141,49 +141,49 @@ class ConnectionImpl extends DelegatingC
pooledConnection.prepareStatement(sql, resultSetType,
resultSetConcurrency, resultSetHoldability));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
+ public PreparedStatement prepareStatement(final String sql, final int autoGeneratedKeys)
throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
pooledConnection.prepareStatement(sql, autoGeneratedKeys));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(String sql, int columnIndexes[])
+ public PreparedStatement prepareStatement(final String sql, final int columnIndexes[])
throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
pooledConnection.prepareStatement(sql, columnIndexes));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
}
@Override
- public PreparedStatement prepareStatement(String sql, String columnNames[])
+ public PreparedStatement prepareStatement(final String sql, final String columnNames[])
throws SQLException {
checkOpen();
try {
return new DelegatingPreparedStatement(this,
pooledConnection.prepareStatement(sql, columnNames));
}
- catch (SQLException e) {
+ catch (final SQLException e) {
handleException(e);
return null;
}
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@tomcat.apache.org
For additional commands, e-mail: dev-help@tomcat.apache.org