public JDBCContext(JDBCContext.Context owner,
    Connection connection,
    Interceptor interceptor) 
{
	       
		this.owner = owner;
		this.connectionManager = new ConnectionManager(
		        owner.getFactory(),
		        this,
		        owner.getConnectionReleaseMode(),
		        connection,
		        interceptor
			);
		final boolean registerSynchronization = owner.isAutoCloseSessionEnabled()
		        || owner.isFlushBeforeCompletionEnabled()
		        || owner.getConnectionReleaseMode() == ConnectionReleaseMode.AFTER_TRANSACTION;
		if ( registerSynchronization ) {
			registerSynchronizationIfPossible();
		}
}

 public  void afterNontransactionalQuery(boolean success) 
{
		log.trace( "after autocommit" );
		try {
			// check to see if the connection is in auto-commit 
			// mode (no connection means aggressive connection
			// release outside a JTA transaction context, so MUST
			// be autocommit mode)
			boolean isAutocommit = connectionManager.isAutoCommit();
			connectionManager.afterTransaction();
			if ( isAutocommit ) {
				owner.afterTransactionCompletion(success, null);
			}
		}
		catch (SQLException sqle) {
			throw JDBCExceptionHelper.convert( 
					owner.getFactory().getSQLExceptionConverter(),
					sqle,
					"could not inspect JDBC autocommit mode"
				);
		}
}

Called after executing a query outside the scope of a Hibernate or JTA transaction

 public  void afterTransactionBegin(Transaction tx) 
{
		log.trace( "after transaction begin" );
		owner.afterTransactionBegin(tx);
}

We cannot rely upon this method being called! It is only called if we are using Hibernate Transaction API.

 public  void afterTransactionCompletion(boolean success,
    Transaction tx) 
{
		log.trace( "after transaction completion" );
		if ( getFactory().getStatistics().isStatisticsEnabled() ) {
			getFactory().getStatisticsImplementor().endTransaction(success);
		}
		connectionManager.afterTransaction();
		isTransactionCallbackRegistered = false;
		hibernateTransaction = null;
		owner.afterTransactionCompletion(success, tx);
}

 public  void beforeTransactionCompletion(Transaction tx) 
{
		log.trace( "before transaction completion" );
		owner.beforeTransactionCompletion(tx);
}

 public Connection borrowConnection() 
{
		return connectionManager.borrowConnection();
}

 public Connection connection() throws HibernateException 
{
		if ( owner.isClosed() ) {
			throw new SessionException( "Session is closed" );
		}
		return connectionManager.getConnection();
}

 public  void connectionCleanedUp() 
{
		if ( !isTransactionCallbackRegistered ) {
			afterTransactionCompletion( false, null );
			// Note : success = false, because we don't know the outcome of the transaction
		}
}

 public  void connectionOpened() 
{
		if ( owner.getFactory().getStatistics().isStatisticsEnabled() ) {
			owner.getFactory().getStatisticsImplementor().connect();
		}
}

 public static JDBCContext deserialize(ObjectInputStream ois,
    JDBCContext.Context context,
    Interceptor interceptor) throws IOException 
{
		JDBCContext jdbcContext = new JDBCContext();
		jdbcContext.owner = context;
		jdbcContext.connectionManager = ConnectionManager.deserialize(
				ois,
				context.getFactory(),
		        interceptor,
		        context.getConnectionReleaseMode(),
		        jdbcContext
		);
		return jdbcContext;
}

Custom deserialization routine used during deserialization of a Session/PersistenceContext for increased performance.

 public ConnectionManager getConnectionManager() 
{
		return connectionManager;
}

 public SessionFactoryImplementor getFactory() 
{
		return owner.getFactory();
}

 public Transaction getTransaction() throws HibernateException 
{
		if (hibernateTransaction==null) {
			hibernateTransaction = owner.getFactory().getSettings()
					.getTransactionFactory()
					.createTransaction( this, owner );
		}
		return hibernateTransaction;
}

 public boolean isTransactionInProgress() 
{
		return owner.getFactory().getSettings().getTransactionFactory()
				.isTransactionInProgress( this, owner, hibernateTransaction );
}

 public boolean registerCallbackIfNecessary() 
{
		if ( isTransactionCallbackRegistered ) {
			return false;
		}
		else {
			isTransactionCallbackRegistered = true;
			return true;
		}
}

 public boolean registerSynchronizationIfPossible() 
{
		if ( isTransactionCallbackRegistered ) {
			// we already have a callback registered; either a local
			// (org.hibernate.Transaction) transaction has accepted
			// callback responsibilities, or we have previously
			// registered a transaction synch.
			return true;
		}
		boolean localCallbacksOnly = owner.getFactory().getSettings()
				.getTransactionFactory()
				.areCallbacksLocalToHibernateTransactions();
		if ( localCallbacksOnly ) {
			// the configured transaction-factory says it only supports
			// local callback mode, so no sense attempting to register a
			// JTA Synchronization
			return false;
		}
		TransactionManager tm = owner.getFactory().getTransactionManager();
		if ( tm == null ) {
			// if there is no TM configured, we will not be able to access
			// the javax.transaction.Transaction object in order to
			// register a synch anyway.
			return false;
		}
		else {
			try {
				if ( !isTransactionInProgress() ) {
					log.trace( "TransactionFactory reported no active transaction; Synchronization not registered" );
					return false;
				}
				else {
					javax.transaction.Transaction tx = tm.getTransaction();
					if ( JTAHelper.isMarkedForRollback( tx ) ) {
						// transactions marked for rollback-only cause some TM impls to throw exceptions
						log.debug( "Transaction is marked for rollback; skipping Synchronization registration" );
						return false;
					}
					else {
						if ( hibernateTransaction == null ) {
							hibernateTransaction = owner.getFactory().getSettings().getTransactionFactory().createTransaction( this, owner );
						}
						tx.registerSynchronization( new CacheSynchronization(owner, this, tx, hibernateTransaction) );
						isTransactionCallbackRegistered = true;
						log.debug("successfully registered Synchronization");
						return true;
					}
				}
			}
			catch( HibernateException e ) {
				throw e;
			}
			catch (Exception e) {
				throw new TransactionException( "could not register synchronization with JTA TransactionManager", e );
			}
		}
}

 public  void serialize(ObjectOutputStream oos) throws IOException 
{
		connectionManager.serialize( oos );
}

Custom serialization routine used during serialization of a Session/PersistenceContext for increased performance.