java.lang.Object
- org.eclipse.persistence.sessions.server.ConnectionPool

Direct Known Subclasses:

ExternalConnectionPool, ReadConnectionPool
```
public class ConnectionPool
extends Object
```
Purpose: Used to specify how connection should be pooled in a server session.

See Also:

ServerSession

Field Summary

Fields
Modifier and Type	Field	Description
`protected boolean`	`checkConnections`
`protected List<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`connectionsAvailable`
`protected List<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`connectionsUsed`
`static long`	`DEAD_CHECK_TIME`
`protected long`	`deadCheckTime`
`protected List<String>`	`failoverConnectionPools`
`static int`	`INITIAL_CONNECTIONS`
`protected int`	`initialNumberOfConnections`
`protected boolean`	`isConnected`
`protected boolean`	`isDead`
`protected Login`	`login`
`static int`	`MAX_CONNECTIONS`
`protected int`	`maxNumberOfConnections`
`static int`	`MIN_CONNECTIONS`
`protected int`	`minNumberOfConnections`
`protected static String`	`MONITOR_HEADER`
`protected String`	`name`
`protected ServerSession`	`owner`
`protected long`	`timeOfDeath`
`static int`	`WAIT_TIMEOUT`
`protected int`	`waitTimeout`

Constructor Summary

Constructors
Constructor	Description
`ConnectionPool()`	PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
`ConnectionPool(String name, Login login, int initialNumberOfConnections, int minNumberOfConnections, int maxNumberOfConnections, ServerSession owner)`	PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
`ConnectionPool(String name, Login login, int minNumberOfConnections, int maxNumberOfConnections, ServerSession owner)`	PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
`ConnectionPool(String name, Login login, ServerSession owner)`	PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`org.eclipse.persistence.internal.databaseaccess.Accessor`	`acquireConnection()`	INTERNAL: Wait until a connection is available and allocate the connection for the client.
`boolean`	`addFailoverConnectionPool(String poolName)`	PUBLIC: Add the connection pool to used if this pool database goes down.
`protected org.eclipse.persistence.internal.databaseaccess.Accessor`	`buildConnection()`	INTERNAL: Create a new connection, accessors are used as connections.
`org.eclipse.persistence.internal.databaseaccess.Accessor`	`failover()`	INTERNAL: The connection pool is dead fail over to the fail-over pool.
`List<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`getConnectionsAvailable()`	INTERNAL: returns the connections currently available for use in the pool
`protected List<org.eclipse.persistence.internal.databaseaccess.Accessor>`	`getConnectionsUsed()`	Return a list of the connections that are being used.
`List<String>`	`getFailoverConnectionPools()`	PUBLIC: Return the list of connection pools to used if this pool database goes down.
`int`	`getInitialNumberOfConnections()`	PUBLIC: Return the initial number of connections allowed.
`Login`	`getLogin()`	PUBLIC: Return the login used to create connections.
`int`	`getMaxNumberOfConnections()`	PUBLIC: Return the maximum number of connections allowed.
`int`	`getMinNumberOfConnections()`	PUBLIC: Return the minimum number of connections.
`String`	`getName()`	PUBLIC: Return the name of this pool.
`protected ServerSession`	`getOwner()`	Return the ServerSession that is the owner of this connection pool.
`int`	`getTotalNumberOfConnections()`	INTERNAL: Return the total number of connections currently in use.
`int`	`getWaitTimeout()`	PUBLIC: Return the time in milliseconds to wait for a available connection.
`boolean`	`hasConnectionAvailable()`	INTERNAL: Wait until a connection is avaiable and allocate the connection for the client.
`boolean`	`isConnected()`	INTERNAL: Return if this pool has been connected to the database.
`boolean`	`isDead()`	ADVANCED: Return if the connection pool's database is down, and failover should be used.
`boolean`	`isThereConflictBetweenLoginAndType()`	INTERNAL: Checks for a conflict between pool's type and pool's login
`void`	`releaseConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)`	INTERNAL: Add the connection as single that a new connection is available.
`void`	`resetConnections()`	INTERNAL: Reset the connections on shutDown and when the pool is started.
`void`	`setCheckConnections()`	INTERNAL: This method is called to indicate that all available connections should be checked.
`protected void`	`setConnectionsAvailable(Vector connectionsAvailable)`	INTERNAL: Set this list of connections available
`protected void`	`setConnectionsUsed(Vector connectionsUsed)`	INTERNAL: Set the list of connections being used.
`void`	`setFailoverConnectionPools(List<String> failoverConnectionPools)`	PUBLIC: Set the list of connection pools to used if this pool database goes down.
`void`	`setInitialNumberOfConnections(int initialNumberOfConnections)`	PUBLIC: Set the initial number of connections allowed.
`void`	`setIsConnected(boolean isConnected)`	INTERNAL: Set if this pool has been connected to the database.
`void`	`setIsDead(boolean isDead)`	ADVANCED: Set if the connection pool's database is down, and failover should be used.
`void`	`setLogin(Login login)`	PUBLIC: Set the login used to create connections.
`void`	`setMaxNumberOfConnections(int maxNumberOfConnections)`	PUBLIC: Set the maximum number of connections allowed.
`void`	`setMinNumberOfConnections(int minNumberOfConnections)`	PUBLIC: Set the minimum number of connections.
`void`	`setName(String name)`	PUBLIC: Set the name of this pool.
`protected void`	`setOwner(ServerSession owner)`	Set the ServerSession that owns this connection pool
`void`	`setWaitTimeout(int waitTimeout)`	PUBLIC: Set the time in milliseconds to wait for an available connection.
`void`	`shutDown()`	INTERNAL: Disconnect all connections.
`void`	`startUp()`	INTERNAL: Allocate the minimum connections.
`String`	`toString()`	INTERNAL: return a string representation of this connection pool

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

- Field Detail
  - MONITOR_HEADER
```
protected static final String MONITOR_HEADER
```
    See Also:
    
    Constant Field Values
  - isConnected
```
protected boolean isConnected
```
  - maxNumberOfConnections
```
protected int maxNumberOfConnections
```
  - minNumberOfConnections
```
protected int minNumberOfConnections
```
  - initialNumberOfConnections
```
protected int initialNumberOfConnections
```
  - waitTimeout
```
protected int waitTimeout
```
  - connectionsAvailable
```
protected List<org.eclipse.persistence.internal.databaseaccess.Accessor> connectionsAvailable
```
  - connectionsUsed
```
protected List<org.eclipse.persistence.internal.databaseaccess.Accessor> connectionsUsed
```
  - login
```
protected Login login
```
  - name
```
protected String name
```
  - owner
```
protected ServerSession owner
```
  - checkConnections
```
protected volatile boolean checkConnections
```
  - timeOfDeath
```
protected volatile long timeOfDeath
```
  - deadCheckTime
```
protected volatile long deadCheckTime
```
  - isDead
```
protected volatile boolean isDead
```
  - failoverConnectionPools
```
protected List<String> failoverConnectionPools
```
  - DEAD_CHECK_TIME
```
public static final long DEAD_CHECK_TIME
```
    See Also:
    
    Constant Field Values
  - MAX_CONNECTIONS
```
public static final int MAX_CONNECTIONS
```
    See Also:
    
    Constant Field Values
  - MIN_CONNECTIONS
```
public static final int MIN_CONNECTIONS
```
    See Also:
    
    Constant Field Values
  - INITIAL_CONNECTIONS
```
public static final int INITIAL_CONNECTIONS
```
    See Also:
    
    Constant Field Values
  - WAIT_TIMEOUT
```
public static final int WAIT_TIMEOUT
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ConnectionPool
```
public ConnectionPool()
```
    PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
  - ConnectionPool
```
public ConnectionPool(String name,
                      Login login,
                      ServerSession owner)
```
    PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
  - ConnectionPool
```
public ConnectionPool(String name,
                      Login login,
                      int minNumberOfConnections,
                      int maxNumberOfConnections,
                      ServerSession owner)
```
    PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
  - ConnectionPool
```
public ConnectionPool(String name,
                      Login login,
                      int initialNumberOfConnections,
                      int minNumberOfConnections,
                      int maxNumberOfConnections,
                      ServerSession owner)
```
    PUBLIC: A connection pool is used to specify how connection should be pooled in a server session.
- Method Detail
  - failover
```
public org.eclipse.persistence.internal.databaseaccess.Accessor failover()
```
    INTERNAL: The connection pool is dead fail over to the fail-over pool.
  - acquireConnection
```
public org.eclipse.persistence.internal.databaseaccess.Accessor acquireConnection()
                                                                           throws ConcurrencyException
```
    INTERNAL: Wait until a connection is available and allocate the connection for the client.
    
    Throws:
    
    ConcurrencyException
  - buildConnection
```
protected org.eclipse.persistence.internal.databaseaccess.Accessor buildConnection()
```
    INTERNAL: Create a new connection, accessors are used as connections.
  - getConnectionsAvailable
```
public List<org.eclipse.persistence.internal.databaseaccess.Accessor> getConnectionsAvailable()
```
    INTERNAL: returns the connections currently available for use in the pool
  - getConnectionsUsed
```
protected List<org.eclipse.persistence.internal.databaseaccess.Accessor> getConnectionsUsed()
```
    Return a list of the connections that are being used.
    
    Returns:
    
    java.util.Vector
  - getLogin
```
public Login getLogin()
```
    PUBLIC: Return the login used to create connections.
  - getMaxNumberOfConnections
```
public int getMaxNumberOfConnections()
```
    PUBLIC: Return the maximum number of connections allowed. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. When the max is reached clients must wait for a connection to become available.
  - getMinNumberOfConnections
```
public int getMinNumberOfConnections()
```
    PUBLIC: Return the minimum number of connections. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects.
  - getName
```
public String getName()
```
    PUBLIC: Return the name of this pool. Pools are identified by name to allow multiple connection pools.
  - getOwner
```
protected ServerSession getOwner()
```
    Return the ServerSession that is the owner of this connection pool.
    
    Returns:
    
    org.eclipse.persistence.sessions.server.ServerSession
  - getTotalNumberOfConnections
```
public int getTotalNumberOfConnections()
```
    INTERNAL: Return the total number of connections currently in use.
  - hasConnectionAvailable
```
public boolean hasConnectionAvailable()
```
    INTERNAL: Wait until a connection is avaiable and allocate the connection for the client.
  - isConnected
```
public boolean isConnected()
```
    INTERNAL: Return if this pool has been connected to the database.
  - isThereConflictBetweenLoginAndType
```
public boolean isThereConflictBetweenLoginAndType()
```
    INTERNAL: Checks for a conflict between pool's type and pool's login
  - releaseConnection
```
public void releaseConnection(org.eclipse.persistence.internal.databaseaccess.Accessor connection)
                       throws DatabaseException
```
    INTERNAL: Add the connection as single that a new connection is available.
    
    Throws:
    
    DatabaseException
  - resetConnections
```
public void resetConnections()
```
    INTERNAL: Reset the connections on shutDown and when the pool is started.
  - setCheckConnections
```
public void setCheckConnections()
```
    INTERNAL: This method is called to indicate that all available connections should be checked.
  - setConnectionsAvailable
```
protected void setConnectionsAvailable(Vector connectionsAvailable)
```
    INTERNAL: Set this list of connections available
  - setConnectionsUsed
```
protected void setConnectionsUsed(Vector connectionsUsed)
```
    INTERNAL: Set the list of connections being used.
  - setIsConnected
```
public void setIsConnected(boolean isConnected)
```
    INTERNAL: Set if this pool has been connected to the database.
  - setLogin
```
public void setLogin(Login login)
```
    PUBLIC: Set the login used to create connections.
  - getInitialNumberOfConnections
```
public int getInitialNumberOfConnections()
```
    PUBLIC: Return the initial number of connections allowed. This is the number of connections connected on startup.
  - setInitialNumberOfConnections
```
public void setInitialNumberOfConnections(int initialNumberOfConnections)
```
    PUBLIC: Set the initial number of connections allowed. This is the number of connections connected on startup. The default is 1.
  - setMaxNumberOfConnections
```
public void setMaxNumberOfConnections(int maxNumberOfConnections)
```
    PUBLIC: Set the maximum number of connections allowed. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. When the max is reached clients must wait for a connection to become available. The default is 32.
  - setMinNumberOfConnections
```
public void setMinNumberOfConnections(int minNumberOfConnections)
```
    PUBLIC: Set the minimum number of connections. If all connections are in use, a new connection will be created until the maximum size is reach. Only the minimum number of connections will be pooled, if the pool is between the min and max size the connection will be disconnected when returned to the pool. Typically it is desirable to have the min and max connections the same to avoid connects and disconnects. The default is 32.
  - setName
```
public void setName(String name)
```
    PUBLIC: Set the name of this pool. Pools are identified by name to allow multiple connection pools.
  - setOwner
```
protected void setOwner(ServerSession owner)
```
    Set the ServerSession that owns this connection pool
  - shutDown
```
public void shutDown()
```
    INTERNAL: Disconnect all connections.
  - startUp
```
public void startUp()
```
    INTERNAL: Allocate the minimum connections.
  - toString
```
public String toString()
```
    INTERNAL: return a string representation of this connection pool
    
    Overrides:
    
    toString in class Object
  - getWaitTimeout
```
public int getWaitTimeout()
```
    PUBLIC: Return the time in milliseconds to wait for a available connection. If the wait time is exceeded and exception will occur. The default is 180000 or 3 minutes. A value of 0 means wait forever.
  - setWaitTimeout
```
public void setWaitTimeout(int waitTimeout)
```
    PUBLIC: Set the time in milliseconds to wait for an available connection. If the wait time is exceeded an exception will occur. The default is 180000 or 3 minutes. A value of 0 means wait forever.
  - isDead
```
public boolean isDead()
```
    ADVANCED: Return if the connection pool's database is down, and failover should be used.
  - setIsDead
```
public void setIsDead(boolean isDead)
```
    ADVANCED: Set if the connection pool's database is down, and failover should be used.
  - getFailoverConnectionPools
```
public List<String> getFailoverConnectionPools()
```
    PUBLIC: Return the list of connection pools to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.
  - setFailoverConnectionPools
```
public void setFailoverConnectionPools(List<String> failoverConnectionPools)
```
    PUBLIC: Set the list of connection pools to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.
  - addFailoverConnectionPool
```
public boolean addFailoverConnectionPool(String poolName)
```
    PUBLIC: Add the connection pool to used if this pool database goes down. The failover pools should be a clustered, replicated or backuped database.

Class ConnectionPool

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MONITOR_HEADER

isConnected

maxNumberOfConnections

minNumberOfConnections

initialNumberOfConnections

waitTimeout

connectionsAvailable

connectionsUsed

login

name

owner

checkConnections

timeOfDeath

deadCheckTime

isDead

failoverConnectionPools

DEAD_CHECK_TIME

MAX_CONNECTIONS

MIN_CONNECTIONS

INITIAL_CONNECTIONS

WAIT_TIMEOUT

Constructor Detail

ConnectionPool

ConnectionPool

ConnectionPool

ConnectionPool

Method Detail

failover

acquireConnection

buildConnection

getConnectionsAvailable

getConnectionsUsed

getLogin

getMaxNumberOfConnections

getMinNumberOfConnections

getName

getOwner

getTotalNumberOfConnections

hasConnectionAvailable

isConnected

isThereConflictBetweenLoginAndType

releaseConnection

resetConnections

setCheckConnections

setConnectionsAvailable

setConnectionsUsed

setIsConnected

setLogin

getInitialNumberOfConnections

setInitialNumberOfConnections

setMaxNumberOfConnections

setMinNumberOfConnections

setName

setOwner

shutDown

startUp

toString

getWaitTimeout

setWaitTimeout

isDead

setIsDead

getFailoverConnectionPools

setFailoverConnectionPools

addFailoverConnectionPool