Class ConnectionPool

java.lang.Object
javax.management.NotificationBroadcasterSupport
org.apache.tomcat.jdbc.pool.jmx.ConnectionPool
All Implemented Interfaces:
MBeanRegistration, NotificationBroadcaster, NotificationEmitter, ConnectionPoolMBean, PoolConfiguration
public class ConnectionPool extends NotificationBroadcasterSupport implements ConnectionPoolMBean, MBeanRegistration
JMX MBean wrapper for a ConnectionPool. Provides management and monitoring capabilities for connection pool statistics, operations, and configuration.

The ObjectName this MBean is registered under is fixed when the registration succeeds. A refused registration leaves getObjectName() null until a later registration succeeds; getName() and getPoolName() report the pool's live name and may differ from that registration name after a rename.

  • Field Details

    • pool

      protected ConnectionPool pool
      The pool this MBean wraps, assigned once by the constructor and never swapped: attribute reads consult the live configuration the pool shares with its DataSource, the operations run against this pool, and it is the pool the reported conditions describe. getPool() hands out the same reference in-process.

    • 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

  • Constructor Details

    • ConnectionPool

      public ConnectionPool(ConnectionPool pool)
      Creates a new JMX wrapper for the given connection pool.
      Parameters:
      pool - the connection pool to wrap

  • Method Details

    • getPool

      public ConnectionPool getPool()
      Returns the underlying connection pool instance.
      Returns:
      the wrapped connection pool

    • getPoolProperties

      public PoolConfiguration getPoolProperties()
      Returns the pool configuration for the wrapped connection pool.
      Returns:
      the pool configuration properties

    • getObjectName

      public ObjectName getObjectName()
      Returns the JMX ObjectName under which this MBean is registered.
      Returns:
      the JMX ObjectName, or null while this MBean is not registered - before its registration, after one the server has refused, and after its deregistration

    • preRegister

      public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception
      Specified by:
      preRegister in interface MBeanRegistration
      Throws:
      Exception

    • postRegister

      public void postRegister(Boolean registrationDone)
      Drops the registration name when the MBean server did not complete this MBean's registration.

      The server calls preRegister(MBeanServer, ObjectName) before it has looked the requested name up in its repository, so the name stored there can still be refused - the usual reason being another MBean that already holds it, most often the leftover of a pool that died without deregistering. After refusing a registration the server runs no postDeregister(): per the MBeanRegistration contract a false registrationDone reports that the registration phase failed, which leaves this callback as the only chance to undo what preRegister wrote.

      A name kept through a refusal is a name this MBean never acquired, and both ways it is used then act on a publication that never happened. The pool's notifications - the pool keeps running - attribute themselves to the MBean that does answer for that name, while getNotificationSource() names the pool as a string precisely so that an MBean nobody published points at nobody else's name. And the connections, which publish themselves below getObjectName() as soon as their physical session is up, are offered to the server below a stranger's name: the publish either collides with the children of the MBean that owns that name - a stale pool MBean holds the very same child names - or, the child name being free, publishes a connection of this pool into a subtree this pool has no claim to and no release for, at one error log per connection. The name is also what ConnectionPool.registerConnectionMBeans() waits for, so the gate that keeps the connections of an unpublished pool unpublished opens for a name this MBean was refused. The DataSource that publishes this MBean gives up its own side of a refused registration the same way.

      Specified by:
      postRegister in interface MBeanRegistration

    • preDeregister

      public void preDeregister() throws Exception
      Specified by:
      preDeregister in interface MBeanRegistration
      Throws:
      Exception

    • postDeregister

      public void postDeregister()
      Drops the registration name.

      The MBean server invokes this when the MBean is deregistered, and the pool it wraps may well keep running - a container that takes its DataSource back releases the pool MBean without closing the pool. From then on the name resolves to no MBean: notifications the pool still raises must not attribute themselves to it (see getNotificationSource(), which falls back to naming the pool as a string), and no further MBean may be published below it. preRegister(MBeanServer, ObjectName) writes the name again if this MBean is ever registered anew.

      Specified by:
      postDeregister in interface MBeanRegistration

    • getNotificationInfo

      public MBeanNotificationInfo[] getNotificationInfo()
      Specified by:
      getNotificationInfo in interface NotificationBroadcaster
      Overrides:
      getNotificationInfo in class NotificationBroadcasterSupport

    • getDefaultNotificationInfo

      public static MBeanNotificationInfo[] getDefaultNotificationInfo()
      Returns the default notification info describing all notification types that this MBean can send.
      Returns:
      array of MBeanNotificationInfo describing supported notifications

    • notify

      public boolean notify(String type, String message)
      Reports a condition to the pool's notification listeners.

      The delivery is asynchronous: the notification is handed to the pool's notification thread as one task, and that task delivers it - first through NotificationBroadcasterSupport.sendNotification(Notification) to the listeners reached through JMX, then to the ones registered locally with addListener(NotificationListener). Nothing of the delivery runs on the thread that calls this method, not even the JMX listeners' filters: the pool raises several of its notifications from the connection lifecycle, some of them while holding the lock of the connection concerned, and a monitoring listener - or a filter - that is slow or blocked must not reach those paths. The notification itself is still built on the calling thread, so it carries the time, sequence number and serializable source of the condition it reports - see getNotificationSource() - and, since the notifier is a single thread and delivers a notification to all its listeners in one go, every listener observes the notifications one reporting thread raised in the order that thread raised them: the sequence number stamped on the calling thread records that construction order, and notifications two threads raise at the same time may be delivered in either order. A listener registered both through JMX and locally is reached through JMX before it is reached locally, as it was when delivery was synchronous.

      Parameters:
      type - The notification type
      message - The message
      Returns:
      true if the notification was accepted for delivery as a whole, false if it was dropped as a whole - which happens when the delivery queue is full or the notification could not be built. A false means nothing was scheduled: no listener will receive this notification. The result otherwise reports the handoff only: it says nothing about whether any listener was reached or what a listener did with the notification.

    • getNotificationSource

      protected Object getNotificationSource()
      Returns the source the pool's notifications are sent with.

      Notification marshals its source, so a listener outside this JVM - one reached through a JMX connector, or one that hands the notification on to another process - only receives the notification at all if the source is serializable. This MBean is not, and neither is the pool it wraps, so the source is the ObjectName the MBean is registered under, which names the pool and is serializable. A pool MBean that is not registered - one that has never been registered, or one the server has taken back while its pool keeps running - has no such name: the source is then a string that names the pool.

      Returns:
      the registered ObjectName, or a string naming the pool if the MBean is not registered. That fallback is a diagnostic label, not necessarily a valid ObjectName

    • addListener

      public void addListener(NotificationListener list)
      Adds a local notification listener that receives pool notifications without requiring JMX registration.
      Parameters:
      list - the notification listener to add

    • removeListener

      public boolean removeListener(NotificationListener list)
      Removes a local notification listener from the pool.
      Parameters:
      list - the notification listener to remove
      Returns:
      true if the listener was removed

    • getSize

      public int getSize()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of connection slots the pool holds right now - the idle ones and the checked out ones together.

      This counts slots, not database sessions, and each of these counts reads the live state for itself. While the pool is establishing connections a slot is claimed before its session is signed on, and releasing a connection to a waiting borrower leaves a wake-up placeholder in the idle queue, so this count - and the idle count - can include an entry with no session behind it. Two of these attributes read at the same moment can still disagree: a Size against Idle plus Active, or an Idle against a NumIdle, is a comparison of samples taken one after the other, not of one state read once.

      Specified by:
      getSize in interface ConnectionPoolMBean
      Returns:
      the number of connections the pool holds a slot for

    • getIdle

      public int getIdle()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of idle connections in the pool, meaning the entries that sit in the idle queue - among which there can be a wake-up placeholder with no session behind it. Like the other counts of this interface this is one sample of live state, so ConnectionPoolMBean.getSize() and ConnectionPoolMBean.getActive() are read separately and need not add up to it.
      Specified by:
      getIdle in interface ConnectionPoolMBean
      Returns:
      idle connection count

    • getActive

      public int getActive()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of active (in-use) connections: the entries of the pool's busy set, which is what the pool counts as checked out rather than idle. Like the other counts of this interface this is one sample of live state, so it need not add up against ConnectionPoolMBean.getSize() and ConnectionPoolMBean.getIdle(), which are read separately.
      Specified by:
      getActive in interface ConnectionPoolMBean
      Returns:
      active connection count

    • getNumIdle

      public int getNumIdle()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of idle connections in the pool. This is another name for ConnectionPoolMBean.getIdle() - the commons-dbcp naming - and reads the same count.
      Specified by:
      getNumIdle in interface ConnectionPoolMBean
      Returns:
      idle connection count

    • getNumActive

      public int getNumActive()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of active (in-use) connections. This is another name for ConnectionPoolMBean.getActive() - the commons-dbcp naming - and reads the same count.
      Specified by:
      getNumActive in interface ConnectionPoolMBean
      Returns:
      active connection count

    • getWaitCount

      public int getWaitCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the number of threads waiting for a connection. This is the count of borrowers parked in the wait loop of the synchronous getConnection: a caller of getConnectionAsync is counted only while that call is still running, and once it has been handed a future and waits on the queue behind it, that caller is no longer counted here - the pool's own wake-up logic has to ask the queue about those waiters separately, because this counter does not see them.
      Specified by:
      getWaitCount in interface ConnectionPoolMBean
      Returns:
      wait count

    • getBorrowedCount

      public long getBorrowedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of connections borrowed since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent.
      Specified by:
      getBorrowedCount in interface ConnectionPoolMBean
      Returns:
      borrowed count

    • getReturnedCount

      public long getReturnedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of connections returned since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent.
      Specified by:
      getReturnedCount in interface ConnectionPoolMBean
      Returns:
      returned count

    • getCreatedCount

      public long getCreatedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of connections created since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent. This counts pooled objects the pool took into service, not sessions that came up: an attempt to establish a connection that the database refused is counted here, and its teardown is counted by ConnectionPoolMBean.getReleasedCount().
      Specified by:
      getCreatedCount in interface ConnectionPoolMBean
      Returns:
      created count

    • getReleasedCount

      public long getReleasedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of connections released since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent. This is the counterpart of ConnectionPoolMBean.getCreatedCount(): it counts each pooled object once as it goes out of service, whether or not it ever established a session.
      Specified by:
      getReleasedCount in interface ConnectionPoolMBean
      Returns:
      released count

    • getReconnectedCount

      public long getReconnectedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of reconnections since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent. A reconnection is one session the pool replaced under a pooled object it already had: the borrower came with different credentials, the session had passed its maxAge, or it could not be handed out as it stood.
      Specified by:
      getReconnectedCount in interface ConnectionPoolMBean
      Returns:
      reconnected count

    • getRemoveAbandonedCount

      public long getRemoveAbandonedCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of connections removed due to abandonment since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent. Only the connections the pool actually took away are counted here; a connection that was merely marked as suspect is not counted.
      Specified by:
      getRemoveAbandonedCount in interface ConnectionPoolMBean
      Returns:
      abandoned count

    • getReleasedIdleCount

      public long getReleasedIdleCount()
      Description copied from interface: ConnectionPoolMBean
      Returns the total number of idle connections released since the pool was created or since the last call to ConnectionPoolMBean.resetStats(), whichever is more recent. Any pass that takes an idle connection out of the pool counts here - evicting one the configuration had kept idle too long, taking back one a purge had made stale, or dropping one that did not survive the idle validation or reconnection - and that pass may be the pool cleaner working on its own timer or an explicit ConnectionPoolMBean.checkIdle(), ConnectionPoolMBean.testIdle() or ConnectionPoolMBean.purge() call.
      Specified by:
      getReleasedIdleCount in interface ConnectionPoolMBean
      Returns:
      released idle count

    • checkIdle

      public void checkIdle()
      Description copied from interface: ConnectionPoolMBean
      Runs the idle-eviction pass over the connections that are currently idle. An idle connection the configuration says should be evicted - one that has been idle past minEvictableIdleTimeMillis, or one a ConnectionPoolMBean.purgeOnReturn() or ConnectionPoolMBean.purge() call made stale - is released, and the pass normally stops at the minIdle floor. A connection a purge made stale is released regardless of that floor, so an explicit call after a purge can take the pool below it. An idle connection a borrower claims while this runs is left to that borrower. This is the pass the pool cleaner runs on its own timer, run on demand, and what it releases is counted by ConnectionPoolMBean.getReleasedIdleCount().
      Specified by:
      checkIdle in interface ConnectionPoolMBean

    • checkAbandoned

      public void checkAbandoned()
      Description copied from interface: ConnectionPoolMBean
      Looks through the connections that are currently checked out for ones that have been held too long. A connection past the remove-abandoned timeout is taken from its borrower and removed only while removeAbandoned is enabled and abandonWhenPercentageFull lets the pool's occupancy allow an abandon; each such removal is counted by ConnectionPoolMBean.getRemoveAbandonedCount() and reported through ConnectionPoolMBean.NOTIFY_ABANDON. A checked-out connection that is not removed - because removal is not allowed, or because it has not passed that timeout - keeps its borrower: one held longer than suspectTimeout is only marked as suspect and reported through ConnectionPoolMBean.SUSPECT_ABANDONED_NOTIFICATION. With suspectTimeout unset and removal off, this operation reports nothing at all.
      Specified by:
      checkAbandoned in interface ConnectionPoolMBean

    • testIdle

      public void testIdle()
      Description copied from interface: ConnectionPoolMBean
      Runs the pass over the idle connections that validates them and takes out of the pool the ones that do not survive it. The validation only runs when testWhileIdle is set; with that flag unset nothing is put to the database. Whatever the flag, a connection whose maxAge has expired is reconnected first, and a connection is released when that reconnection fails, when the validation runs and fails it, or when it reaches the validation with no session behind it at all. Those releases are counted by ConnectionPoolMBean.getReleasedIdleCount(), and an idle connection a borrower claims while this runs is left to that borrower.
      Specified by:
      testIdle in interface ConnectionPoolMBean

    • resetStats

      public void resetStats()
      Description copied from interface: ConnectionPoolMBean
      Resets the statistics of this pool: the seven counters of this interface - ConnectionPoolMBean.getBorrowedCount(), ConnectionPoolMBean.getReturnedCount(), ConnectionPoolMBean.getCreatedCount(), ConnectionPoolMBean.getReleasedCount(), ConnectionPoolMBean.getReconnectedCount(), ConnectionPoolMBean.getRemoveAbandonedCount() and ConnectionPoolMBean.getReleasedIdleCount() - are brought back to zero. Everything else about the pool - its connections, its configuration, its notifications - is left as it is.
      Specified by:
      resetStats in interface ConnectionPoolMBean

    • getConnectionProperties

      public String getConnectionProperties()
      Returns the connection properties with any credential they carry masked out, so that a read of this attribute does not hand back in cleartext the password getPassword() exists to withhold. The write is not masked: setConnectionProperties(String) takes the string as it is meant to reach the driver, which is the same read/write asymmetry the password attribute has.

      The masked value is a display value, not a safe value to write back: the ordinary read-modify-write replaces the credential with the mask and leaves the pool unable to authenticate. Change the credential through setPassword(String) and setUsername(String), or read the raw value from getPool(). 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()
      Returns a copy of the database properties with the credential entries removed, so the JMX surface does not expose the plaintext password while getPassword() is explicitly masked. A credential entry is one whose key is password, pass or pwd, ignoring case and surrounding whitespace. A configuration whose database properties are null - a state PoolConfiguration.setDbProperties(Properties) accepts - has nothing to mask, so this returns null. Returns the database properties that are passed into the Driver.connect(String, Properties) method.

      The copy is a display value, and it looks complete: nothing in it says that the pool's own set carries a pair this one withholds. That matters because this attribute is also writable and its write is the whole set - setDbProperties(Properties) replaces the live collection - so the ordinary read-modify-write of the attribute hands the pool back a set with the credential taken out and takes that credential away from the live configuration along with it. A configuration whose password travels only among the database properties - the shape the credential has when a connectionProperties line carries it - then establishes its next connections with nothing to authenticate them, and nothing on the read, the write or in between warns. The credential's owning controls are the Password and Username attributes: each mirrors its value into the database properties and takes the entry away when cleared, and while one of them holds the password it, not the entry, is what new connections are established with however this attribute is written.

      Specified by:
      getDbProperties in interface PoolConfiguration
      Returns:
      database properties that are passed into the Driver.connect(String, Properties) method, or null when the configuration has none

    • 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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it; a level the driver refuses on a session is the one documented exception to that enforcement - the session stays in service and that level is not retried on it.
      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.

      The query runs while the pool is initializing the freshly established session, and the pool terminates the transaction it executes into by commit, so its effects - a data change or a session setting - persist for the lifetime of the connection even when the pool runs with auto commit off. A validation query follows the opposite rule and terminates an open transaction by rollback, so a health check never commits application work. A pool configured with a custom Validator does not run this query at all: the validator replaces the validation itself.

      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()
      Returns the interceptor configuration with any credential its definitions carry masked out, so that a read of this attribute does not hand back in cleartext the password getPassword() exists to withhold - the parameter list of a definition reaches a third-party interceptor as configured, so it is one of the raw strings an operator may type a credential into. There is no write to mask: setJdbcInterceptors(String) refuses the change on a running pool at all. 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 any activity on the connection, upon any statement execution and upon any read of a result set, whether the operation succeeded or failed. ConnectionState caches the auto commit, read only, transaction isolation 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 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 PoolConfiguration.getMaxActive() (100 with the default configuration)
      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. A value less than or equal to zero makes the pool wait indefinitely for a connection to be returned instead of timing out. 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. The default is the value PoolConfiguration.getInitialSize() had when this configuration was constructed; changing initialSize later does not move it, so set this explicitly to change the floor (also see PoolConfiguration.setTestWhileIdle(boolean)). The eviction run normally keeps the total number of connections in the pool - idle plus busy - at or above this value, hence the number of actual connections can be between PoolConfiguration.getMinIdle() and somewhere between PoolConfiguration.getMaxIdle() and PoolConfiguration.getMaxActive(). A connection left over from an earlier pool generation is released regardless, so an explicit idle check after a purge can take the pool below the floor.
      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()
      Returns the pool's current name, as the Name attribute. This is the live configuration value and may differ from the ObjectName this MBean was registered under after a rename; see setName(String).
      Specified by:
      getName in interface PoolConfiguration
      Returns:
      the pool's current name

    • getNumTestsPerEvictionRun

      public int getNumTestsPerEvictionRun()
      Description copied from interface: PoolConfiguration
      Property not used
      Specified by:
      getNumTestsPerEvictionRun in interface PoolConfiguration
      Returns:
      the stored value, which the pool never reads

    • getPassword

      public String getPassword()
      Description copied from interface: PoolConfiguration
      Returns the password used when establishing connections to the database. Some implementations mask the value - the DataSourceProxy and the JMX bean return a placeholder instead of the password so that it cannot be read out through JMX - so a consumer of this contract must not treat the returned string as the configured password.
      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:

    • 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()
      Returns the JDBC URL with any credential it carries masked out, so that a read of this attribute does not hand back in cleartext the password getPassword() exists to withhold. The write is not masked: setUrl(String) takes the URL as it is meant to reach the driver, which is the same read/write asymmetry the password attribute has.

      The masked value is a display value, not a safe value to write back: the ordinary read-modify-write replaces the credential with the mask and leaves the pool unable to authenticate. Change the credential through setPassword(String) and setUsername(String), or read the raw value from getPool(). The URL used to connect to the database

      Specified by:
      getUrl in interface PoolConfiguration
      Returns:
      the configured URL for this connection pool
      See Also:

    • 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. A blank query means the unset value: no statement, the built-in Connection.isValid(int) check runs instead. 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()
      Description copied from interface: PoolConfiguration
      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()
      Description copied from interface: PoolConfiguration
      Returns the validator object used for connection validation. May be null if the pool is using a standard validation query instead.
      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.) When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. Implementations are expected to run the background maintenance whenever boolean timer = getTimeBetweenEvictionRunsMillis()>0; boolean result = timer && (isRemoveAbandoned() && getRemoveAbandonedTimeout()>0); result = result || (timer && getSuspectTimeout()>0); result = result || (timer && isTestWhileIdle()); result = result || (timer && getMinEvictableIdleTimeMillis()>0); result = result || (timer && getMaxAge()>0); return result; so enabling the maintenance when any one of these triggers is turned on satisfies the contract. With the defaults shipped by PoolProperties the sweeper is enabled. When it runs, the background cleaner thread checks for abandoned connections when PoolConfiguration.isRemoveAbandoned() is set, marks and reports connections that exceeded PoolConfiguration.getSuspectTimeout(), evicts idle connections towards PoolConfiguration.getMinIdle(), validates idle connections when PoolConfiguration.isTestWhileIdle() is set and reconnects idle connections that exceeded PoolConfiguration.getMaxAge(). While the sweeper is enabled, the pool also takes the per-connection lock when borrowing and returning connections (the same lock PoolConfiguration.getUseLock() forces on) and returned connections are kept beyond PoolConfiguration.getMaxIdle(), letting the idle pool grow towards PoolConfiguration.getMaxActive() as the cleaner trims it.
      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) won't 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, a reconnection of the same pooled connection is attempted and validated again; if that also fails, the object is dropped from the pool and the borrow fails with an SQLException. NOTE - if no validationQuery is set, Connection.isValid(int) is used to validate the connection. 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:

    • 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 - if no validationQuery is set, Connection.isValid(int) is used to validate the connection. 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:

    • 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:

    • 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.) When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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()
      Returns the parsed interceptor configuration with any credential its definitions carry masked out, so that a read of this attribute does not hand back in cleartext the password getPassword() exists to withhold - the pairs of a definition reach a third-party interceptor as configured, which is why getJdbcInterceptors() masks them in the string this attribute is the parsed form of. There is no write to mask: setJdbcInterceptors(String) refuses the change on a running pool at all. The array is a copy made for this read, so the configuration the interceptor chains are built from keeps the raw pairs and this attribute is no way to reach those definitions either. 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 true.
      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) won't 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)
      Replaces the whole set of database properties the pool connects with: the write is a new set rather than a change applied over the set the pool holds, and the caller owns whatever the written collection holds, as PoolProperties.setDbProperties(Properties) records. It re-mirrors nothing - the user and password entries are whatever the set written here carries. The read of this same attribute, getDbProperties(), withholds the password, so writing back what that read returned - the ordinary way of adding or removing one entry - drops the credential from the live configuration: a pool whose password travels only among the database properties establishes its next connections with nothing to authenticate them, while a pool whose credential the Password attribute holds keeps authenticating with the attribute, the superseded entry going with the replaced set. The Password attribute and its Username pair are therefore the credential's owning controls: they mirror their value into the database properties and take the entry away when cleared, whereas this attribute can only be written with a set the writer itself already holds the credential for - what the read hands back is never that set.
      Specified by:
      setDbProperties in interface PoolConfiguration
      Parameters:
      dbProperties - The database properties, may be null

    • 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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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)
      Renames the running pool. The write is allowed at any time and changes only what the pool calls itself: the Name and PoolName attributes of this MBean, the name ConnectionPool.getName() reports for the pool, and - while this MBean is not registered, so it has no ObjectName to name itself by - the string its notifications carry as their source (see getNotificationSource()).

      Nothing that was registered under a name moves with the rename. Every registration made for a pool is keyed by the name the pool started with, which ConnectionPool.getRegistrationName() returns, and not by this property: the statistics the SlowQueryReport interceptor keeps for this pool stay reachable under the old name and are released under it when the pool closes, as does the MBean its SlowQueryReportJmx subclass publishes for the pool. The ObjectName this MBean is registered under is, in the same way, the one its registration took, and the per-connection MBeans stay published below that name.

      Specified by:
      setName in interface PoolConfiguration
      Parameters:
      name - the name the pool is to call itself by from now on

    • getPoolName

      public String getPoolName()
      Returns the pool's current name, as the PoolName attribute. The MBean's registration name is fixed when it is registered; a rename changes this value without moving the registration.
      Specified by:
      getPoolName in interface PoolConfiguration
      Returns:
      the pool's current name

    • 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.

      Re-setting the string re-applies it: the pairs the previous value of the string contributed are removed from the driver properties before the new ones are parsed in, so a reconfigure that drops a pair really stops sending it, while entries contributed from elsewhere - the explicitly passed user and password among them - are kept. A null value clears the string and takes its contributed pairs with it.

      Specified by:
      setConnectionProperties in interface PoolConfiguration
      Parameters:
      connectionProperties - properties - Format of the string is [propertyName=property;]* Example: prop1=value1;prop2=value2, may be null

    • 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.) When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it.
      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. When the ConnectionState interceptor is configured, it applies this setting on every borrow rather than at connection creation, and re-applies it whenever a borrower has changed it (see PoolConfiguration.getDefaultTransactionIsolation() for the refused-level exception).
      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
      Throws:
      UnsupportedOperationException - always - whether borrow waits are queued fairly is decided when the pool builds its wait queue; set the property before starting the pool

    • 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.
      Throws:
      UnsupportedOperationException - always - the initial size is what the pool pre-loads with when it is created; set the property before starting the pool

    • 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.

      The query runs while the pool is initializing the freshly established session, and the pool terminates the transaction it executes into by commit, so its effects - a data change or a session setting - persist for the lifetime of the connection even when the pool runs with auto commit off. A validation query follows the opposite rule and terminates an open transaction by rollback, so a health check never commits application work. A pool configured with a custom Validator does not run this query at all: the validator replaces the validation itself.

      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 any activity on the connection, upon any statement execution and upon any read of a result set, whether the operation succeeded or failed. ConnectionState caches the auto commit, read only, transaction isolation 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'
      Throws:
      UnsupportedOperationException - always - the interceptor chain is built when the pool starts and for every connection it establishes; set the property before starting the pool

    • 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 true if the mbean object should be created upon startup.
      Throws:
      UnsupportedOperationException - always - whether the pool registers this MBean at all is decided when the pool is created, and a client reaching this setter has reached an MBean whose registration is that decision; set the property before starting the pool

    • 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 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 PoolConfiguration.getMaxActive() (100 with the default configuration)
      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. A value less than or equal to zero makes the pool wait indefinitely for a connection to be returned instead of timing out. 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. The default is the value PoolConfiguration.getInitialSize() had when this configuration was constructed; changing initialSize later does not move it, so set this explicitly to change the floor (also see PoolConfiguration.setTestWhileIdle(boolean)). The eviction run normally keeps the total number of connections in the pool - idle plus busy - at or above this value, hence the number of actual connections can be between PoolConfiguration.getMinIdle() and somewhere between PoolConfiguration.getMaxIdle() and PoolConfiguration.getMaxActive(). A connection left over from an earlier pool generation is released regardless, so an explicit idle check after a purge can take the pool below the floor.
      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)
      Sets the password on the running pool's configuration. The write carries the same meaning as DataSourceProxy.setPassword(String): the credential also lives among the database properties the driver is given, and a null password takes it away from there as well, so that clearing it here really does stop new connections authenticating with it.

      No session is signed on again by the write itself, so what a rotation does to the connections the pool had already established depends on who takes such a connection up again. A borrowed one takes the new password up: the borrow compares the identity the session carries with the identity configured now and, finding them different, re-establishes that same connection under the password written here, which is the identity it keeps from then on. A connection the pool takes up on its own account - an idle one whose maxAge has expired - signs on again with the credential it cached for itself at its first sign-on rather than with this one, so wherever the two differ the database may refuse that reconnect; the pool retires such a connection and the next borrow is served by one established under the password set here. A rotation therefore converges without the operator doing anything, at the price of a refused sign-on or two on the renewals the pool runs by itself, and it does not leave sessions in service under a superseded credential.

      To stop presenting the superseded credential now rather than connection by connection, expire the sessions that still carry it: purge() closes the idle connections at once and the busy ones as they come back, while purgeOnReturn() waits for each connection to come back, an idle one no sooner than it has been borrowed and returned. Whatever the pool establishes after either authenticates with the password set here.

      Specified by:
      setPassword in interface PoolConfiguration
      Parameters:
      password - the password, or null to take the credential away
      See Also:

    • 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:

    • 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, a reconnection of the same pooled connection is attempted and validated again; if that also fails, the object is dropped from the pool and the borrow fails with an SQLException. NOTE - if no validationQuery is set, Connection.isValid(int) is used to validate the connection. 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:

    • 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 - if no validationQuery is set, Connection.isValid(int) is used to validate the connection. 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:

    • 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:

    • 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:

    • 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 true.
      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)
      Sets the user name on the running pool's configuration, with the same meaning as DataSourceProxy.setUsername(String): a null user name takes the credential away from the database properties as well as from the configuration.

      What setPassword(String) records about connections the pool had already established holds here in full, because the identity a session serves under is this user name together with that password: the borrow compares the pair the session carries with the pair configured now and re-establishes the connection under the new one, while a connection the pool renews on its own account signs on again with the pair it cached at its first sign-on and is retired when the database refuses it. purge() and purgeOnReturn() expire the sessions that still carry the superseded user name, on demand.

      Specified by:
      setUsername in interface PoolConfiguration
      Parameters:
      username - the user name, or null to take the credential away
      See Also:

    • 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. A blank query is stored as the unset value: a configuration surface that cannot express null is written empty to mean "no statement", and no statement can be blank. 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 or a blank string if no validation query is set

    • 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)
      Description copied from interface: PoolConfiguration
      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()
      Description copied from interface: PoolConfiguration
      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)
      Description copied from interface: PoolConfiguration
      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)
      Description copied from interface: PoolConfiguration
      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. If it implements ConnectionPoolDataSource the methods ConnectionPoolDataSource.getPooledConnection() and ConnectionPoolDataSource.getPooledConnection(String,String) will be invoked instead.
      Specified by:
      setDataSource in interface PoolConfiguration
      Parameters:
      ds - the DataSource to be used for creating connections to be pooled.

    • getDataSource

      public Object getDataSource()
      Description copied from interface: PoolConfiguration
      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 backing object - a DataSource, XADataSource or ConnectionPoolDataSource - used for creating connections to be pooled, or null if a Driver is used.

    • setDataSourceJNDI

      public void setDataSourceJNDI(String jndiDS)
      Description copied from interface: PoolConfiguration
      Configures a JNDI name for the backing data source. Instead of injecting the object through PoolConfiguration.setDataSource(Object), this names it. The name is resolved by DataSourceFactory, which looks it up when the pool is created through the factory and JNDI path and injects the found object through PoolConfiguration.setDataSource(Object); after that lookup, PoolConfiguration.getDataSource() does not return null. Nothing else performs the lookup: set on a pool configured programmatically, the property never becomes a data source and the pool keeps connecting through the driver properties.
      Specified by:
      setDataSourceJNDI in interface PoolConfiguration
      Parameters:
      jndiDS - the JNDI name of the data source to wrap

    • getDataSourceJNDI

      public String getDataSourceJNDI()
      Description copied from interface: PoolConfiguration
      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()
      Description copied from interface: PoolConfiguration
      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)
      Description copied from interface: PoolConfiguration
      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)
      Description copied from interface: PoolConfiguration
      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)
      Description copied from interface: PoolConfiguration
      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 ignored if PoolConfiguration.setRollbackOnReturn(boolean) is also set to true. The commit is only performed when the returned connection is actually in a transaction.
      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()
      Description copied from interface: PoolConfiguration
      Returns whether the pool commits any pending transaction when a connection is returned. See PoolConfiguration.setCommitOnReturn(boolean) for details.
      Specified by:
      getCommitOnReturn in interface PoolConfiguration
      Returns:
      true if the pool should commit when a connection is returned to it

    • setRollbackOnReturn

      public void setRollbackOnReturn(boolean rollbackOnReturn)
      Description copied from interface: PoolConfiguration
      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 discarding data the application has not committed. The rollback is only performed when the returned connection is actually in a transaction.
      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()
      Description copied from interface: PoolConfiguration
      Returns whether the pool rolls back any pending transaction when a connection is returned. See PoolConfiguration.setRollbackOnReturn(boolean) for details.
      Specified by:
      getRollbackOnReturn in interface PoolConfiguration
      Returns:
      true if the pool should rollback when a connection is returned to it

    • setUseDisposableConnectionFacade

      @Deprecated public void setUseDisposableConnectionFacade(boolean useDisposableConnectionFacade)
      Deprecated.
      The disposable connection facade is always used, so this property no longer has any effect.
      Stores the value of the deprecated useDisposableConnectionFacade property. The pool always wraps the connection handle in a facade that disallows use of the connection after Connection.close() has been called, whatever value is stored here.
      Specified by:
      setUseDisposableConnectionFacade in interface PoolConfiguration
      Parameters:
      useDisposableConnectionFacade - the configured value, retained but without effect

    • getUseDisposableConnectionFacade

      @Deprecated public boolean getUseDisposableConnectionFacade()
      Deprecated.
      The disposable connection facade is always used, so this property no longer has any effect.
      Returns the value stored for the deprecated useDisposableConnectionFacade property. The pool always wraps the connection handle in a facade that disallows use of the connection after Connection.close() has been called, whatever value is returned here.
      Specified by:
      getUseDisposableConnectionFacade in interface PoolConfiguration
      Returns:
      the configured value, retained but without effect

    • setLogValidationErrors

      public void setLogValidationErrors(boolean logValidationErrors)
      Description copied from interface: PoolConfiguration
      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()
      Description copied from interface: PoolConfiguration
      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()
      Description copied from interface: PoolConfiguration
      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 SQLException reporting the interrupted wait, with the InterruptedException as its cause.
      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)
      Description copied from interface: PoolConfiguration
      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 SQLException reporting the interrupted wait, with the InterruptedException as its cause. If set to true, this behavior will change, while the SQLException 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()
      Description copied from interface: PoolConfiguration
      Returns whether exceptions during connection creation at pool initialization should be ignored. See PoolConfiguration.setIgnoreExceptionOnPreLoad(boolean) for details.
      Specified by:
      isIgnoreExceptionOnPreLoad in interface PoolConfiguration
      Returns:
      true to ignore exceptions during pre-load

    • setIgnoreExceptionOnPreLoad

      public void setIgnoreExceptionOnPreLoad(boolean ignoreExceptionOnPreLoad)
      Description copied from interface: PoolConfiguration
      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.
      Throws:
      UnsupportedOperationException - always - the flag governs the preload of initial connections the pool runs when it is created; set the property before starting the pool

    • getUseStatementFacade

      @Deprecated public boolean getUseStatementFacade()
      Deprecated.
      The statement facade is always used, so this property no longer has any effect.
      Returns the value stored for the deprecated useStatementFacade property. The pool always wraps the statements it hands out - and the result sets read from them - in a facade, whatever value is returned here.
      Specified by:
      getUseStatementFacade in interface PoolConfiguration
      Returns:
      the configured value, retained but without effect

    • setUseStatementFacade

      @Deprecated public void setUseStatementFacade(boolean useStatementFacade)
      Deprecated.
      The statement facade is always used, so this property no longer has any effect.
      Stores the value of the deprecated useStatementFacade property. The pool always wraps the statements it hands out - and the result sets read from them - in a facade, whatever value is stored here. That facade answers equals(), hashCode() and toString() on closed statements, answers Statement.getConnection() with the pooled connection the statement was created from, and stops the statement and its result sets from working once that connection has been returned to the pool.
      Specified by:
      setUseStatementFacade in interface PoolConfiguration
      Parameters:
      useStatementFacade - the configured value, retained but without effect

    • purge

      public void purge()
      Description copied from interface: ConnectionPoolMBean
      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()
      Description copied from interface: ConnectionPoolMBean
      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