| Methods Summary |
|---|
| 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.
if ( isAggressiveRelease() ) {
if ( isFlushing ) {
log.debug( "skipping aggressive-release due to flush cycle" );
}
else if ( batcher.hasOpenResources() ) {
log.debug( "skipping aggresive-release due to open resources on batcher" );
}
else if ( borrowedConnection != null ) {
log.debug( "skipping aggresive-release due to borrowed connection" );
}
else {
aggressiveRelease();
}
}
|
| public void | afterTransaction()To be called after local transaction completion. Used to conditionally
release the JDBC connection aggressively if the configured release mode
indicates.
if ( isAfterTransactionRelease() ) {
aggressiveRelease();
}
else if ( isAggressiveReleaseNoTransactionCheck() && batcher.hasOpenResources() ) {
log.info( "forcing batcher resource cleanup on transaction completion; forgot to close ScrollableResults/Iterator?" );
batcher.closeStatements();
aggressiveRelease();
}
else if ( isOnCloseRelease() ) {
// log a message about potential connection leaks
log.debug( "transaction completed on session with on_close connection release mode; be sure to close the session to release JDBC resources!" );
}
batcher.unsetTransactionTimeout();
|
| private void | aggressiveRelease()Performs actions required to perform an aggressive release of the
JDBC Connection.
if ( !wasConnectionSupplied ) {
log.debug( "aggressively releasing JDBC connection" );
if ( connection != null ) {
closeConnection();
}
}
|
| public java.sql.Connection | borrowConnection()
if ( isClosed ) {
throw new HibernateException( "connection manager has been closed" );
}
if ( isSuppliedConnection() ) {
return connection;
}
else {
if ( borrowedConnection == null ) {
borrowedConnection = BorrowedConnectionProxy.generateProxy( this );
}
return borrowedConnection;
}
|
| private java.sql.Connection | cleanup()Releases the Connection and cleans up any resources associated with
that Connection. This is intended for use:
1) at the end of the session
2) on a manual disconnect of the session
3) from afterTransaction(), in the case of skipped aggressive releasing
releaseBorrowedConnection();
if ( connection == null ) {
log.trace( "connection already null in cleanup : no action");
return null;
}
try {
log.trace( "performing cleanup" );
batcher.closeStatements();
Connection c = null;
if ( !wasConnectionSupplied ) {
closeConnection();
}
else {
c = connection;
}
connection = null;
return c;
}
finally {
callback.connectionCleanedUp();
}
|
| public java.sql.Connection | close()To be called after Session completion. Used to release the JDBC
connection.
try {
return cleanup();
}
finally {
isClosed = true;
}
|
| private void | closeConnection()Physically closes the JDBC Connection.
if ( log.isDebugEnabled() ) {
log.debug(
"releasing JDBC connection [" +
batcher.openResourceStatsAsString() + "]"
);
}
try {
if ( !connection.isClosed() ) {
JDBCExceptionReporter.logAndClearWarnings( connection );
}
factory.getConnectionProvider().closeConnection( connection );
connection = null;
}
catch (SQLException sqle) {
throw JDBCExceptionHelper.convert(
factory.getSQLExceptionConverter(),
sqle,
"Cannot release connection"
);
}
|
| public static org.hibernate.jdbc.ConnectionManager | deserialize(java.io.ObjectInputStream ois, org.hibernate.engine.SessionFactoryImplementor factory, org.hibernate.Interceptor interceptor, org.hibernate.ConnectionReleaseMode connectionReleaseMode, JDBCContext jdbcContext)
return new ConnectionManager(
factory,
jdbcContext,
connectionReleaseMode,
interceptor,
ois.readBoolean(),
ois.readBoolean()
);
|
| 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 {@link #flushEnding()}
log.trace( "registering flush begin" );
isFlushing = true;
|
| public void | flushEnding()Callback to let us know that a flush is ending. We use this fact to
stop circumventing aggressive releasing connections.
log.trace( "registering flush end" );
isFlushing = false;
afterStatement();
|
| public Batcher | getBatcher()The batcher managed by this ConnectionManager.
return batcher;
|
| public java.sql.Connection | getConnection()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).
if ( isClosed ) {
throw new HibernateException( "connection manager has been closed" );
}
if ( connection == null ) {
openConnection();
}
return connection;
|
| public org.hibernate.engine.SessionFactoryImplementor | getFactory()The session factory.
return factory;
|
| public boolean | hasBorrowedConnection()
// used from testsuite
return borrowedConnection != null;
|
| private boolean | isAfterTransactionRelease()
return releaseMode == ConnectionReleaseMode.AFTER_TRANSACTION;
|
| public boolean | isAggressiveRelease()Will connections be released after each statement execution?
Connections will be released after each statement if either: |
| private boolean | isAggressiveReleaseNoTransactionCheck()Modified version of {@link #isAggressiveRelease} which does not force a
transaction check. This is solely used from our {@link #afterTransaction}
callback, so no need to do the check; plus it seems to cause problems on
websphere (god i love websphere ;)
It uses this information to decide if an aggressive release was skipped
do to open resources, and if so forces a release.
if ( releaseMode == ConnectionReleaseMode.AFTER_STATEMENT ) {
return true;
}
else {
boolean inAutoCommitState;
try {
inAutoCommitState = isAutoCommit();
}
catch( SQLException e ) {
// assume we are in an auto-commit state
inAutoCommitState = true;
}
return releaseMode == ConnectionReleaseMode.AFTER_TRANSACTION && inAutoCommitState;
}
|
| public boolean | isAutoCommit()Is the connection considered "auto-commit"?
return connection == null
|| connection.isClosed()
|| connection.getAutoCommit();
|
| 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.
return wasConnectionSupplied ? connection != null : !isClosed;
|
| private boolean | isOnCloseRelease()
return releaseMode == ConnectionReleaseMode.ON_CLOSE;
|
| public boolean | isReadyForSerialization()
return wasConnectionSupplied ? connection == null : !batcher.hasOpenResources();
|
| public boolean | isSuppliedConnection()Was the connection being used here supplied by the user?
return wasConnectionSupplied;
|
| public java.sql.Connection | manualDisconnect()Manually disconnect the underlying JDBC Connection. The assumption here
is that the manager will be reconnected at a later point in time.
return cleanup();
|
| 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.
|
| public void | manualReconnect(java.sql.Connection suppliedConnection)Manually reconnect the underlying JDBC Connection. Should be called at
some point after manualDisconnect().
This form is used for user-supplied connections.
this.connection = suppliedConnection;
|
| private void | openConnection()Pysically opens a JDBC Connection.
if ( connection != null ) {
return;
}
log.debug("opening JDBC connection");
try {
connection = factory.getConnectionProvider().getConnection();
}
catch (SQLException sqle) {
throw JDBCExceptionHelper.convert(
factory.getSQLExceptionConverter(),
sqle,
"Cannot open connection"
);
}
callback.connectionOpened(); // register synch; stats.connect()
|
| private void | readObject(java.io.ObjectInputStream ois)Used during deserialization.
factory = (SessionFactoryImplementor) ois.readObject();
interceptor = (Interceptor) ois.readObject();
ois.defaultReadObject();
this.batcher = factory.getSettings().getBatcherFactory().createBatcher( this, interceptor );
|
| public void | releaseBorrowedConnection()
if ( borrowedConnection != null ) {
try {
BorrowedConnectionProxy.renderUnuseable( borrowedConnection );
}
finally {
borrowedConnection = null;
}
}
|
| public void | serialize(java.io.ObjectOutputStream oos)
oos.writeBoolean( wasConnectionSupplied );
oos.writeBoolean( isClosed );
|
| private void | writeObject(java.io.ObjectOutputStream oos)Used during serialization.
if ( !isReadyForSerialization() ) {
throw new IllegalStateException( "Cannot serialize a ConnectionManager while connected" );
}
oos.writeObject( factory );
oos.writeObject( interceptor );
oos.defaultWriteObject();
|
