理解Session的上下文

 

 

一、什么是上下文相关的Session(Contextual Session)?

上下文相关可以理解为范围。一个会话必须发生在一定的环境下，有一定的存活范围，而这个环境和范围就称为上下文。

假设整个应用只用一个Session,，那么这个Session的上下文就是这个应用的范围。相反，假设每次增删改查都使用全新的Session，使用一次之后又销毁掉，那么每次操作的范围都是这些Session的上下文。

 

一种常见的情况则是为每个线程绑定一个session，这就是基于ThreadLocal的上下文会话。例如，在Web应用中，每个request都必须交给一个线程来处理，如果这个线程使用session来进行数据库交互。这时候，我们首先必须拥有一个session(新建或者使用已有的), 然后再将这个session与这个线程绑定在一起。当完成绑定之后该线程生命范围内的获取当前session的操作都会返回已绑定的那个session。 

 

二、如何管理当前的session

1. 一个接口

为了管理session的上下文，hibernate提供了org.hibernate.context.CurrentSessionContext接口。这个接口只提供了一个方法：

 

	/**
	 * Retrieve the current session according to the scoping defined
	 * by this implementation.
	 *
	 * @return The current session.
	 * @throws HibernateException Typically indicates an issue
	 * locating or creating the current session.
	 */
	public org.hibernate.classic.Session currentSession() throws HibernateException;

 

 

实际上，这表示了如何获取当前session是session上下文管理中首要解决的，session上下文管理只需要管理在某种环境下该返回哪个session，而可以不必关注session本身(例如session的open，close等操作)。下面列出了hibernate内置的CurrentSessionContext接口的三种实现，你将会发现，这三种实现除了对上下文的定义不同之外，在对待session的管理上也有不同，例如是否对session进行清理，如何结合自身的特点进行清理。

 

Hibernate内置的CurrentSessionContext接口的三种实现：

1). org.hibernate.context.JTASessionContext：当前会话根据 JTA 来跟踪和界定。这和以前的仅支持 JTA 的方法是完全一样的。详情请参阅 Javadoc。

2). org.hibernate.context.ThreadLocalSessionContext：当前会话通过当前执行的线程来跟踪和界定。详情也请参阅 Javadoc。

3). org.hibernate.context.ManagedSessionContext：当前会话通过当前执行的线程来跟踪和界定。但是，你需要负责使用这个类的静态方法将 Session 实例绑定、或者取消绑定，它并不会打开（open）、flush 或者关闭（close）任何 Session。

2. 三种默认实现

1). JTASessionContext

 

/**
 * An implementation of {@link CurrentSessionContext} which scopes the notion
 * of a current session to a JTA transaction.  Because JTA gives us a nice
 * tie-in to clean up after ourselves, this implementation will generate
 * Sessions as needed provided a JTA transaction is in effect.  If a session
 * is not already associated with the current JTA transaction at the time
 * {@link #currentSession()} is called, a new session will be opened and it
 * will be associated with that JTA transaction.
 * <p/>
 * Note that the sessions returned from this method are automatically configured with
 * both the {@link org.hibernate.cfg.Environment#FLUSH_BEFORE_COMPLETION auto-flush} and
 * {@link org.hibernate.cfg.Environment#AUTO_CLOSE_SESSION auto-close} attributes set to
 * true, meaning that the Session will be automatically flushed and closed
 * as part of the lifecycle for the JTA transaction to which it is associated.
 * Additionally, it will also be configured to aggressively release JDBC
 * connections after each statement is executed.  These settings are governed
 * by the {@link #isAutoFlushEnabled()}, {@link #isAutoCloseEnabled()}, and
 * {@link #getConnectionReleaseMode()} methods; these are provided (along with
 * the {@link #buildOrObtainSession()} method) for easier subclassing for custom
 * JTA-based session tracking logic (like maybe long-session semantics).
 *
 * @author Steve Ebersole
 */
public class JTASessionContext implements CurrentSessionContext

 

JTASessionContext是一种用JTA事务来划分当前session概念的实现。由于JTA提供了一个良好的关联(tie-in)可用于清理，因此针对每个有效的JTA事务，这种实现会根据需要产生一些session。如果在调用currentSession()方法时，当前的JTA事务还没有与任何session关联，那么一个新的session将会被打开并与这个JTA事务关联起来。

 

需注意的是，这些由currentSession()方法返回的session都已经自动将org.hibernate.cfg.Environment.FLUSH_BEFORE_COMPLETION auto-flush和org.hibernate.cfg.Environment.AUTO_CLOSE_SESSION auto-close这两个属性配置为true了，这就表示这个session将会作为它所关联的JTA事务的一部分，被自动地flush和close。

 

另外，这个session还被配置成当每一个statement被执行后就主动地释放JDBC连接。这些配置是通过isAutoFlushEnabled()，isAutoCloseEnabled()和getConnectionReleaseMode()方法来控制的；这些(还有buildOrObtainSession()方法)是为了能更简单地定制基于JTA的session跟踪逻辑(像long-session这种)的子类化。

 

2). ThreadLocalSessionContext

 

/**
 * A {@link 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 {@link 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 {@link Session#beginTransaction()}
 * has been called. If <tt>close()</tt> is called on a session managed by
 * this class, it will be automatically unbound.
 * <p/>
 * Additionally, the static {@link #bind} and {@link #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.
 * <p/>
 * The {@link #buildOrObtainSession}, {@link #isAutoCloseEnabled},
 * {@link #isAutoFlushEnabled}, {@link #getConnectionReleaseMode}, and
 * {@link #buildCleanupSynch} methods are all provided to allow easy
 * subclassing (for long-running session scenarios, for example).
 *
 * @author Steve Ebersole
 */
public class ThreadLocalSessionContext implements CurrentSessionContext

 

顾名思义，ThreadLocalSessionContext是一种根据当前正在执行的线程来定义当前session的概念的。不同于JTA的是，线程并不能提供一个良好的hook(钩子)给我们来执行任何形式的清理，这也使得要用这种实现来真正地产生Session实例变得可疑。从可用性的角度出发，我们决定让默认实现在第一次请求的时候产生一个session，然后在与这个session相关的事务(org.hibernate.Transaction)提交或回滚后就清理它(清理后session处于closed状态，并与当前线程解除绑定)。为了保证这个过程能够顺利进行，新产生的session们必须等到session.beginTransaction()方法被调用后才能够可用。如果这个类所管理的sesion的close()方法被调用了，那么这个session将自动地解除与这个类的绑定。

 

另外，为了能够明确地控制session们的开闭，ThreadLocalSessionContext提供了bind和unbind这些静态方法。这种带有些许Interception方式的实现是一种更好的方法。它允许了简单框架的集成，也为实现长session(long-session)提供了一种可能。

 

buildOrObtainSession(), isAutoCloseEnabled(), isAutoFlushEnabled(), getConnectionReleaseMode(), 和 buildCleanupSynch()这些方法是提供给子类用于定制相关行为时使用的(例如用于long-running session的场合)。

 

 

根据上述的内容，如果不想让session在每次事务提交或回滚后就关闭(同时解除绑定)，则可以通过继承ThreadLocalSessionContext并重写isAutoClosedEnabled()方法使其返回false。这样，在每次事务完成后将不再自动地关闭session，你可以通过显式的调用session.close()方法来关闭它。而且你可能还需要调用unbind()方法来显式地将session与当前线程解除绑定。

 

3). ManagedSessionContext

 

/**
 * Represents a {@link CurrentSessionContext} the notion of a contextual session
 * is managed by some external entity (generally some form of interceptor, etc).
 * This external manager is responsible for scoping these contextual sessions
 * appropriately binding/unbinding them here for exposure to the application
 * through {@link SessionFactory#getCurrentSession} calls.
 * <p/>
 *  Basically exposes two interfaces.  <ul>
 * <li>First is the implementation of CurrentSessionContext which is then used
 * by the {@link SessionFactory#getCurrentSession()} calls.  This
 * portion is instance-based specific to the session factory owning the given
 * instance of this impl (there will be one instance of this per each session
 * factory using this strategy).
 * <li>Second is the externally facing methods {@link #hasBind}, {@link #bind},
 * and {@link #unbind} used by the external thing to manage exposure of the
 * current session it is scoping.  This portion is static to allow easy
 * reference from that external thing.
 * </ul>
 * The underlying storage of the current sessions here is a static
 * {@link ThreadLocal}-based map where the sessions are keyed by the
 * the owning session factory.
 *
 * @author Steve Ebersole
 */
public class ManagedSessionContext implements CurrentSessionContext 

 

 

ManagedSessionContext是上下文会话由外部实体(一般指interceptor等)管理的一种实现。
外部管理器负责通过绑定和解除绑定(binding/unbinding)来合适地确定这些会话的范围，并提供SessionFactory的getCurrentSession方法给应用来调用。

 

主要提供了以下两个接口：

• 第一是提供CurrentSessionContext的实现，这是在调用SessionFactory的getCurrentSession()方法时用到的[只有实现了会话的上下文，SessionFactory在调用getCurrentSession()时才会知道哪个session是当前的，才能返回它]。 这部分的实现是基于实例的，针对每个SessionFactory都会有一个指定的实现了CurrentSessionContext的实例(每个使用这种策略的session factory都会有一个CurrentSessionContext的实例)。
  
• 第二是外部方法，包括hasBind,bind,unbind等。外部管理器用这些方法来管理它所拥有的session的暴露程度的。这一部分旨在允许通过对外部管理器提供方法的简单引用来管理session。

在这种实现方式下，session的底层存储方法是基于静态(ThreadLocal)map的，session们是value，而拥有这些session的session factory则是key。

 

 

 

使用ManagedSessionContext我们可定制的内容将更多。例如在session的关闭上，ThreadLocalSessionContext默认在事务结束之后就关闭当前session并解除绑定关系，而ManagedSessionContext默认不关闭session，你只能通过session的close(()方法和ManagedSessionContext.unbind()方法来关闭和解除绑定。