ConnectionPool (avaje-datasource 1.1.3 API)

java.lang.Object
- org.avaje.datasource.pool.ConnectionPool

All Implemented Interfaces:

Wrapper, CommonDataSource, DataSource, org.avaje.datasource.DataSourcePool
```
public class ConnectionPool
extends Object
implements org.avaje.datasource.DataSourcePool
```
A robust DataSource implementation.
- Manages the number of connections closing connections that have been idle for some time.
- Notifies when the datasource goes down and comes back up.
- Provides PreparedStatement caching
- Knows the busy connections
- Traces connections that have been leaked

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class ConnectionPool.Status

Nested Classes
Modifier and Type	Class and Description
`static class`	`ConnectionPool.Status`

Constructor Summary

Constructors
Constructor and Description

ConnectionPool(String name, org.avaje.datasource.DataSourceConfig params)

Constructors
Constructor and Description
`ConnectionPool(String name, org.avaje.datasource.DataSourceConfig params)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`closeBusyConnections(long leakTimeMinutes)` Close any busy connections that have not been used for some time.
`Connection`	`createUnpooledConnection()` Create a Connection that will not be part of the connection pool.
`void`	`dumpBusyConnectionInformation()` Dumps the busy connection information to the logs.
`String`	`getBusyConnectionInformation()` Returns information describing connections that are currently being used.
`Connection`	`getConnection()` Return a pooled connection.
`Connection`	`getConnection(String username, String password)` Create an un-pooled connection with the given username and password.
`long`	`getLeakTimeMinutes()` Return the number of minutes after which a busy connection could be considered leaked from the connection pool.
`int`	`getLoginTimeout()` Not implemented and shouldn't be used.
`PrintWriter`	`getLogWriter()` Returns null.
`long`	`getMaxAgeMillis()` Return the maximum age a connection is allowed to be before it is trimmed out of the pool.
`int`	`getMaxInactiveMillis()` Return the time after which inactive connections are trimmed.
`int`	`getMaxSize()` Return the max size this pool can grow to.
`int`	`getMinSize()` Return the min size this pool should maintain.
`String`	`getName()` Return the dataSource name.
`Logger`	`getParentLogger()`
`int`	`getPstmtCacheSize()` Return the preparedStatement cache size.
`org.avaje.datasource.PoolStatistics`	`getStatistics(boolean reset)` Return the aggregated load statistics collected on all the connections in the pool.
`org.avaje.datasource.PoolStatus`	`getStatus(boolean reset)` Return the current status of the connection pool.
`int`	`getWaitTimeoutMillis()` Return the time in millis that threads will wait when the pool has hit the max size.
`int`	`getWarningSize()` Return the warning size.
`boolean`	`isAutoCommit()` Return the default autoCommit setting Connections in this pool will use.
`boolean`	`isCaptureStackTrace()` Return true if the connection pool is currently capturing the StackTrace when connections are 'got' from the pool.
`boolean`	`isDataSourceUp()` Returns false when the dataSource is down.
`boolean`	`isWrapperFor(Class<?> arg0)` Returns false.
`void`	`reset()` Close all the connections in the pool.
`void`	`setCaptureStackTrace(boolean captureStackTrace)` Set this to true means that the StackElements are captured every time a connection is retrieved from the pool.
`void`	`setLeakTimeMinutes(long leakTimeMinutes)` For detecting and closing leaked connections.
`void`	`setLoginTimeout(int seconds)` Not implemented and shouldn't be used.
`void`	`setLogWriter(PrintWriter writer)` Not implemented.
`void`	`setMaxSize(int max)` Set a new maximum size.
`void`	`setMinSize(int min)` Set the min size this pool should maintain.
`void`	`setPstmtCacheSize(int pstmtCacheSize)` Set the preparedStatement cache size.
`void`	`setWarningSize(int warningSize)` Set a new maximum size.
`void`	`shutdown(boolean deregisterDriver)` This will close all the free connections, and then go into a wait loop, waiting for the busy connections to be freed.
`void`	`testAlert()` Send a message to the DataSourceAlertListener to test it.
`<T> T`	`unwrap(Class<T> arg0)` Not Implemented.

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

- Constructor Detail
  - ConnectionPool
```
public ConnectionPool(String name,
                      org.avaje.datasource.DataSourceConfig params)
```
- Method Detail
  - getParentLogger
```
public Logger getParentLogger()
                       throws SQLFeatureNotSupportedException
```
    Specified by:
    
    getParentLogger in interface CommonDataSource
    
    Throws:
    
    SQLFeatureNotSupportedException
  - isWrapperFor
```
public boolean isWrapperFor(Class<?> arg0)
                     throws SQLException
```
    Returns false.
    
    Specified by:
    
    isWrapperFor in interface Wrapper
    
    Throws:
    
    SQLException
  - unwrap
```
public <T> T unwrap(Class<T> arg0)
             throws SQLException
```
    Not Implemented.
    
    Specified by:
    
    unwrap in interface Wrapper
    
    Throws:
    
    SQLException
  - getName
```
public String getName()
```
    Return the dataSource name.
    
    Specified by:
    
    getName in interface org.avaje.datasource.DataSourcePool
  - isDataSourceUp
```
public boolean isDataSourceUp()
```
    Returns false when the dataSource is down.
  - createUnpooledConnection
```
public Connection createUnpooledConnection()
                                    throws SQLException
```
    Create a Connection that will not be part of the connection pool.
    
    When this connection is closed it will not go back into the pool.
    
    If withDefaults is true then the Connection will have the autoCommit and transaction isolation set to the defaults for the pool.
    
    Throws:
    
    SQLException
  - setMaxSize
```
public void setMaxSize(int max)
```
    Set a new maximum size. The pool should respect this new maximum immediately and not require a restart. You may want to increase the maxConnections if the pool gets large and hits the warning level.
  - getMaxSize
```
public int getMaxSize()
```
    Return the max size this pool can grow to.
  - setMinSize
```
public void setMinSize(int min)
```
    Set the min size this pool should maintain.
  - getMinSize
```
public int getMinSize()
```
    Return the min size this pool should maintain.
  - setWarningSize
```
public void setWarningSize(int warningSize)
```
    Set a new maximum size. The pool should respect this new maximum immediately and not require a restart. You may want to increase the maxConnections if the pool gets large and hits the warning and or alert levels.
  - getWarningSize
```
public int getWarningSize()
```
    Return the warning size. When the pool hits this size it can send a notify message to an administrator.
  - getWaitTimeoutMillis
```
public int getWaitTimeoutMillis()
```
    Return the time in millis that threads will wait when the pool has hit the max size. These threads wait for connections to be returned by the busy connections.
  - getMaxInactiveMillis
```
public int getMaxInactiveMillis()
```
    Return the time after which inactive connections are trimmed.
  - getMaxAgeMillis
```
public long getMaxAgeMillis()
```
    Return the maximum age a connection is allowed to be before it is trimmed out of the pool. This value can be 0 which means there is no maximum age.
  - getBusyConnectionInformation
```
public String getBusyConnectionInformation()
```
    Returns information describing connections that are currently being used.
  - dumpBusyConnectionInformation
```
public void dumpBusyConnectionInformation()
```
    Dumps the busy connection information to the logs.
    This includes the stackTrace elements if they are being captured. This is useful when needing to look a potential connection pool leaks.
  - closeBusyConnections
```
public void closeBusyConnections(long leakTimeMinutes)
```
    Close any busy connections that have not been used for some time.
    These connections are considered to have leaked from the connection pool.
    
    Connection leaks occur when code doesn't ensure that connections are closed() after they have been finished with. There should be an appropriate try catch finally block to ensure connections are always closed and put back into the pool.
  - reset
```
public void reset()
```
    Close all the connections in the pool.
    - Checks that the database is up.
    - Resets the Alert level.
    - Closes busy connections that have not been used for some time (aka leaks).
    - This closes all the currently available connections.
    - Busy connections are closed when they are returned to the pool.
  - getConnection
```
public Connection getConnection()
                         throws SQLException
```
    Return a pooled connection.
    
    Specified by:
    
    getConnection in interface DataSource
    
    Throws:
    
    SQLException
  - testAlert
```
public void testAlert()
```
    Send a message to the DataSourceAlertListener to test it. This is so that you can make sure the alerter is configured correctly etc.
  - shutdown
```
public void shutdown(boolean deregisterDriver)
```
    This will close all the free connections, and then go into a wait loop, waiting for the busy connections to be freed.
    
    The DataSources's should be shutdown AFTER thread pools. Leaked Connections are not waited on, as that would hang the server.
    
    Specified by:
    
    shutdown in interface org.avaje.datasource.DataSourcePool
  - isAutoCommit
```
public boolean isAutoCommit()
```
    Return the default autoCommit setting Connections in this pool will use.
    
    Specified by:
    
    isAutoCommit in interface org.avaje.datasource.DataSourcePool
    
    Returns:
    
    true if the pool defaults autoCommit to true
  - isCaptureStackTrace
```
public boolean isCaptureStackTrace()
```
    Return true if the connection pool is currently capturing the StackTrace when connections are 'got' from the pool.
    This is set to true to help diagnose connection pool leaks.
  - setCaptureStackTrace
```
public void setCaptureStackTrace(boolean captureStackTrace)
```
    Set this to true means that the StackElements are captured every time a connection is retrieved from the pool. This can be used to identify connection pool leaks.
  - getConnection
```
public Connection getConnection(String username,
                                String password)
                         throws SQLException
```
    Create an un-pooled connection with the given username and password. This uses the default isolation level and autocommit mode.
    
    Specified by:
    
    getConnection in interface DataSource
    
    Throws:
    
    SQLException
  - getLoginTimeout
```
public int getLoginTimeout()
                    throws SQLException
```
    Not implemented and shouldn't be used.
    
    Specified by:
    
    getLoginTimeout in interface CommonDataSource
    
    Throws:
    
    SQLException
  - setLoginTimeout
```
public void setLoginTimeout(int seconds)
                     throws SQLException
```
    Not implemented and shouldn't be used.
    
    Specified by:
    
    setLoginTimeout in interface CommonDataSource
    
    Throws:
    
    SQLException
  - getLogWriter
```
public PrintWriter getLogWriter()
```
    Returns null.
    
    Specified by:
    
    getLogWriter in interface CommonDataSource
  - setLogWriter
```
public void setLogWriter(PrintWriter writer)
                  throws SQLException
```
    Not implemented.
    
    Specified by:
    
    setLogWriter in interface CommonDataSource
    
    Throws:
    
    SQLException
  - setLeakTimeMinutes
```
public void setLeakTimeMinutes(long leakTimeMinutes)
```
    For detecting and closing leaked connections. Connections that have been busy for more than leakTimeMinutes are considered leaks and will be closed on a reset().
    If you want to use a connection for that longer then you should consider creating an unpooled connection or setting longRunning to true on that connection.
  - getLeakTimeMinutes
```
public long getLeakTimeMinutes()
```
    Return the number of minutes after which a busy connection could be considered leaked from the connection pool.
  - getPstmtCacheSize
```
public int getPstmtCacheSize()
```
    Return the preparedStatement cache size.
  - setPstmtCacheSize
```
public void setPstmtCacheSize(int pstmtCacheSize)
```
    Set the preparedStatement cache size.
  - getStatus
```
public org.avaje.datasource.PoolStatus getStatus(boolean reset)
```
    Return the current status of the connection pool.
    If you pass reset = true then the counters such as hitCount, waitCount and highWaterMark are reset.
    
    Specified by:
    
    getStatus in interface org.avaje.datasource.DataSourcePool
  - getStatistics
```
public org.avaje.datasource.PoolStatistics getStatistics(boolean reset)
```
    Return the aggregated load statistics collected on all the connections in the pool.
    
    Specified by:
    
    getStatistics in interface org.avaje.datasource.DataSourcePool

Class ConnectionPool

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ConnectionPool

Method Detail

getParentLogger

isWrapperFor

unwrap

getName

isDataSourceUp

createUnpooledConnection

setMaxSize

getMaxSize

setMinSize

getMinSize

setWarningSize

getWarningSize

getWaitTimeoutMillis

getMaxInactiveMillis

getMaxAgeMillis

getBusyConnectionInformation

dumpBusyConnectionInformation

closeBusyConnections

reset

getConnection

testAlert

shutdown

isAutoCommit

isCaptureStackTrace

setCaptureStackTrace

getConnection

getLoginTimeout

setLoginTimeout

getLogWriter

setLogWriter

setLeakTimeMinutes

getLeakTimeMinutes

getPstmtCacheSize

setPstmtCacheSize

getStatus

getStatistics