org.hibernate.context: public class: ThreadLocalSessionContext

org.hibernate.context
public class: ThreadLocalSessionContext [javadoc | source]

java.lang.Object
   org.hibernate.context.ThreadLocalSessionContext

All Implemented Interfaces:
CurrentSessionContext

A CurrentSessionContext impl which scopes the notion of current session by the current thread of execution. Unlike the JTA counterpart, threads do not give us a nice hook to perform any type of cleanup making it questionable for this impl to actually generate Session instances. In the interest of usability, it was decided to have this default impl actually generate a session upon first request and then clean it up after the org.hibernate.Transaction associated with that session is committed/rolled-back. In order for ensuring that happens, the sessions generated here are unusable until after Session#beginTransaction() has been called. If close() is called on a session managed by this class, it will be automatically unbound.

Additionally, the static #bind and #unbind methods are provided to allow application code to explicitly control opening and closing of these sessions. This, with some from of interception, is the preferred approach. It also allows easy framework integration and one possible approach for implementing long-sessions.

The #buildOrObtainSession , #isAutoCloseEnabled , #isAutoFlushEnabled , #getConnectionReleaseMode , and #buildCleanupSynch methods are all provided to allow easy subclassing (for long-running session scenarios, for example).

author: Steve - Ebersole

Nested Class Summary:
protected static class	ThreadLocalSessionContext.CleanupSynch	JTA transaction synch used for cleanup of the internal session map.

Field Summary
protected final SessionFactoryImplementor	factory

Constructor:
public ThreadLocalSessionContext(SessionFactoryImplementor factory) { this.factory = factory; }

Method from org.hibernate.context.ThreadLocalSessionContext Summary:
bind, buildCleanupSynch, buildOrObtainSession, currentSession, getConnectionReleaseMode, getFactory, isAutoCloseEnabled, isAutoFlushEnabled, sessionMap, unbind, wrap

Methods from java.lang.Object:
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from org.hibernate.context.ThreadLocalSessionContext Detail:
public static void bind(Session session) { SessionFactory factory = session.getSessionFactory(); cleanupAnyOrphanedSession( factory ); doBind( session, factory ); } Associates the given session with the current thread of execution.
protected ThreadLocalSessionContext.CleanupSynch buildCleanupSynch() { return new CleanupSynch( factory ); }
protected Session buildOrObtainSession() { return factory.openSession( null, isAutoFlushEnabled(), isAutoCloseEnabled(), getConnectionReleaseMode() ); } Strictly provided for subclassing purposes; specifically to allow long-session support. This implementation always just opens a new session.
public final Session currentSession() throws HibernateException { Session current = existingSession( factory ); if (current == null) { current = buildOrObtainSession(); // register a cleanup synch current.getTransaction().registerSynchronization( buildCleanupSynch() ); // wrap the session in the transaction-protection proxy if ( needsWrapping( current ) ) { current = wrap( current ); } // then bind it doBind( current, factory ); } return current; } {@inheritDoc}
protected ConnectionReleaseMode getConnectionReleaseMode() { return factory.getSettings().getConnectionReleaseMode(); } Mainly for subclass usage. This impl always returns after_transaction.
protected SessionFactoryImplementor getFactory() { return factory; } Getter for property 'factory'.
protected boolean isAutoCloseEnabled() { return true; } Mainly for subclass usage. This impl always returns true.
protected boolean isAutoFlushEnabled() { return true; } Mainly for subclass usage. This impl always returns true.
protected static Map sessionMap() { return ( Map ) context.get(); }
public static Session unbind(SessionFactory factory) { return doUnbind( factory, true ); } Unassociate a previously bound session from the current thread of execution.
protected Session wrap(Session session) { TransactionProtectionWrapper wrapper = new TransactionProtectionWrapper( session ); Session wrapped = ( Session ) Proxy.newProxyInstance( Session.class.getClassLoader(), SESS_PROXY_INTERFACES, wrapper ); // yick! need this for proper serialization/deserialization handling... wrapper.setWrapped( wrapped ); return wrapped; }

Method from org.hibernate.context.ThreadLocalSessionContext Detail:

 public static  void bind(Session session) {
		SessionFactory factory = session.getSessionFactory();
		cleanupAnyOrphanedSession( factory );
		doBind( session, factory );
}

Associates the given session with the current thread of execution.

 protected ThreadLocalSessionContext.CleanupSynch buildCleanupSynch() {
		return new CleanupSynch( factory );
}

 protected Session buildOrObtainSession() {
		return factory.openSession(
				null,
		        isAutoFlushEnabled(),
		        isAutoCloseEnabled(),
		        getConnectionReleaseMode()
			);
}

This implementation always just opens a new session.

 public final Session currentSession() throws HibernateException {
		Session current = existingSession( factory );
		if (current == null) {
			current = buildOrObtainSession();
			// register a cleanup synch
			current.getTransaction().registerSynchronization( buildCleanupSynch() );
			// wrap the session in the transaction-protection proxy
			if ( needsWrapping( current ) ) {
				current = wrap( current );
			}
			// then bind it
			doBind( current, factory );
		}
		return current;
}

{@inheritDoc}

 protected ConnectionReleaseMode getConnectionReleaseMode() {
		return factory.getSettings().getConnectionReleaseMode();
}

Mainly for subclass usage. This impl always returns after_transaction.

 protected SessionFactoryImplementor getFactory() {
		return factory;
}

Getter for property 'factory'.

 protected boolean isAutoCloseEnabled() {
		return true;
}

Mainly for subclass usage. This impl always returns true.

 protected boolean isAutoFlushEnabled() {
		return true;
}

Mainly for subclass usage. This impl always returns true.

 protected static Map sessionMap() {
		return ( Map ) context.get();
}

 public static Session unbind(SessionFactory factory) {
		return doUnbind( factory, true );
}

Unassociate a previously bound session from the current thread of execution.

 protected Session wrap(Session session) {
		TransactionProtectionWrapper wrapper = new TransactionProtectionWrapper( session );
		Session wrapped = ( Session ) Proxy.newProxyInstance(
				Session.class.getClassLoader(),
		        SESS_PROXY_INTERFACES,
		        wrapper
			);
		// yick!  need this for proper serialization/deserialization handling...
		wrapper.setWrapped( wrapped );
		return wrapped;
}