org.hibernate.jdbc

Class ConnectionManager

Implemented Interfaces:
Serializable

public class ConnectionManager
extends java.lang.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

Nested Class Summary

static interface
ConnectionManager.Callback

Constructor Summary

ConnectionManager(SessionFactoryImplementor factory, ConnectionManager.Callback callback, ConnectionReleaseMode releaseMode, Connection connection, Interceptor interceptor)
Constructs a ConnectionManager.

Method Summary

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:

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)

Constructor Details

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 Details

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.

borrowConnection

public Connection borrowConnection()

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.

deserialize

public static ConnectionManager deserialize(ObjectInputStream ois,
                                            SessionFactoryImplementor factory,
                                            Interceptor interceptor,
                                            ConnectionReleaseMode connectionReleaseMode,
                                            JDBCContext jdbcContext)
            throws IOException

flushBeginning

public void flushBeginning()

flushEnding

public void flushEnding()
Callback to let us know that a flush is ending. We use this fact to stop circumventing aggressive releasing connections.

getBatcher

public Batcher getBatcher()
The batcher managed by this ConnectionManager.
Returns:
The batcher.

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

getFactory

public SessionFactoryImplementor getFactory()
The session factory.
Returns:
the session factory.

hasBorrowedConnection

public boolean hasBorrowedConnection()

isAggressiveRelease

public boolean isAggressiveRelease()
Returns:
True if the connections will be released after each statement; false otherwise.

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.

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.

isReadyForSerialization

public boolean isReadyForSerialization()

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

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.


releaseBorrowedConnection

public void releaseBorrowedConnection()

serialize

public void serialize(ObjectOutputStream oos)
            throws IOException