ConnectionManager (Hibernate Core Aggregator 3.6.10.Final API)

java.lang.Object
- org.hibernate.jdbc.ConnectionManager

All Implemented Interfaces:

Serializable
```
public class ConnectionManager
extends Object
implements Serializable
```
Encapsulates JDBC Connection management logic needed by Hibernate.
The lifecycle is intended to span a logical series of interactions with the database. Internally, this means the the lifecycle of the Session.

Author:

Steve Ebersole

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static interface ConnectionManager.Callback

Nested Classes
Modifier and Type	Class and Description
`static interface`	`ConnectionManager.Callback`

Constructor Summary

Constructors
Constructor and Description
`ConnectionManager(SessionFactoryImplementor factory, ConnectionManager.Callback callback, ConnectionReleaseMode releaseMode, Connection connection, Interceptor interceptor)` Constructs a ConnectionManager.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`afterStatement()` To be called after execution of each JDBC statement.
`void`	`afterTransaction()` To be called after local transaction completion.
`Connection`	`borrowConnection()`
`Connection`	`close()` To be called after Session completion.
`static ConnectionManager`	`deserialize(ObjectInputStream ois, SessionFactoryImplementor factory, Interceptor interceptor, ConnectionReleaseMode connectionReleaseMode, JDBCContext jdbcContext)`
`void`	`flushBeginning()` Callback to let us know that a flush is beginning.
`void`	`flushEnding()` Callback to let us know that a flush is ending.
`Batcher`	`getBatcher()` The batcher managed by this ConnectionManager.
`Connection`	`getConnection()` Retrieves the connection currently managed by this ConnectionManager.
`SessionFactoryImplementor`	`getFactory()` The session factory.
`boolean`	`hasBorrowedConnection()`
`boolean`	`isAggressiveRelease()` Will connections be released after each statement execution? Connections will be released after each statement if either: the defined release-mode is `ConnectionReleaseMode.AFTER_STATEMENT`; or the defined release-mode is `ConnectionReleaseMode.AFTER_TRANSACTION` but we are in auto-commit mode.
`boolean`	`isAutoCommit()` Is the connection considered "auto-commit"?
`boolean`	`isCurrentlyConnected()` Is this ConnectionManager instance "logically" connected.
`boolean`	`isReadyForSerialization()`
`boolean`	`isSuppliedConnection()` Was the connection being used here supplied by the user?
`Connection`	`manualDisconnect()` Manually disconnect the underlying JDBC Connection.
`void`	`manualReconnect()` Manually reconnect the underlying JDBC Connection.
`void`	`manualReconnect(Connection suppliedConnection)` Manually reconnect the underlying JDBC Connection.
`void`	`releaseBorrowedConnection()`
`void`	`serialize(ObjectOutputStream oos)`

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

- Constructor Detail
  - ConnectionManager
```
public ConnectionManager(SessionFactoryImplementor factory,
                 ConnectionManager.Callback callback,
                 ConnectionReleaseMode releaseMode,
                 Connection connection,
                 Interceptor interceptor)
```
    Constructs a ConnectionManager.
    This is the form used internally.
    
    Parameters:
    factory - The SessionFactory.
    callback - An observer for internal state change.
    releaseMode - The mode by which to release JDBC connections.
    connection - An externally supplied connection.
- Method Detail
  - getFactory
```
public SessionFactoryImplementor getFactory()
```
    The session factory.
    
    Returns:
    the session factory.
  - getBatcher
```
public Batcher getBatcher()
```
    The batcher managed by this ConnectionManager.
    
    Returns:
    The batcher.
  - isSuppliedConnection
```
public boolean isSuppliedConnection()
```
    Was the connection being used here supplied by the user?
    
    Returns:
    True if the user supplied the JDBC connection; false otherwise
  - getConnection
```
public Connection getConnection()
                         throws HibernateException
```
    Retrieves the connection currently managed by this ConnectionManager.
    Note, that we may need to obtain a connection to return here if a connection has either not yet been obtained (non-UserSuppliedConnectionProvider) or has previously been aggressively released (if supported in this environment).
    
    Returns:
    The current Connection.
    
    Throws:
    
    HibernateException - Indicates a connection is currently not available (we are currently manually disconnected).
  - hasBorrowedConnection
```
public boolean hasBorrowedConnection()
```
  - borrowConnection
```
public Connection borrowConnection()
```
  - releaseBorrowedConnection
```
public void releaseBorrowedConnection()
```
  - isAutoCommit
```
public boolean isAutoCommit()
                     throws SQLException
```
    Is the connection considered "auto-commit"?
    
    Returns:
    True if we either do not have a connection, or the connection really is in auto-commit mode.
    
    Throws:
    
    SQLException - Can be thrown by the Connection.isAutoCommit() check.
  - isAggressiveRelease
```
public boolean isAggressiveRelease()
```
    Will connections be released after each statement execution?
    Connections will be released after each statement if either:
    - the defined release-mode is ConnectionReleaseMode.AFTER_STATEMENT; or
    - the defined release-mode is ConnectionReleaseMode.AFTER_TRANSACTION but we are in auto-commit mode.
      release-mode = ConnectionReleaseMode.ON_CLOSE should [b]never[/b] release a connection.
    Returns:
    True if the connections will be released after each statement; false otherwise.
  - isCurrentlyConnected
```
public boolean isCurrentlyConnected()
```
    Is this ConnectionManager instance "logically" connected. Meaning do we either have a cached connection available or do we have the ability to obtain a connection on demand.
    
    Returns:
    True if logically connected; false otherwise.
  - afterStatement
```
public void afterStatement()
```
    To be called after execution of each JDBC statement. Used to conditionally release the JDBC connection aggressively if the configured release mode indicates.
  - afterTransaction
```
public void afterTransaction()
```
    To be called after local transaction completion. Used to conditionally release the JDBC connection aggressively if the configured release mode indicates.
  - close
```
public Connection close()
```
    To be called after Session completion. Used to release the JDBC connection.
    
    Returns:
    The connection mantained here at time of close. Null if there was no connection cached internally.
  - manualDisconnect
```
public Connection manualDisconnect()
```
    Manually disconnect the underlying JDBC Connection. The assumption here is that the manager will be reconnected at a later point in time.
    
    Returns:
    The connection mantained here at time of disconnect. Null if there was no connection cached internally.
  - manualReconnect
```
public void manualReconnect()
```
    Manually reconnect the underlying JDBC Connection. Should be called at some point after manualDisconnect().
    This form is used for ConnectionProvider-supplied connections.
  - manualReconnect
```
public void manualReconnect(Connection suppliedConnection)
```
    Manually reconnect the underlying JDBC Connection. Should be called at some point after manualDisconnect().
    This form is used for user-supplied connections.
  - flushBeginning
```
public void flushBeginning()
```
    Callback to let us know that a flush is beginning. We use this fact to temporarily circumvent aggressive connection releasing until after the flush cycle is complete flushEnding()
  - flushEnding
```
public void flushEnding()
```
    Callback to let us know that a flush is ending. We use this fact to stop circumventing aggressive releasing connections.
  - isReadyForSerialization
```
public boolean isReadyForSerialization()
```
  - serialize
```
public void serialize(ObjectOutputStream oos)
               throws IOException
```
    Throws:
    
    IOException
  - deserialize
```
public static ConnectionManager deserialize(ObjectInputStream ois,
                            SessionFactoryImplementor factory,
                            Interceptor interceptor,
                            ConnectionReleaseMode connectionReleaseMode,
                            JDBCContext jdbcContext)
                                     throws IOException
```
    Throws:
    
    IOException

Class ConnectionManager

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ConnectionManager

Method Detail

getFactory

getBatcher

isSuppliedConnection

getConnection

hasBorrowedConnection

borrowConnection

releaseBorrowedConnection

isAutoCommit

isAggressiveRelease

isCurrentlyConnected

afterStatement

afterTransaction

close

manualDisconnect

manualReconnect

manualReconnect

flushBeginning

flushEnding

isReadyForSerialization

serialize

deserialize