理解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接口。这个接口只提供了一个方法：

Java代码



/**

* 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

Java代码



/**

* 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

Java代码



/**

* 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

Java代码



/**

* 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()方法来关闭和解除绑定。