ConnectionPool (Apache Tomcat 7.0.109 API Documentation)

java.lang.Object
- javax.management.NotificationBroadcasterSupport
- - org.apache.tomcat.jdbc.pool.jmx.ConnectionPool

All Implemented Interfaces:

NotificationBroadcaster, NotificationEmitter, ConnectionPoolMBean, PoolConfiguration
```
public class ConnectionPool
extends NotificationBroadcasterSupport
implements ConnectionPoolMBean
```

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`FAILED_QUERY_NOTIFICATION`
`protected ConcurrentLinkedQueue<NotificationListener>`	`listeners` Listeners that are local and interested in our notifications, no need for JMX
`static String`	`NOTIFY_ABANDON`
`static String`	`NOTIFY_CONNECT`
`static String`	`NOTIFY_INIT`
`protected ConnectionPool`	`pool` the connection pool
`static String`	`POOL_EMPTY`
`protected AtomicInteger`	`sequence` sequence for JMX notifications
`static String`	`SLOW_QUERY_NOTIFICATION`
`static String`	`SUSPECT_ABANDONED_NOTIFICATION`
`static String`	`SUSPECT_RETURNED_NOTIFICATION`

Fields inherited from interface org.apache.tomcat.jdbc.pool.PoolConfiguration
PKG_PREFIX

Constructor Summary

Constructors
Constructor and Description

ConnectionPool(ConnectionPool pool)

Constructors
Constructor and Description
`ConnectionPool(ConnectionPool pool)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addListener(NotificationListener list)`
`void`	`checkAbandoned()`
`void`	`checkIdle()`
`int`	`getAbandonWhenPercentageFull()` Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull.
`int`	`getActive()`
`long`	`getBorrowedCount()`
`boolean`	`getCommitOnReturn()`
`String`	`getConnectionProperties()` The connection properties that will be sent to the JDBC driver when establishing new connections.
`long`	`getCreatedCount()`
`Object`	`getDataSource()` Returns a datasource, if one exists that is being used to create connections.
`String`	`getDataSourceJNDI()` Returns the JNDI string configured for data source usage.
`Properties`	`getDbProperties()` Returns the database properties that are passed into the `Driver.connect(String, Properties)` method.
`Boolean`	`getDefaultAutoCommit()` The default auto-commit state of connections created by this pool.
`String`	`getDefaultCatalog()` If non null, during connection creation the method `Connection.setCatalog(String)` will be called with the set value.
`static MBeanNotificationInfo[]`	`getDefaultNotificationInfo()`
`Boolean`	`getDefaultReadOnly()` If non null, during connection creation the method `Connection.setReadOnly(boolean)` will be called with the set value.
`int`	`getDefaultTransactionIsolation()` Returns the default transaction isolation level.
`String`	`getDriverClassName()` The fully qualified Java class name of the JDBC driver to be used.
`int`	`getIdle()`
`int`	`getInitialSize()` Returns the number of connections that will be established when the connection pool is started.
`String`	`getInitSQL()` A custom query to be run when a connection is first created.
`String`	`getJdbcInterceptors()` A semicolon separated list of classnames extending `JdbcInterceptor` class.
`PoolProperties.InterceptorDefinition[]`	`getJdbcInterceptorsAsArray()` Returns the `PoolConfiguration.getJdbcInterceptors()` as an array of objects with properties and the classes.
`boolean`	`getLogValidationErrors()` Returns true if errors that happen during validation will be logged
`int`	`getMaxActive()` The maximum number of active connections that can be allocated from this pool at the same time.
`long`	`getMaxAge()` Time in milliseconds to keep this connection before reconnecting.
`int`	`getMaxIdle()` The maximum number of connections that should be kept in the idle pool if `PoolConfiguration.isPoolSweeperEnabled()` returns false.
`int`	`getMaxWait()` The maximum number of milliseconds that the pool will wait (when there are no available connections and the `PoolConfiguration.getMaxActive()` has been reached) for a connection to be returned before throwing an exception.
`int`	`getMinEvictableIdleTimeMillis()` The minimum amount of time an object must sit idle in the pool before it is eligible for eviction.
`int`	`getMinIdle()` The minimum number of established connections that should be kept in the pool at all times.
`String`	`getName()` Returns the name of the connection pool.
`MBeanNotificationInfo[]`	`getNotificationInfo()`
`int`	`getNumActive()`
`int`	`getNumIdle()`
`int`	`getNumTestsPerEvictionRun()` Property not used
`String`	`getPassword()` Returns the password used when establishing connections to the database.
`ConnectionPool`	`getPool()`
`String`	`getPoolName()`
`PoolConfiguration`	`getPoolProperties()`
`boolean`	`getPropagateInterruptState()` Returns true if the pool is configured to propagate interrupt state of a thread.
`long`	`getReconnectedCount()`
`long`	`getReleasedCount()`
`long`	`getReleasedIdleCount()`
`long`	`getRemoveAbandonedCount()`
`int`	`getRemoveAbandonedTimeout()` The time in seconds before a connection can be considered abandoned.
`long`	`getReturnedCount()`
`boolean`	`getRollbackOnReturn()`
`int`	`getSize()`
`int`	`getSuspectTimeout()` Returns the time in seconds to pass before a connection is marked an abandoned suspect.
`int`	`getTimeBetweenEvictionRunsMillis()` The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing.
`String`	`getUrl()` The URL used to connect to the database
`boolean`	`getUseDisposableConnectionFacade()` Returns `true` if this connection pool is configured to use a connection facade to prevent re-use of connection after `Connection.close()` has been invoked
`boolean`	`getUseLock()` Return true if a lock should be used when operations are performed on the connection object.
`String`	`getUsername()` Returns the username used to establish the connection with
`boolean`	`getUseStatementFacade()` Returns `true` if this connection pool is configured to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
`long`	`getValidationInterval()` avoid excess validation, only run validation at most at this frequency - time in milliseconds.
`String`	`getValidationQuery()` The SQL query that will be used to validate connections from this pool before returning them to the caller or pool.
`int`	`getValidationQueryTimeout()` The timeout in seconds before a connection validation queries fail.
`Validator`	`getValidator()`
`String`	`getValidatorClassName()` Return the name of the optional validator class - may be null.
`int`	`getWaitCount()`
`boolean`	`isAccessToUnderlyingConnectionAllowed()` Property not used.
`boolean`	`isAlternateUsernameAllowed()` Returns true if the call `getConnection(username,password)` is allowed.
`Boolean`	`isDefaultAutoCommit()` The default auto-commit state of connections created by this pool.
`Boolean`	`isDefaultReadOnly()` If non null, during connection creation the method `Connection.setReadOnly(boolean)` will be called with the set value.
`boolean`	`isFairQueue()` Returns `true` if a fair queue is being used by the connection pool
`boolean`	`isIgnoreExceptionOnPreLoad()`
`boolean`	`isJmxEnabled()` If set to true, the connection pool creates a `ConnectionPoolMBean` object that can be registered with JMX to receive notifications and state about the pool.
`boolean`	`isLogAbandoned()` boolean flag to set if stack traces should be logged for application code which abandoned a Connection.
`boolean`	`isPoolSweeperEnabled()` Returns true if the pool sweeper is enabled for the connection pool.
`boolean`	`isRemoveAbandoned()` boolean flag to remove abandoned connections if they exceed the removeAbandonedTimeout.
`boolean`	`isTestOnBorrow()` The indication of whether objects will be validated before being borrowed from the pool.
`boolean`	`isTestOnConnect()` Returns true if we should run the validation query when connecting to the database for the first time on a connection.
`boolean`	`isTestOnReturn()` The indication of whether objects will be validated after being returned to the pool.
`boolean`	`isTestWhileIdle()` Set to true if query validation should take place while the connection is idle.
`boolean`	`isUseEquals()` Set to true if you wish the `ProxyConnection` class to use `String.equals` instead of `==` when comparing method names.
`boolean`	`notify(String type, String message)` Return true if the notification was sent successfully, false otherwise.
`void`	`purge()` Purges all connections in the pool.
`void`	`purgeOnReturn()` Purges connections when they are returned from the pool.
`boolean`	`removeListener(NotificationListener list)`
`void`	`resetStats()` reset the statistics of this pool.
`void`	`setAbandonWhenPercentageFull(int percentage)` Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull.
`void`	`setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed)` No-op
`void`	`setAlternateUsernameAllowed(boolean alternateUsernameAllowed)` Set to true if the call `getConnection(username,password)` is allowed and honored..
`void`	`setCommitOnReturn(boolean commitOnReturn)` Set to true if you want the connection pool to commit any pending transaction when a connection is returned.
`void`	`setConnectionProperties(String connectionProperties)` The properties that will be passed into `Driver.connect(String, Properties)` method.
`void`	`setDataSource(Object ds)` Injects a datasource that will be used to retrieve/create connections.
`void`	`setDataSourceJNDI(String jndiDS)` Configure the connection pool to use a DataSource according to `PoolConfiguration.setDataSource(Object)` But instead of injecting the object, specify the JNDI location.
`void`	`setDbProperties(Properties dbProperties)` Overrides the database properties passed into the `Driver.connect(String, Properties)` method.
`void`	`setDefaultAutoCommit(Boolean defaultAutoCommit)` The default auto-commit state of connections created by this pool.
`void`	`setDefaultCatalog(String defaultCatalog)` If non null, during connection creation the method `Connection.setCatalog(String)` will be called with the set value.
`void`	`setDefaultReadOnly(Boolean defaultReadOnly)` If non null, during connection creation the method `Connection.setReadOnly(boolean)` will be called with the set value.
`void`	`setDefaultTransactionIsolation(int defaultTransactionIsolation)` If set to `DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION` the method `Connection.setTransactionIsolation(int)` will not be called during connection creation.
`void`	`setDriverClassName(String driverClassName)` The fully qualified Java class name of the JDBC driver to be used.
`void`	`setFairQueue(boolean fairQueue)` Set to true if you wish that calls to getConnection should be treated fairly in a true FIFO fashion.
`void`	`setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad)` Set to true if you want to ignore error of connection creation while initializing the pool.
`void`	`setInitialSize(int initialSize)` Set the number of connections that will be established when the connection pool is started.
`void`	`setInitSQL(String initSQL)` A custom query to be run when a connection is first created.
`void`	`setJdbcInterceptors(String jdbcInterceptors)` A semicolon separated list of classnames extending `JdbcInterceptor` class.
`void`	`setJmxEnabled(boolean jmxEnabled)` If set to true, the connection pool creates a `ConnectionPoolMBean` object that can be registered with JMX to receive notifications and state about the pool.
`void`	`setLogAbandoned(boolean logAbandoned)` boolean flag to set if stack traces should be logged for application code which abandoned a Connection.
`void`	`setLogValidationErrors(boolean logValidationErrors)` Set to true if you wish that errors from validation should be logged as error messages.
`void`	`setMaxActive(int maxActive)` The maximum number of active connections that can be allocated from this pool at the same time.
`void`	`setMaxAge(long maxAge)` Time in milliseconds to keep this connection before reconnecting.
`void`	`setMaxIdle(int maxIdle)` The maximum number of connections that should be kept in the idle pool if `PoolConfiguration.isPoolSweeperEnabled()` returns false.
`void`	`setMaxWait(int maxWait)` The maximum number of milliseconds that the pool will wait (when there are no available connections and the `PoolConfiguration.getMaxActive()` has been reached) for a connection to be returned before throwing an exception.
`void`	`setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis)` The minimum amount of time an object must sit idle in the pool before it is eligible for eviction.
`void`	`setMinIdle(int minIdle)` The minimum number of established connections that should be kept in the pool at all times.
`void`	`setName(String name)` Sets the name of the connection pool
`void`	`setNumTestsPerEvictionRun(int numTestsPerEvictionRun)` Property not used
`void`	`setPassword(String password)` Sets the password to establish the connection with.
`void`	`setPropagateInterruptState(boolean propagateInterruptState)` Configure the pool to propagate interrupt state for interrupted threads waiting for a connection A thread waiting for a connection, can have its wait interrupted, and by default will clear the interrupt flag and throw a `PoolExhaustedException` If set to true, this behavior will change, while the `PoolExhaustedException` is still thrown, the threads interrupted state is still set.
`void`	`setRemoveAbandoned(boolean removeAbandoned)` boolean flag to remove abandoned connections if they exceed the removeAbandonedTimeout.
`void`	`setRemoveAbandonedTimeout(int removeAbandonedTimeout)` The time in seconds before a connection can be considered abandoned.
`void`	`setRollbackOnReturn(boolean rollbackOnReturn)` Set to true if you want the connection pool to rollback any pending transaction when a connection is returned.
`void`	`setSuspectTimeout(int seconds)` Similar to `PoolConfiguration.setRemoveAbandonedTimeout(int)` but instead of treating the connection as abandoned, and potentially closing the connection, this simply logs the warning if `PoolConfiguration.isLogAbandoned()` returns true.
`void`	`setTestOnBorrow(boolean testOnBorrow)` The indication of whether objects will be validated before being borrowed from the pool.
`void`	`setTestOnConnect(boolean testOnConnect)` Set to true if we should run the validation query when connecting to the database for the first time on a connection.
`void`	`setTestOnReturn(boolean testOnReturn)` The indication of whether objects will be validated after being returned to the pool.
`void`	`setTestWhileIdle(boolean testWhileIdle)` Set to true if query validation should take place while the connection is idle.
`void`	`setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis)` The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing.
`void`	`setUrl(String url)` Sets the URL used to connect to the database
`void`	`setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade)` If set to `true`, the connection will be wrapped with facade that will disallow the connection to be used after `Connection.close()` is called.
`void`	`setUseEquals(boolean useEquals)` Set to true if you wish the `ProxyConnection` class to use `String.equals` instead of `==` when comparing method names.
`void`	`setUseLock(boolean useLock)` Set to true if a lock should be used when operations are performed on the connection object.
`void`	`setUsername(String username)` Sets the username used to establish the connection with It will also be a property called 'user' in the database properties.
`void`	`setUseStatementFacade(boolean useStatementFacade)` Set this to true if you wish to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
`void`	`setValidationInterval(long validationInterval)` avoid excess validation, only run validation at most at this frequency - time in milliseconds.
`void`	`setValidationQuery(String validationQuery)` The SQL query that will be used to validate connections from this pool before returning them to the caller or pool.
`void`	`setValidationQueryTimeout(int validationQueryTimeout)` The timeout in seconds before a connection validation queries fail.
`void`	`setValidator(Validator validator)` Sets the validator object If this is a non null object, it will be used as a validator instead of the validationQuery If this is null, remove the usage of the validator.
`void`	`setValidatorClassName(String className)` Set the name for an optional validator class which will be used in place of test queries.
`void`	`testIdle()`

Methods inherited from class javax.management.NotificationBroadcasterSupport
addNotificationListener, handleNotification, removeNotificationListener, removeNotificationListener, sendNotification

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - pool
```
protected ConnectionPool pool
```
    the connection pool
  - sequence
```
protected AtomicInteger sequence
```
    sequence for JMX notifications
  - listeners
```
protected ConcurrentLinkedQueue<NotificationListener> listeners
```
    Listeners that are local and interested in our notifications, no need for JMX
  - NOTIFY_INIT
```
public static final String NOTIFY_INIT
```
    See Also:
    Constant Field Values
  - NOTIFY_CONNECT
```
public static final String NOTIFY_CONNECT
```
    See Also:
    Constant Field Values
  - NOTIFY_ABANDON
```
public static final String NOTIFY_ABANDON
```
    See Also:
    Constant Field Values
  - SLOW_QUERY_NOTIFICATION
```
public static final String SLOW_QUERY_NOTIFICATION
```
    See Also:
    Constant Field Values
  - FAILED_QUERY_NOTIFICATION
```
public static final String FAILED_QUERY_NOTIFICATION
```
    See Also:
    Constant Field Values
  - SUSPECT_ABANDONED_NOTIFICATION
```
public static final String SUSPECT_ABANDONED_NOTIFICATION
```
    See Also:
    Constant Field Values
  - POOL_EMPTY
```
public static final String POOL_EMPTY
```
    See Also:
    Constant Field Values
  - SUSPECT_RETURNED_NOTIFICATION
```
public static final String SUSPECT_RETURNED_NOTIFICATION
```
    See Also:
    Constant Field Values
- Constructor Detail
  - ConnectionPool
```
public ConnectionPool(ConnectionPool pool)
```
- Method Detail
  - getPool
```
public ConnectionPool getPool()
```
  - getPoolProperties
```
public PoolConfiguration getPoolProperties()
```
  - getNotificationInfo
```
public MBeanNotificationInfo[] getNotificationInfo()
```
    Specified by:
    
    getNotificationInfo in interface NotificationBroadcaster
    
    Overrides:
    
    getNotificationInfo in class NotificationBroadcasterSupport
  - getDefaultNotificationInfo
```
public static MBeanNotificationInfo[] getDefaultNotificationInfo()
```
  - notify
```
public boolean notify(String type,
             String message)
```
    Return true if the notification was sent successfully, false otherwise.
    
    Parameters:
    type -
    message -
    
    Returns:
    true if the notification succeeded
  - addListener
```
public void addListener(NotificationListener list)
```
  - removeListener
```
public boolean removeListener(NotificationListener list)
```
  - getSize
```
public int getSize()
```
    Specified by:
    
    getSize in interface ConnectionPoolMBean
  - getIdle
```
public int getIdle()
```
    Specified by:
    
    getIdle in interface ConnectionPoolMBean
  - getActive
```
public int getActive()
```
    Specified by:
    
    getActive in interface ConnectionPoolMBean
  - getNumIdle
```
public int getNumIdle()
```
    Specified by:
    
    getNumIdle in interface ConnectionPoolMBean
  - getNumActive
```
public int getNumActive()
```
    Specified by:
    
    getNumActive in interface ConnectionPoolMBean
  - getWaitCount
```
public int getWaitCount()
```
    Specified by:
    
    getWaitCount in interface ConnectionPoolMBean
  - getBorrowedCount
```
public long getBorrowedCount()
```
    Specified by:
    
    getBorrowedCount in interface ConnectionPoolMBean
  - getReturnedCount
```
public long getReturnedCount()
```
    Specified by:
    
    getReturnedCount in interface ConnectionPoolMBean
  - getCreatedCount
```
public long getCreatedCount()
```
    Specified by:
    
    getCreatedCount in interface ConnectionPoolMBean
  - getReleasedCount
```
public long getReleasedCount()
```
    Specified by:
    
    getReleasedCount in interface ConnectionPoolMBean
  - getReconnectedCount
```
public long getReconnectedCount()
```
    Specified by:
    
    getReconnectedCount in interface ConnectionPoolMBean
  - getRemoveAbandonedCount
```
public long getRemoveAbandonedCount()
```
    Specified by:
    
    getRemoveAbandonedCount in interface ConnectionPoolMBean
  - getReleasedIdleCount
```
public long getReleasedIdleCount()
```
    Specified by:
    
    getReleasedIdleCount in interface ConnectionPoolMBean
  - checkIdle
```
public void checkIdle()
```
    Specified by:
    
    checkIdle in interface ConnectionPoolMBean
  - checkAbandoned
```
public void checkAbandoned()
```
    Specified by:
    
    checkAbandoned in interface ConnectionPoolMBean
  - testIdle
```
public void testIdle()
```
    Specified by:
    
    testIdle in interface ConnectionPoolMBean
  - resetStats
```
public void resetStats()
```
    Description copied from interface: ConnectionPoolMBean
    
    reset the statistics of this pool.
    
    Specified by:
    
    resetStats in interface ConnectionPoolMBean
  - getConnectionProperties
```
public String getConnectionProperties()
```
    Description copied from interface: PoolConfiguration
    
    The connection properties that will be sent to the JDBC driver when establishing new connections. Format of the string is [propertyName=property;]
    NOTE - The "user" and "password" properties will be passed explicitly, so they do not need to be included here. The default value is null.
    
    Specified by:
    
    getConnectionProperties in interface PoolConfiguration
    
    Returns:
    the connection properties
  - getDbProperties
```
public Properties getDbProperties()
```
    Description copied from interface: PoolConfiguration
    
    Returns the database properties that are passed into the Driver.connect(String, Properties) method.
    
    Specified by:
    
    getDbProperties in interface PoolConfiguration
    
    Returns:
    database properties that are passed into the Driver.connect(String, Properties) method.
  - getDefaultCatalog
```
public String getDefaultCatalog()
```
    Description copied from interface: PoolConfiguration
    
    If non null, during connection creation the method Connection.setCatalog(String) will be called with the set value.
    
    Specified by:
    
    getDefaultCatalog in interface PoolConfiguration
    
    Returns:
    the default catalog, null if not set and accepting the driver default.
  - getDefaultTransactionIsolation
```
public int getDefaultTransactionIsolation()
```
    Description copied from interface: PoolConfiguration
    
    Returns the default transaction isolation level. If set to DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION the method Connection.setTransactionIsolation(int) will not be called during connection creation.
    
    Specified by:
    
    getDefaultTransactionIsolation in interface PoolConfiguration
    
    Returns:
    driver transaction isolation level, or -1 DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION if not set.
  - getDriverClassName
```
public String getDriverClassName()
```
    Description copied from interface: PoolConfiguration
    
    The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
    
    Specified by:
    
    getDriverClassName in interface PoolConfiguration
    
    Returns:
    fully qualified JDBC driver name.
  - getInitialSize
```
public int getInitialSize()
```
    Description copied from interface: PoolConfiguration
    
    Returns the number of connections that will be established when the connection pool is started. Default value is 10
    
    Specified by:
    
    getInitialSize in interface PoolConfiguration
    
    Returns:
    number of connections to be started when pool is started
  - getInitSQL
```
public String getInitSQL()
```
    Description copied from interface: PoolConfiguration
    
    A custom query to be run when a connection is first created. The default value is null. This query only runs once per connection, and that is when a new connection is established to the database. If this value is non null, it will replace the validation query during connection creation.
    
    Specified by:
    
    getInitSQL in interface PoolConfiguration
    
    Returns:
    the init SQL used to run against the DB or null if not set
  - getJdbcInterceptors
```
public String getJdbcInterceptors()
```
    Description copied from interface: PoolConfiguration
    
    A semicolon separated list of classnames extending JdbcInterceptor class. These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object. Example interceptors are StatementFinalizer to close all used statements during the session. ResetAbandonedTimer resets the timer upon every operation on the connection or a statement. ConnectionState caches the auto commit, read only and catalog settings to avoid round trips to the DB. The default value is null.
    
    Specified by:
    
    getJdbcInterceptors in interface PoolConfiguration
    
    Returns:
    the interceptors that are used for connections. Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
  - getMaxActive
```
public int getMaxActive()
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
    
    Specified by:
    
    getMaxActive in interface PoolConfiguration
    
    Returns:
    the maximum number of connections used by this pool
  - getMaxIdle
```
public int getMaxIdle()
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of connections that should be kept in the idle pool if PoolConfiguration.isPoolSweeperEnabled() returns false. If the If PoolConfiguration.isPoolSweeperEnabled() returns true, then the idle pool can grow up to PoolConfiguration.getMaxActive() and will be shrunk according to PoolConfiguration.getMinEvictableIdleTimeMillis() setting. Default value is maxActive:100
    
    Specified by:
    
    getMaxIdle in interface PoolConfiguration
    
    Returns:
    the maximum number of idle connections.
  - getMaxWait
```
public int getMaxWait()
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of milliseconds that the pool will wait (when there are no available connections and the PoolConfiguration.getMaxActive() has been reached) for a connection to be returned before throwing an exception. Default value is 30000 (30 seconds)
    
    Specified by:
    
    getMaxWait in interface PoolConfiguration
    
    Returns:
    the number of milliseconds to wait for a connection to become available if the pool is maxed out.
  - getMinEvictableIdleTimeMillis
```
public int getMinEvictableIdleTimeMillis()
```
    Description copied from interface: PoolConfiguration
    
    The minimum amount of time an object must sit idle in the pool before it is eligible for eviction. The default value is 60000 (60 seconds).
    
    Specified by:
    
    getMinEvictableIdleTimeMillis in interface PoolConfiguration
    
    Returns:
    the minimum amount of idle time in milliseconds before a connection is considered idle and eligible for eviction.
  - getMinIdle
```
public int getMinIdle()
```
    Description copied from interface: PoolConfiguration
    
    The minimum number of established connections that should be kept in the pool at all times. The connection pool can shrink below this number if validation queries fail and connections get closed. Default value is derived from PoolConfiguration.getInitialSize() (also see PoolConfiguration.setTestWhileIdle(boolean) The idle pool will not shrink below this value during an eviction run, hence the number of actual connections can be between PoolConfiguration.getMinIdle() and somewhere between PoolConfiguration.getMaxIdle() and PoolConfiguration.getMaxActive()
    
    Specified by:
    
    getMinIdle in interface PoolConfiguration
    
    Returns:
    the minimum number of idle or established connections
  - getMaxAge
```
public long getMaxAge()
```
    Description copied from interface: PoolConfiguration
    
    Time in milliseconds to keep this connection before reconnecting. When a connection is idle, returned to the pool or borrowed from the pool, the pool will check to see if the ((now - time-when-connected) > maxAge) has been reached, and if so, it reconnects. Note that the age of idle connections will only be checked if PoolConfiguration.getTimeBetweenEvictionRunsMillis() returns a value greater than 0. The default value is 0, which implies that connections will be left open and no age checks will be done. This is a useful setting for database sessions that leak memory as it ensures that the session will have a finite life span.
    
    Specified by:
    
    getMaxAge in interface PoolConfiguration
    
    Returns:
    the time in milliseconds a connection will be open for when used
  - getName
```
public String getName()
```
    Description copied from interface: PoolConfiguration
    
    Returns the name of the connection pool. By default a JVM unique random name is assigned.
    
    Specified by:
    
    getName in interface PoolConfiguration
    
    Returns:
    the name of the pool, should be unique in a JVM
  - getNumTestsPerEvictionRun
```
public int getNumTestsPerEvictionRun()
```
    Description copied from interface: PoolConfiguration
    
    Property not used
    
    Specified by:
    
    getNumTestsPerEvictionRun in interface PoolConfiguration
    
    Returns:
    unknown value
  - getPassword
```
public String getPassword()
```
    Description copied from interface: PoolConfiguration
    
    Returns the password used when establishing connections to the database.
    
    Specified by:
    
    getPassword in interface PoolConfiguration
    
    Returns:
    DOES NOT RETURN THE PASSWORD, IT WOULD SHOW UP IN JMX
  - getRemoveAbandonedTimeout
```
public int getRemoveAbandonedTimeout()
```
    Description copied from interface: PoolConfiguration
    
    The time in seconds before a connection can be considered abandoned. The timer can be reset upon queries using an interceptor.
    
    Specified by:
    
    getRemoveAbandonedTimeout in interface PoolConfiguration
    
    Returns:
    the time in seconds before a used connection can be considered abandoned
    See Also:
    ResetAbandonedTimer
  - getTimeBetweenEvictionRunsMillis
```
public int getTimeBetweenEvictionRunsMillis()
```
    Description copied from interface: PoolConfiguration
    
    The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing. This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool. The default value is 5000 (5 seconds)
    
    Specified by:
    
    getTimeBetweenEvictionRunsMillis in interface PoolConfiguration
    
    Returns:
    the sleep time in between validations in milliseconds
  - getUrl
```
public String getUrl()
```
    Description copied from interface: PoolConfiguration
    
    The URL used to connect to the database
    
    Specified by:
    
    getUrl in interface PoolConfiguration
    
    Returns:
    the configured URL for this connection pool
    See Also:
    Driver.connect(String, Properties)
  - getUsername
```
public String getUsername()
```
    Description copied from interface: PoolConfiguration
    
    Returns the username used to establish the connection with
    
    Specified by:
    
    getUsername in interface PoolConfiguration
    
    Returns:
    the username used to establish the connection with
  - getValidationInterval
```
public long getValidationInterval()
```
    Description copied from interface: PoolConfiguration
    
    avoid excess validation, only run validation at most at this frequency - time in milliseconds. If a connection is due for validation, but has been validated previously within this interval, it will not be validated again. The default value is 3000 (3 seconds).
    
    Specified by:
    
    getValidationInterval in interface PoolConfiguration
    
    Returns:
    the validation interval in milliseconds
  - getValidationQuery
```
public String getValidationQuery()
```
    Description copied from interface: PoolConfiguration
    
    The SQL query that will be used to validate connections from this pool before returning them to the caller or pool. If specified, this query does not have to return any data, it just can't throw an SQLException. The default value is null. Example values are SELECT 1(mysql), select 1 from dual(oracle), SELECT 1(MS Sql Server)
    
    Specified by:
    
    getValidationQuery in interface PoolConfiguration
    
    Returns:
    the query used for validation or null if no validation is performed
  - getValidationQueryTimeout
```
public int getValidationQueryTimeout()
```
    Description copied from interface: PoolConfiguration
    
    The timeout in seconds before a connection validation queries fail. A value less than or equal to zero will disable this feature. Defaults to -1.
    
    Specified by:
    
    getValidationQueryTimeout in interface PoolConfiguration
    
    Returns:
    the timeout value in seconds
  - getValidatorClassName
```
public String getValidatorClassName()
```
    Return the name of the optional validator class - may be null.
    
    Specified by:
    
    getValidatorClassName in interface PoolConfiguration
    
    Returns:
    the name of the optional validator class - may be null
  - getValidator
```
public Validator getValidator()
```
    Specified by:
    
    getValidator in interface PoolConfiguration
    
    Returns:
    the optional validator object - may be null
  - isAccessToUnderlyingConnectionAllowed
```
public boolean isAccessToUnderlyingConnectionAllowed()
```
    Description copied from interface: PoolConfiguration
    
    Property not used. Access is always allowed. Access can be achieved by calling unwrap on the pooled connection. see DataSource interface or call getConnection through reflection or cast the object as PooledConnection
    
    Specified by:
    
    isAccessToUnderlyingConnectionAllowed in interface PoolConfiguration
    
    Returns:
    true
  - isDefaultAutoCommit
```
public Boolean isDefaultAutoCommit()
```
    Description copied from interface: PoolConfiguration
    
    The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
    
    Specified by:
    
    isDefaultAutoCommit in interface PoolConfiguration
    
    Returns:
    the default auto commit setting, null is Driver default.
  - isDefaultReadOnly
```
public Boolean isDefaultReadOnly()
```
    Description copied from interface: PoolConfiguration
    
    If non null, during connection creation the method Connection.setReadOnly(boolean) will be called with the set value.
    
    Specified by:
    
    isDefaultReadOnly in interface PoolConfiguration
    
    Returns:
    null if not set and accepting the driver default otherwise the read only value
  - isLogAbandoned
```
public boolean isLogAbandoned()
```
    Description copied from interface: PoolConfiguration
    
    boolean flag to set if stack traces should be logged for application code which abandoned a Connection. Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated. The default value is false.
    
    Specified by:
    
    isLogAbandoned in interface PoolConfiguration
    
    Returns:
    true if the connection pool logs stack traces when connections are borrowed from the pool.
  - isPoolSweeperEnabled
```
public boolean isPoolSweeperEnabled()
```
    Description copied from interface: PoolConfiguration
    
    Returns true if the pool sweeper is enabled for the connection pool. The pool sweeper is enabled if any settings that require async intervention in the pool are turned on boolean result = getTimeBetweenEvictionRunsMillis()>0; result = result && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0); result = result || (isTestWhileIdle() && getValidationQuery()!=null); return result;
    
    Specified by:
    
    isPoolSweeperEnabled in interface PoolConfiguration
    
    Returns:
    true if a background thread is or will be enabled for this pool
  - isRemoveAbandoned
```
public boolean isRemoveAbandoned()
```
    Description copied from interface: PoolConfiguration
    
    boolean flag to remove abandoned connections if they exceed the removeAbandonedTimeout. If set to true a connection is considered abandoned and eligible for removal if it has been in use longer than the PoolConfiguration.getRemoveAbandonedTimeout() and the condition for PoolConfiguration.getAbandonWhenPercentageFull() is met. Setting this to true can recover db connections from applications that fail to close a connection. See also PoolConfiguration.isLogAbandoned() The default value is false.
    
    Specified by:
    
    isRemoveAbandoned in interface PoolConfiguration
    
    Returns:
    true if abandoned connections can be closed and expelled out of the pool
  - getAbandonWhenPercentageFull
```
public int getAbandonWhenPercentageFull()
```
    Description copied from interface: PoolConfiguration
    
    Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull. The value should be between 0-100. The default value is 0, which implies that connections are eligible for closure as soon as removeAbandonedTimeout has been reached.
    
    Specified by:
    
    getAbandonWhenPercentageFull in interface PoolConfiguration
    
    Returns:
    percentage - a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
  - isTestOnBorrow
```
public boolean isTestOnBorrow()
```
    Description copied from interface: PoolConfiguration
    
    The indication of whether objects will be validated before being borrowed from the pool. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
    
    Specified by:
    
    isTestOnBorrow in interface PoolConfiguration
    
    Returns:
    true if the connection is to be validated upon borrowing a connection from the pool
    See Also:
    PoolConfiguration.getValidationInterval()
  - isTestOnConnect
```
public boolean isTestOnConnect()
```
    Description copied from interface: PoolConfiguration
    
    Returns true if we should run the validation query when connecting to the database for the first time on a connection. Normally this is always set to false, unless one wants to use the validationQuery as an init query.
    
    Specified by:
    
    isTestOnConnect in interface PoolConfiguration
    
    Returns:
    true if we should run the validation query upon connect
  - isTestOnReturn
```
public boolean isTestOnReturn()
```
    Description copied from interface: PoolConfiguration
    
    The indication of whether objects will be validated after being returned to the pool. If the object fails to validate, it will be dropped from the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
    
    Specified by:
    
    isTestOnReturn in interface PoolConfiguration
    
    Returns:
    true if validation should take place after a connection is returned to the pool
    See Also:
    PoolConfiguration.getValidationInterval()
  - isTestWhileIdle
```
public boolean isTestWhileIdle()
```
    Description copied from interface: PoolConfiguration
    
    Set to true if query validation should take place while the connection is idle.
    
    Specified by:
    
    isTestWhileIdle in interface PoolConfiguration
    
    Returns:
    true if validation should take place during idle checks
    See Also:
    PoolConfiguration.setTimeBetweenEvictionRunsMillis(int)
  - getDefaultAutoCommit
```
public Boolean getDefaultAutoCommit()
```
    Description copied from interface: PoolConfiguration
    
    The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
    
    Specified by:
    
    getDefaultAutoCommit in interface PoolConfiguration
    
    Returns:
    the default auto commit setting, null is Driver default.
  - getDefaultReadOnly
```
public Boolean getDefaultReadOnly()
```
    Description copied from interface: PoolConfiguration
    
    If non null, during connection creation the method Connection.setReadOnly(boolean) will be called with the set value.
    
    Specified by:
    
    getDefaultReadOnly in interface PoolConfiguration
    
    Returns:
    null if not set and accepting the driver default otherwise the read only value
  - getJdbcInterceptorsAsArray
```
public PoolProperties.InterceptorDefinition[] getJdbcInterceptorsAsArray()
```
    Description copied from interface: PoolConfiguration
    
    Returns the PoolConfiguration.getJdbcInterceptors() as an array of objects with properties and the classes.
    
    Specified by:
    
    getJdbcInterceptorsAsArray in interface PoolConfiguration
    
    Returns:
    an array of interceptors that have been configured
  - getUseLock
```
public boolean getUseLock()
```
    Description copied from interface: PoolConfiguration
    
    Return true if a lock should be used when operations are performed on the connection object. Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
    
    Specified by:
    
    getUseLock in interface PoolConfiguration
    
    Returns:
    true if a lock is used.
  - isFairQueue
```
public boolean isFairQueue()
```
    Description copied from interface: PoolConfiguration
    
    Returns true if a fair queue is being used by the connection pool
    
    Specified by:
    
    isFairQueue in interface PoolConfiguration
    
    Returns:
    true if a fair waiting queue is being used
  - isJmxEnabled
```
public boolean isJmxEnabled()
```
    Description copied from interface: PoolConfiguration
    
    If set to true, the connection pool creates a ConnectionPoolMBean object that can be registered with JMX to receive notifications and state about the pool. The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
    
    Specified by:
    
    isJmxEnabled in interface PoolConfiguration
    
    Returns:
    true if the mbean object will be created upon startup.
  - isUseEquals
```
public boolean isUseEquals()
```
    Description copied from interface: PoolConfiguration
    
    Set to true if you wish the ProxyConnection class to use String.equals instead of == when comparing method names. This property does not apply to added interceptors as those are configured individually. The default value is false.
    
    Specified by:
    
    isUseEquals in interface PoolConfiguration
    
    Returns:
    true if pool uses String.equals(Object) instead of == when comparing method names on Connection methods
  - setAbandonWhenPercentageFull
```
public void setAbandonWhenPercentageFull(int percentage)
```
    Description copied from interface: PoolConfiguration
    
    Connections that have been abandoned (timed out) wont get closed and reported up unless the number of connections in use are above the percentage defined by abandonWhenPercentageFull. The value should be between 0-100. The default value is 0, which implies that connections are eligible for closure as soon as removeAbandonedTimeout has been reached.
    
    Specified by:
    
    setAbandonWhenPercentageFull in interface PoolConfiguration
    
    Parameters:
    percentage - a value between 0 and 100 to indicate when connections that have been abandoned/timed out are considered abandoned
  - setAccessToUnderlyingConnectionAllowed
```
public void setAccessToUnderlyingConnectionAllowed(boolean accessToUnderlyingConnectionAllowed)
```
    Description copied from interface: PoolConfiguration
    
    No-op
    
    Specified by:
    
    setAccessToUnderlyingConnectionAllowed in interface PoolConfiguration
    
    Parameters:
    accessToUnderlyingConnectionAllowed - parameter ignored
  - setDbProperties
```
public void setDbProperties(Properties dbProperties)
```
    Description copied from interface: PoolConfiguration
    
    Overrides the database properties passed into the Driver.connect(String, Properties) method.
    
    Specified by:
    
    setDbProperties in interface PoolConfiguration
    
    Parameters:
    dbProperties - The database properties
  - setDefaultReadOnly
```
public void setDefaultReadOnly(Boolean defaultReadOnly)
```
    Description copied from interface: PoolConfiguration
    
    If non null, during connection creation the method Connection.setReadOnly(boolean) will be called with the set value.
    
    Specified by:
    
    setDefaultReadOnly in interface PoolConfiguration
    
    Parameters:
    defaultReadOnly - null if not set and accepting the driver default.
  - setMaxAge
```
public void setMaxAge(long maxAge)
```
    Description copied from interface: PoolConfiguration
    
    Time in milliseconds to keep this connection before reconnecting. When a connection is idle, returned to the pool or borrowed from the pool, the pool will check to see if the ((now - time-when-connected) > maxAge) has been reached, and if so, it reconnects. Note that the age of idle connections will only be checked if PoolConfiguration.getTimeBetweenEvictionRunsMillis() returns a value greater than 0. The default value is 0, which implies that connections will be left open and no age checks will be done. This is a useful setting for database sessions that leak memory as it ensures that the session will have a finite life span.
    
    Specified by:
    
    setMaxAge in interface PoolConfiguration
    
    Parameters:
    maxAge - the time in milliseconds a connection will be open for when used
  - setName
```
public void setName(String name)
```
    Description copied from interface: PoolConfiguration
    
    Sets the name of the connection pool
    
    Specified by:
    
    setName in interface PoolConfiguration
    
    Parameters:
    name - the name of the pool, should be unique in a runtime JVM
  - getPoolName
```
public String getPoolName()
```
    Specified by:
    
    getPoolName in interface PoolConfiguration
    
    Returns:
    the pool name
    See Also:
    PoolConfiguration.getName()
  - setConnectionProperties
```
public void setConnectionProperties(String connectionProperties)
```
    Description copied from interface: PoolConfiguration
    
    The properties that will be passed into Driver.connect(String, Properties) method. Username and password do not need to be stored here, they will be passed into the properties right before the connection is established.
    
    Specified by:
    
    setConnectionProperties in interface PoolConfiguration
    
    Parameters:
    connectionProperties - properties - Format of the string is [propertyName=property;]* Example: prop1=value1;prop2=value2
  - setDefaultAutoCommit
```
public void setDefaultAutoCommit(Boolean defaultAutoCommit)
```
    Description copied from interface: PoolConfiguration
    
    The default auto-commit state of connections created by this pool. If not set (null), default is JDBC driver default (If set to null then the Connection.setAutoCommit(boolean) method will not be called.)
    
    Specified by:
    
    setDefaultAutoCommit in interface PoolConfiguration
    
    Parameters:
    defaultAutoCommit - default auto commit setting, null is Driver default.
  - setDefaultCatalog
```
public void setDefaultCatalog(String defaultCatalog)
```
    Description copied from interface: PoolConfiguration
    
    If non null, during connection creation the method Connection.setCatalog(String) will be called with the set value.
    
    Specified by:
    
    setDefaultCatalog in interface PoolConfiguration
    
    Parameters:
    defaultCatalog - null if not set and accepting the driver default.
  - setDefaultTransactionIsolation
```
public void setDefaultTransactionIsolation(int defaultTransactionIsolation)
```
    Description copied from interface: PoolConfiguration
    
    If set to DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION the method Connection.setTransactionIsolation(int) will not be called during connection creation. Otherwise the method will be called with the isolation level set by this property.
    
    Specified by:
    
    setDefaultTransactionIsolation in interface PoolConfiguration
    
    Parameters:
    defaultTransactionIsolation - a value of Connection.TRANSACTION_NONE, Connection.TRANSACTION_READ_COMMITTED, Connection.TRANSACTION_READ_UNCOMMITTED, Connection.TRANSACTION_REPEATABLE_READ, Connection.TRANSACTION_SERIALIZABLE or DataSourceFactory.UNKNOWN_TRANSACTIONISOLATION The last value will not be set on the connection.
  - setDriverClassName
```
public void setDriverClassName(String driverClassName)
```
    Description copied from interface: PoolConfiguration
    
    The fully qualified Java class name of the JDBC driver to be used. The driver has to be accessible from the same classloader as tomcat-jdbc.jar
    
    Specified by:
    
    setDriverClassName in interface PoolConfiguration
    
    Parameters:
    driverClassName - a fully qualified Java class name of a Driver implementation.
  - setFairQueue
```
public void setFairQueue(boolean fairQueue)
```
    Description copied from interface: PoolConfiguration
    
    Set to true if you wish that calls to getConnection should be treated fairly in a true FIFO fashion. This uses the FairBlockingQueue implementation for the list of the idle connections. The default value is true. This flag is required when you want to use asynchronous connection retrieval.
    
    Specified by:
    
    setFairQueue in interface PoolConfiguration
    
    Parameters:
    fairQueue - true to use a fair queue
  - setInitialSize
```
public void setInitialSize(int initialSize)
```
    Description copied from interface: PoolConfiguration
    
    Set the number of connections that will be established when the connection pool is started. Default value is 10. If this value exceeds PoolConfiguration.setMaxActive(int) it will automatically be lowered.
    
    Specified by:
    
    setInitialSize in interface PoolConfiguration
    
    Parameters:
    initialSize - the number of connections to be established.
  - setInitSQL
```
public void setInitSQL(String initSQL)
```
    Description copied from interface: PoolConfiguration
    
    A custom query to be run when a connection is first created. The default value is null. This query only runs once per connection, and that is when a new connection is established to the database. If this value is non null, it will replace the validation query during connection creation.
    
    Specified by:
    
    setInitSQL in interface PoolConfiguration
    
    Parameters:
    initSQL - the init SQL used to run against the DB or null if no query should be executed
  - setJdbcInterceptors
```
public void setJdbcInterceptors(String jdbcInterceptors)
```
    Description copied from interface: PoolConfiguration
    
    A semicolon separated list of classnames extending JdbcInterceptor class. These interceptors will be inserted as an interceptor into the chain of operations on a java.sql.Connection object. Example interceptors are StatementFinalizer to close all used statements during the session. ResetAbandonedTimer resets the timer upon every operation on the connection or a statement. ConnectionState caches the auto commit, read only and catalog settings to avoid round trips to the DB. The default value is null.
    
    Specified by:
    
    setJdbcInterceptors in interface PoolConfiguration
    
    Parameters:
    jdbcInterceptors - the interceptors that are used for connections. Example format: 'ConnectionState(useEquals=true,fast=yes);ResetAbandonedTimer'
  - setJmxEnabled
```
public void setJmxEnabled(boolean jmxEnabled)
```
    Description copied from interface: PoolConfiguration
    
    If set to true, the connection pool creates a ConnectionPoolMBean object that can be registered with JMX to receive notifications and state about the pool. The ConnectionPool object doesn't register itself, as there is no way to keep a static non changing ObjectName across JVM restarts.
    
    Specified by:
    
    setJmxEnabled in interface PoolConfiguration
    
    Parameters:
    jmxEnabled - set to to if the mbean object should be created upon startup.
  - setLogAbandoned
```
public void setLogAbandoned(boolean logAbandoned)
```
    Description copied from interface: PoolConfiguration
    
    boolean flag to set if stack traces should be logged for application code which abandoned a Connection. Logging of abandoned Connections adds overhead for every Connection borrow because a stack trace has to be generated. The default value is false.
    
    Specified by:
    
    setLogAbandoned in interface PoolConfiguration
    
    Parameters:
    logAbandoned - set to true if stack traces should be recorded when DataSourceProxy.getConnection() is called.
  - setMaxActive
```
public void setMaxActive(int maxActive)
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of active connections that can be allocated from this pool at the same time. The default value is 100
    
    Specified by:
    
    setMaxActive in interface PoolConfiguration
    
    Parameters:
    maxActive - hard limit for number of managed connections by this pool
  - setMaxIdle
```
public void setMaxIdle(int maxIdle)
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of connections that should be kept in the idle pool if PoolConfiguration.isPoolSweeperEnabled() returns false. If the If PoolConfiguration.isPoolSweeperEnabled() returns true, then the idle pool can grow up to PoolConfiguration.getMaxActive() and will be shrunk according to PoolConfiguration.getMinEvictableIdleTimeMillis() setting. Default value is maxActive:100
    
    Specified by:
    
    setMaxIdle in interface PoolConfiguration
    
    Parameters:
    maxIdle - the maximum size of the idle pool
  - setMaxWait
```
public void setMaxWait(int maxWait)
```
    Description copied from interface: PoolConfiguration
    
    The maximum number of milliseconds that the pool will wait (when there are no available connections and the PoolConfiguration.getMaxActive() has been reached) for a connection to be returned before throwing an exception. Default value is 30000 (30 seconds)
    
    Specified by:
    
    setMaxWait in interface PoolConfiguration
    
    Parameters:
    maxWait - the maximum number of milliseconds to wait.
  - setMinEvictableIdleTimeMillis
```
public void setMinEvictableIdleTimeMillis(int minEvictableIdleTimeMillis)
```
    Description copied from interface: PoolConfiguration
    
    The minimum amount of time an object must sit idle in the pool before it is eligible for eviction. The default value is 60000 (60 seconds).
    
    Specified by:
    
    setMinEvictableIdleTimeMillis in interface PoolConfiguration
    
    Parameters:
    minEvictableIdleTimeMillis - the number of milliseconds a connection must be idle to be eligible for eviction.
  - setMinIdle
```
public void setMinIdle(int minIdle)
```
    Description copied from interface: PoolConfiguration
    
    The minimum number of established connections that should be kept in the pool at all times. The connection pool can shrink below this number if validation queries fail and connections get closed. Default value is derived from PoolConfiguration.getInitialSize() (also see PoolConfiguration.setTestWhileIdle(boolean) The idle pool will not shrink below this value during an eviction run, hence the number of actual connections can be between PoolConfiguration.getMinIdle() and somewhere between PoolConfiguration.getMaxIdle() and PoolConfiguration.getMaxActive()
    
    Specified by:
    
    setMinIdle in interface PoolConfiguration
    
    Parameters:
    minIdle - the minimum number of idle or established connections
  - setNumTestsPerEvictionRun
```
public void setNumTestsPerEvictionRun(int numTestsPerEvictionRun)
```
    Description copied from interface: PoolConfiguration
    
    Property not used
    
    Specified by:
    
    setNumTestsPerEvictionRun in interface PoolConfiguration
    
    Parameters:
    numTestsPerEvictionRun - parameter ignored.
  - setPassword
```
public void setPassword(String password)
```
    Description copied from interface: PoolConfiguration
    
    Sets the password to establish the connection with. The password will be included as a database property with the name 'password'.
    
    Specified by:
    
    setPassword in interface PoolConfiguration
    
    Parameters:
    password - The password
    See Also:
    PoolConfiguration.getDbProperties()
  - setRemoveAbandoned
```
public void setRemoveAbandoned(boolean removeAbandoned)
```
    Description copied from interface: PoolConfiguration
    
    boolean flag to remove abandoned connections if they exceed the removeAbandonedTimeout. If set to true a connection is considered abandoned and eligible for removal if it has been in use longer than the PoolConfiguration.getRemoveAbandonedTimeout() and the condition for PoolConfiguration.getAbandonWhenPercentageFull() is met. Setting this to true can recover db connections from applications that fail to close a connection. See also PoolConfiguration.isLogAbandoned() The default value is false.
    
    Specified by:
    
    setRemoveAbandoned in interface PoolConfiguration
    
    Parameters:
    removeAbandoned - set to true if abandoned connections can be closed and expelled out of the pool
  - setRemoveAbandonedTimeout
```
public void setRemoveAbandonedTimeout(int removeAbandonedTimeout)
```
    Description copied from interface: PoolConfiguration
    
    The time in seconds before a connection can be considered abandoned. The timer can be reset upon queries using an interceptor.
    
    Specified by:
    
    setRemoveAbandonedTimeout in interface PoolConfiguration
    
    Parameters:
    removeAbandonedTimeout - the time in seconds before a used connection can be considered abandoned
    See Also:
    ResetAbandonedTimer
  - setTestOnBorrow
```
public void setTestOnBorrow(boolean testOnBorrow)
```
    Description copied from interface: PoolConfiguration
    
    The indication of whether objects will be validated before being borrowed from the pool. If the object fails to validate, it will be dropped from the pool, and we will attempt to borrow another. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
    
    Specified by:
    
    setTestOnBorrow in interface PoolConfiguration
    
    Parameters:
    testOnBorrow - set to true if validation should take place before a connection is handed out to the application
    See Also:
    PoolConfiguration.getValidationInterval()
  - setTestOnConnect
```
public void setTestOnConnect(boolean testOnConnect)
```
    Description copied from interface: PoolConfiguration
    
    Set to true if we should run the validation query when connecting to the database for the first time on a connection. Normally this is always set to false, unless one wants to use the validationQuery as an init query. Setting an PoolConfiguration.setInitSQL(String) will override this setting, as the init SQL will be used instead of the validation query
    
    Specified by:
    
    setTestOnConnect in interface PoolConfiguration
    
    Parameters:
    testOnConnect - set to true if we should run the validation query upon connect
  - setTestOnReturn
```
public void setTestOnReturn(boolean testOnReturn)
```
    Description copied from interface: PoolConfiguration
    
    The indication of whether objects will be validated after being returned to the pool. If the object fails to validate, it will be dropped from the pool. NOTE - for a true value to have any effect, the validationQuery parameter must be set to a non-null string. Default value is false In order to have a more efficient validation, see PoolConfiguration.setValidationInterval(long)
    
    Specified by:
    
    setTestOnReturn in interface PoolConfiguration
    
    Parameters:
    testOnReturn - true if validation should take place after a connection is returned to the pool
    See Also:
    PoolConfiguration.getValidationInterval()
  - setTestWhileIdle
```
public void setTestWhileIdle(boolean testWhileIdle)
```
    Description copied from interface: PoolConfiguration
    
    Set to true if query validation should take place while the connection is idle.
    
    Specified by:
    
    setTestWhileIdle in interface PoolConfiguration
    
    Parameters:
    testWhileIdle - true if validation should take place during idle checks
    See Also:
    PoolConfiguration.setTimeBetweenEvictionRunsMillis(int)
  - setTimeBetweenEvictionRunsMillis
```
public void setTimeBetweenEvictionRunsMillis(int timeBetweenEvictionRunsMillis)
```
    Description copied from interface: PoolConfiguration
    
    The number of milliseconds to sleep between runs of the idle connection validation, abandoned cleaner and idle pool resizing. This value should not be set under 1 second. It dictates how often we check for idle, abandoned connections, and how often we validate idle connection and resize the idle pool. The default value is 5000 (5 seconds)
    
    Specified by:
    
    setTimeBetweenEvictionRunsMillis in interface PoolConfiguration
    
    Parameters:
    timeBetweenEvictionRunsMillis - the sleep time in between validations in milliseconds
  - setUrl
```
public void setUrl(String url)
```
    Description copied from interface: PoolConfiguration
    
    Sets the URL used to connect to the database
    
    Specified by:
    
    setUrl in interface PoolConfiguration
    
    Parameters:
    url - the configured URL for this connection pool
    See Also:
    Driver.connect(String, Properties)
  - setUseEquals
```
public void setUseEquals(boolean useEquals)
```
    Description copied from interface: PoolConfiguration
    
    Set to true if you wish the ProxyConnection class to use String.equals instead of == when comparing method names. This property does not apply to added interceptors as those are configured individually. The default value is false.
    
    Specified by:
    
    setUseEquals in interface PoolConfiguration
    
    Parameters:
    useEquals - set to true if the pool should use String.equals(Object) instead of == when comparing method names on Connection methods
  - setUseLock
```
public void setUseLock(boolean useLock)
```
    Description copied from interface: PoolConfiguration
    
    Set to true if a lock should be used when operations are performed on the connection object. Should be set to false unless you plan to have a background thread of your own doing idle and abandon checking such as JMX clients. If the pool sweeper is enabled, then the lock will automatically be used regardless of this setting.
    
    Specified by:
    
    setUseLock in interface PoolConfiguration
    
    Parameters:
    useLock - set to true if a lock should be used on connection operations
  - setUsername
```
public void setUsername(String username)
```
    Description copied from interface: PoolConfiguration
    
    Sets the username used to establish the connection with It will also be a property called 'user' in the database properties.
    
    Specified by:
    
    setUsername in interface PoolConfiguration
    
    Parameters:
    username - The user name
    See Also:
    PoolConfiguration.getDbProperties()
  - setValidationInterval
```
public void setValidationInterval(long validationInterval)
```
    Description copied from interface: PoolConfiguration
    
    avoid excess validation, only run validation at most at this frequency - time in milliseconds. If a connection is due for validation, but has been validated previously within this interval, it will not be validated again. The default value is 3000 (3 seconds).
    
    Specified by:
    
    setValidationInterval in interface PoolConfiguration
    
    Parameters:
    validationInterval - the validation interval in milliseconds
  - setValidationQuery
```
public void setValidationQuery(String validationQuery)
```
    Description copied from interface: PoolConfiguration
    
    The SQL query that will be used to validate connections from this pool before returning them to the caller or pool. If specified, this query does not have to return any data, it just can't throw an SQLException. The default value is null. Example values are SELECT 1(mysql), select 1 from dual(oracle), SELECT 1(MS Sql Server)
    
    Specified by:
    
    setValidationQuery in interface PoolConfiguration
    
    Parameters:
    validationQuery - the query used for validation or null if no validation is performed
  - setValidationQueryTimeout
```
public void setValidationQueryTimeout(int validationQueryTimeout)
```
    Description copied from interface: PoolConfiguration
    
    The timeout in seconds before a connection validation queries fail. A value less than or equal to zero will disable this feature. Defaults to -1.
    
    Specified by:
    
    setValidationQueryTimeout in interface PoolConfiguration
    
    Parameters:
    validationQueryTimeout - The timeout value
  - setValidatorClassName
```
public void setValidatorClassName(String className)
```
    Set the name for an optional validator class which will be used in place of test queries. If set to null, standard validation will be used.
    
    Specified by:
    
    setValidatorClassName in interface PoolConfiguration
    
    Parameters:
    className - the name of the optional validator class
  - getSuspectTimeout
```
public int getSuspectTimeout()
```
    Returns the time in seconds to pass before a connection is marked an abandoned suspect. Any value lesser than or equal to 0 means the check is disabled.
    
    Specified by:
    
    getSuspectTimeout in interface PoolConfiguration
    
    Returns:
    Returns the time in seconds to pass before a connection is marked an abandoned suspect.
  - setSuspectTimeout
```
public void setSuspectTimeout(int seconds)
```
    Similar to PoolConfiguration.setRemoveAbandonedTimeout(int) but instead of treating the connection as abandoned, and potentially closing the connection, this simply logs the warning if PoolConfiguration.isLogAbandoned() returns true. If this value is equal or less than 0, no suspect checking will be performed. Suspect checking only takes place if the timeout value is larger than 0 and the connection was not abandoned or if abandon check is disabled. If a connection is suspect a WARN message gets logged and a JMX notification gets sent once.
    
    Specified by:
    
    setSuspectTimeout in interface PoolConfiguration
    
    Parameters:
    seconds - - the amount of time in seconds that has to pass before a connection is marked suspect.
  - setDataSource
```
public void setDataSource(Object ds)
```
    Injects a datasource that will be used to retrieve/create connections. If a data source is set, the PoolConfiguration.getUrl() and PoolConfiguration.getDriverClassName() methods are ignored and not used by the pool. If the PoolConfiguration.getUsername() and PoolConfiguration.getPassword() values are set, the method DataSource.getConnection(String, String) method will be called instead of the DataSource.getConnection() method. If the data source implements XADataSource the methods XADataSource.getXAConnection() and XADataSource.getXAConnection(String,String) will be invoked.
    
    Specified by:
    
    setDataSource in interface PoolConfiguration
    
    Parameters:
    ds - the DataSource to be used for creating connections to be pooled.
  - getDataSource
```
public Object getDataSource()
```
    Returns a datasource, if one exists that is being used to create connections. This method will return null if the pool is using a Driver
    
    Specified by:
    
    getDataSource in interface PoolConfiguration
    
    Returns:
    the DataSource to be used for creating connections to be pooled or null if a Driver is used.
  - setDataSourceJNDI
```
public void setDataSourceJNDI(String jndiDS)
```
    Configure the connection pool to use a DataSource according to PoolConfiguration.setDataSource(Object) But instead of injecting the object, specify the JNDI location. After a successful JNDI look, the PoolConfiguration.getDataSource() will not return null.
    
    Specified by:
    
    setDataSourceJNDI in interface PoolConfiguration
    
    Parameters:
    jndiDS - -the JNDI string @TODO specify the rules here.
  - getDataSourceJNDI
```
public String getDataSourceJNDI()
```
    Returns the JNDI string configured for data source usage.
    
    Specified by:
    
    getDataSourceJNDI in interface PoolConfiguration
    
    Returns:
    the JNDI string or null if not set
  - isAlternateUsernameAllowed
```
public boolean isAlternateUsernameAllowed()
```
    Returns true if the call getConnection(username,password) is allowed. This is used for when the pool is used by an application accessing multiple schemas. There is a performance impact turning this option on.
    
    Specified by:
    
    isAlternateUsernameAllowed in interface PoolConfiguration
    
    Returns:
    true if getConnection(username,password) is honored, false if it is ignored.
  - setAlternateUsernameAllowed
```
public void setAlternateUsernameAllowed(boolean alternateUsernameAllowed)
```
    Set to true if the call getConnection(username,password) is allowed and honored.. This is used for when the pool is used by an application accessing multiple schemas. There is a performance impact turning this option on, even when not used due to username checks.
    
    Specified by:
    
    setAlternateUsernameAllowed in interface PoolConfiguration
    
    Parameters:
    alternateUsernameAllowed - - set true if getConnection(username,password) is honored, false if it is to be ignored.
  - setValidator
```
public void setValidator(Validator validator)
```
    Sets the validator object If this is a non null object, it will be used as a validator instead of the validationQuery If this is null, remove the usage of the validator.
    
    Specified by:
    
    setValidator in interface PoolConfiguration
    
    Parameters:
    validator - The validator object
  - setCommitOnReturn
```
public void setCommitOnReturn(boolean commitOnReturn)
```
    Set to true if you want the connection pool to commit any pending transaction when a connection is returned. The default value is false, as this could result in committing data. This parameter is only looked at if the PoolConfiguration.getDefaultAutoCommit() returns false
    
    Specified by:
    
    setCommitOnReturn in interface PoolConfiguration
    
    Parameters:
    commitOnReturn - set to true if the pool should call Connection.commit() when a connection is returned to the pool. Default is false
  - getCommitOnReturn
```
public boolean getCommitOnReturn()
```
    Specified by:
    
    getCommitOnReturn in interface PoolConfiguration
    
    Returns:
    true if the pool should commit when a connection is returned to it
    See Also:
    PoolConfiguration.setCommitOnReturn(boolean)
  - setRollbackOnReturn
```
public void setRollbackOnReturn(boolean rollbackOnReturn)
```
    Set to true if you want the connection pool to rollback any pending transaction when a connection is returned. The default value is false, as this could result in committing data. This parameter is only looked at if the PoolConfiguration.getDefaultAutoCommit() returns false
    
    Specified by:
    
    setRollbackOnReturn in interface PoolConfiguration
    
    Parameters:
    rollbackOnReturn - set to true if the pool should call Connection.rollback() when a connection is returned to the pool. Default is false
  - getRollbackOnReturn
```
public boolean getRollbackOnReturn()
```
    Specified by:
    
    getRollbackOnReturn in interface PoolConfiguration
    
    Returns:
    true if the pool should rollback when a connection is returned to it
    See Also:
    PoolConfiguration.setRollbackOnReturn(boolean)
  - setUseDisposableConnectionFacade
```
public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade)
```
    If set to true, the connection will be wrapped with facade that will disallow the connection to be used after Connection.close() is called. If set to true, after Connection.close() all calls except Connection.close() and Connection.isClosed() will throw an exception.
    
    Specified by:
    
    setUseDisposableConnectionFacade in interface PoolConfiguration
    
    Parameters:
    useDisposableConnectionFacade - true to use a facade
  - getUseDisposableConnectionFacade
```
public boolean getUseDisposableConnectionFacade()
```
    Returns true if this connection pool is configured to use a connection facade to prevent re-use of connection after Connection.close() has been invoked
    
    Specified by:
    
    getUseDisposableConnectionFacade in interface PoolConfiguration
    
    Returns:
    true if Connection.close() has been invoked.
  - setLogValidationErrors
```
public void setLogValidationErrors(boolean logValidationErrors)
```
    Set to true if you wish that errors from validation should be logged as error messages.
    
    Specified by:
    
    setLogValidationErrors in interface PoolConfiguration
    
    Parameters:
    logValidationErrors - set to true to log validation errors
  - getLogValidationErrors
```
public boolean getLogValidationErrors()
```
    Returns true if errors that happen during validation will be logged
    
    Specified by:
    
    getLogValidationErrors in interface PoolConfiguration
    
    Returns:
    true if errors that happen during validation will be logged
  - getPropagateInterruptState
```
public boolean getPropagateInterruptState()
```
    Returns true if the pool is configured to propagate interrupt state of a thread. A thread waiting for a connection, can have its wait interrupted, and by default will clear the interrupt flag and throw a PoolExhaustedException
    
    Specified by:
    
    getPropagateInterruptState in interface PoolConfiguration
    
    Returns:
    true if the pool is configured to propagate and not clear the thread interrupt state
  - setPropagateInterruptState
```
public void setPropagateInterruptState(boolean propagateInterruptState)
```
    Configure the pool to propagate interrupt state for interrupted threads waiting for a connection A thread waiting for a connection, can have its wait interrupted, and by default will clear the interrupt flag and throw a PoolExhaustedException If set to true, this behavior will change, while the PoolExhaustedException is still thrown, the threads interrupted state is still set.
    
    Specified by:
    
    setPropagateInterruptState in interface PoolConfiguration
    
    Parameters:
    propagateInterruptState - - set to true to not clear, but propagate, a threads interrupted state.
  - isIgnoreExceptionOnPreLoad
```
public boolean isIgnoreExceptionOnPreLoad()
```
    Specified by:
    
    isIgnoreExceptionOnPreLoad in interface PoolConfiguration
    
    Returns:
    true to ignore exceptions
    See Also:
    PoolConfiguration.setIgnoreExceptionOnPreLoad(boolean)
  - setIgnoreExceptionOnPreLoad
```
public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad)
```
    Set to true if you want to ignore error of connection creation while initializing the pool. Set to false if you want to fail the initialization of the pool by throwing exception.
    
    Specified by:
    
    setIgnoreExceptionOnPreLoad in interface PoolConfiguration
    
    Parameters:
    ignoreExceptionOnPreLoad - set to true if you want to ignore error of connection creation while initializing the pool.
  - getUseStatementFacade
```
public boolean getUseStatementFacade()
```
    Returns true if this connection pool is configured to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
    
    Specified by:
    
    getUseStatementFacade in interface PoolConfiguration
    
    Returns:
    true if the statements are wrapped
  - setUseStatementFacade
```
public void setUseStatementFacade(boolean useStatementFacade)
```
    Set this to true if you wish to wrap statements in order to enable equals() and hashCode() methods to be called on the closed statements if any statement proxy is set.
    
    Specified by:
    
    setUseStatementFacade in interface PoolConfiguration
    
    Parameters:
    useStatementFacade - set to true to wrap statements
  - purge
```
public void purge()
```
    Purges all connections in the pool. For connections currently in use, these connections will be purged when returned on the pool. This call also purges connections that are idle and in the pool To only purge used/active connections see ConnectionPoolMBean.purgeOnReturn()
    
    Specified by:
    
    purge in interface ConnectionPoolMBean
  - purgeOnReturn
```
public void purgeOnReturn()
```
    Purges connections when they are returned from the pool. This call does not purge idle connections until they are used. To purge idle connections see ConnectionPoolMBean.purge()
    
    Specified by:
    
    purgeOnReturn in interface ConnectionPoolMBean

Class ConnectionPool

Field Summary

Fields inherited from interface org.apache.tomcat.jdbc.pool.PoolConfiguration

Constructor Summary

Method Summary

Methods inherited from class javax.management.NotificationBroadcasterSupport

Methods inherited from class java.lang.Object

Field Detail

pool

sequence

listeners

NOTIFY_INIT

NOTIFY_CONNECT

NOTIFY_ABANDON

SLOW_QUERY_NOTIFICATION

FAILED_QUERY_NOTIFICATION

SUSPECT_ABANDONED_NOTIFICATION

POOL_EMPTY

SUSPECT_RETURNED_NOTIFICATION

Constructor Detail

ConnectionPool

Method Detail

getPool

getPoolProperties

getNotificationInfo

getDefaultNotificationInfo

notify

addListener

removeListener

getSize

getIdle

getActive

getNumIdle

getNumActive

getWaitCount

getBorrowedCount

getReturnedCount

getCreatedCount

getReleasedCount

getReconnectedCount

getRemoveAbandonedCount

getReleasedIdleCount

checkIdle

checkAbandoned

testIdle

resetStats

getConnectionProperties

getDbProperties

getDefaultCatalog

getDefaultTransactionIsolation

getDriverClassName

getInitialSize

getInitSQL

getJdbcInterceptors

getMaxActive

getMaxIdle

getMaxWait

getMinEvictableIdleTimeMillis

getMinIdle

getMaxAge

getName

getNumTestsPerEvictionRun

getPassword

getRemoveAbandonedTimeout

getTimeBetweenEvictionRunsMillis

getUrl

getUsername

getValidationInterval

getValidationQuery

getValidationQueryTimeout

getValidatorClassName

getValidator

isAccessToUnderlyingConnectionAllowed

isDefaultAutoCommit

isDefaultReadOnly

isLogAbandoned

isPoolSweeperEnabled

isRemoveAbandoned

getAbandonWhenPercentageFull

isTestOnBorrow