Hibernate Session & Transaction详解

HIbernate中的Session
Session是JAVA应用程序和Hibernate进行交互时使用的主要接口,它也是持久化操作核心API,
注意这里的Session的含义,它与传统意思上web层的HttpSession并没有关系,Hibernate Session之与Hibernate,相当于JDBC Connection相对与JDBC。
Session对象是有生命周期的,它以Transaction对象的事务开始和结束边界
Session作为贯穿Hibernate的持久化管理器核心,提供了众多的持久化的方法,如save(), update ,delete ,find(Hibernate 3中已经取消了此方法)等,通过这些方法我们可以透明的完成对象的增删改查(CRUD– create read update delete),这里所谓的透明是指,Session在读取,创建和删除影射的实体对象的实例时,这一系列的操作将被转换为对数据库表中数据的增加,修改,查询和删除操作。

SessionFactory负责创建Session,SessionFactory是线程安全的,多个并发线程可以同时访问一个SessionFactory 并从中获取Session实例。而Session并非线程安全,也就是说,如果多个线程同时使用一个Session实例进行数据存取,则将会导致Session 数据存取逻辑混乱.因此创建的Session实例必须在本地存取空上运行,使之总与当前的线程相关。

Session有以下的特点
1,不是线程安全的,应该避免多个线程共享同一个Session实例
2,Session实例是轻量级的,所谓轻量级:是指他的创建和删除不需要消耗太多资源
3,Session对象内部有一个缓存,被称为Hibernate第一缓存,他存放被当前工作单元中加载的对象,每个Session实例都有自己的缓存。

Hibernate Session缓存被称为Hibernate的第一级缓存。SessionFactory的外置缓存称为Hibernate的二级缓存。这两个缓存都位于持久层,它们存放的都是数据库数据的拷贝。SessionFactory的内置缓存 存放元数据和预定义SQL, SessionFactory的内置缓存是只读缓存。

Hibernate Session缓存的三大作用:
1,减少数据库的访问频率,提高访问性能。
2,保证缓存中的对象与数据库同步,位于缓存中的对象称为持久化对象。
3,当持久化对象之间存在关联时,Session 保证不出现对象图的死锁。
Session 如何判断持久化对象的状态的改变呢?
Session 加载对象后会为对象值类型的属性复制一份快照。当Session 清理缓存时,比较当前对象和它的快照就可以知道那些属性发生了变化。

Session 什么时候清理缓存?
1,commit()方法被调用时
2,查询时会清理缓存,保证查询结果能反映对象的最新状态。
3,显示的调用session 的 flush方法。
session 清理缓存的特例:
当对象使用 native 生成器 时 会立刻清理缓存向数据库中插入记录。

org.hibernate Interface Session
public interface Session extends Serializable : 是一个Java application 和Hibernate之间主要的运行时接口,这是执行持久化服务的中心API
主要方法:
public Transaction beginTransaction() throws HibernateException【1】:返回和当前Session对象相互联系的Transaction对象(表示在数据库中重新开始一个事务)
public Transaction getTransaction(): 返回和当前session联系的Transaction对象
public Connection connection close() throws HibernateExcepton:结束当前的Session对象
public void clear() :清空Session,清除所有保存在当前Session缓存中的实体对象,终止所有正在执行的方法(eg: save() , update() ,delete() …..)
public Serializable save(Object object)throws HibernateException 对当前参数指定的对象进行持久化(系统会首先赋予参数对象一个标识符OID),他相当于insert语句 后面在详细介绍
public Connection connection() throws HibernateException 得到当前Session 中包含的Connection对象。
public boolean contains(Object object):判断参数给出的对象(持久化类)是否在当前Session的缓存中
public void evict(Object object) throws HibernateException :将参数给出的Object从当前Session对象类中删除,使这个对象从持久态变成游离态,这种状态的改变不会引起对数据库的同步,后面详细介绍
public Object load(Class theclass ,Serializable id) throws HibernateException 返回第一个参数指定类对应的表中,第二个参数指定的行(第二个参数就是要取得对象的OID,他对应表中主键列的值)
public void update(Object object) throws HibernateException :更新一个对象到数据库中,后面在详细介绍
public void delete (Object object)throws HibernateException:从数据库中删除和参数指定的对象对应的记录
public Object get(Class class,Serializable id) throws HibernateException:和load()方法一样区别在于,如果数据库表中没有对应的记录,get()方法返回null,load()方法将报异常
Transaction
Transanction接口是Hibernate的数据库事务接口,用于管理事务,他对底层的事务作出了封装,用户可以使用Transanction对象定义自己的对数据库的原子操作,底层事务包括:JDBC API ,JTA(Java Transaction API)。。。。。
一个Transaction对象的事务可能会包括多个对数据库进行的操作
org.hibernate Interface Transaction
public interface Transaction
常用方法:
public void commit() throws HibernateException 刷新当前的Session以及结束事务的工作,这个方法将迫使数据库对当前的事务进行提交
public void rollback() throws HibernateException :强迫回滚当前事务
public boolean isActive() throws HibernateException: 这个事务是否存活
—————————————————————————————-

Session:当中包含一个Connection对象
Connection c =session.getConnection();
Session的缓存用于临时保存持久化的对象,等到一定时候,再将缓存中的对象保存到数据库中。
应用程序事务:如果一个Session中包含有多个Transaction(数据库事务),这些Transaction的集合称为应用程序事务
标准使用形式:

 Configuration config=new Configuration().configure(“hibernate.cfg.xml”);
SessionFactory sessionfactory=config.buildSessionFactory();
Session session=sessionfactory.openSession();
Transaction tx=session.beginTransaction();
try
{
session.save();
tx.commit();
}
catch(Exception e)
{
if(tx!=null) tx.rollback();
}
finally
{
session.close ();
}

保证session的线程安全

ThreadLocal,在很多种Session 管理方案中都用到了它.ThreadLocal 是Java中一种较为特殊的线程绑定机制,通过ThreadLocal存取的数据,总是与当前线程相关,也就是说,JVM 为每个运行的线程,绑定了私有的本地实例存取空间,从而为多线程环境常出现的并发访问问题提供了一种隔离机制,ThreadLocal并不是线程本地化的实现,而是线程局部变量。

也就是说每个使用该变量的线程都必须为该变量提供一个副本,每个线程改变该变量的值仅仅是改变该副本的值,而不会影响其他线程的该变量的值,ThreadLocal是隔离多个线程的数据共享,不存在多个线程之间共享资源,因此不再需要对线程同步。
请看一下代码:

public class HibernateUtil {

public static final SessionFactory sessionFactory;
public static final ThreadLocal session = new ThreadLocal();
static{
try{
Configuration configuration=new Configuration().configure();
sessionFactory = configuration.buildSessionFactory();
}catch (Throwable ex){
System.err.println(“Initial SessionFactory creation failed.” + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static Session currentSession() throws HibernateException{
Session s = (Session) session.get();
if (s == null)
{
s = sessionFactory.openSession();
session.set(s);
}
return s;
}

public static void closeSession() throws HibernateException {
Session s = (Session) session.get();
if (s != null)
s.close();
session.set(null);
}
}

不安全解释,例如:Servlet 运行是多线程的,而应用服务器并不会为每个线程都创建一个Servlet实例,也就是说,TestServlet在应用服务器中只有一个实例(在Tomcat中是这样,其他的应用服务器可能有不同的实现),而这个实例会被许多个线程并发调用,doGet 方法也将被不同的线程反复调用,可想而知,每次调用doGet 方法,这个唯一的TestServlet 实例的session 变量都会被重置

在代码中,只要借助上面这个工具类获取Session 实例,我们就可以实现线程范围内的Session 共享,从而避免了在线程中频繁的创建和销毁Session 实例。不过注意在线程结束时关闭Session。同时值得一提的是,新版本的Hibernate在处理Session的时候已经内置了延迟加载机制,只有在真正发生数据库操作的时候,才会从数据库连接池获取数据库连接,我们不必过于担心Session的共享会导致整个线程生命周期内数据库连接被持续占用。

对于Web程序
而言,我们可以借助Servlet2.3规范中新引入的Filter机制,轻松实现线程生命周期内的Session管理(关于Filter的具体描述,请参考Servlet2.3规范)。Filter的生命周期贯穿了其所覆盖的Servlet(JSP也可以看作是一种特殊的Servlet)
及其底层对象。Filter在Servlet被调用之前执行,在Servlet调用结束之后结束。因此,在Filter 中管理Session 对于Web 程序而言就显得水到渠成。下面是一个通过Filter 进行Session管理的典型案例:

public class PersistenceFilter implements Filter
{
protected static ThreadLocal hibernateHolder = new ThreadLocal();
public void doFilter(ServletRequest request, ServletResponse
response, FilterChain chain)
throws IOException, ServletException
{
hibernateHolder.set(getSession());
try
{
……
chain.doFilter(request, response);
……
}
finally
{
Session sess = (Session)hibernateHolder.get();
if (sess != null)
{
hibernateHolder.set(null);
try
{
sess.close();
}
catch (HibernateException ex) {
throw new ServletException(ex);
}
}
}
}
……
Hibernate Developer’s Guide Version 1.0
September 2, 2004 So many open source projects. Why not Open your Documents?
}

通过在doFilter中获取和关闭Session,并在周期内运行的所有对象(Filter链中其余的Filter,及其覆盖的Servlet 和其他对象)对此Session 实例进行重用,保证了一个Http Request处理过程中只占用一个Session,提高了整体性能表现。在实际设计中,Session的重用做到线程级别一般已经足够,企图通过HttpSession实现用户级的Session重用反而可能导致其他的问题。凡事不能过火,Session重用也一样。

Hibernate中的Transaction

Hibernate是对JDBC的轻量级对象封装,Hibernate本身是不具备Transaction处理功能的,Hibernate的Transaction实际上是底层的JDBC Transaction的封装,或者是JTA Transaction的封装,下面我们详细的分析:

Hibernate可以配置为JDBCTransaction或者是JTATransaction,这取决于你在hibernate.properties中的配置:

引用
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory
如果你什么都不配置,默认情况下使用JDBCTransaction,不管你准备让Hibernate使用JDBCTransaction,还是JTATransaction,我的忠告就是什么都不配,将让它保持默认状态,如下:
在下面的分析中我会给出原因。

一、JDBC Transaction

看看使用JDBC Transaction的时候我们的代码例子:

Session session = sf.openSession();;
Transaction tx = session.beginTransactioin();;

session.flush();;
tx.commit();;
session.close();;

这是默认的情况,当你在代码中使用Hibernate的Transaction的时候实际上就是JDBCTransaction。那么JDBCTransaction究竟是什么东西呢?来看看源代码就清楚了:

Hibernate2.0.3源代码中的类

net.sf.hibernate.transaction.JDBCTransaction:
public void begin(); throws HibernateException {
log.debug(“begin”);;
try {
toggleAutoCommit = session.connection();.getAutoCommit();;
if (toggleAutoCommit); session.connection();.setAutoCommit(false);;
}
catch (SQLException e); {
log.error(“Begin failed”, e);;
throw new TransactionException(“Begin failed with SQL exception: “, e);;
}
begun = true;
}

这是启动Transaction的方法,看到 connection().setAutoCommit(false) 了吗?是不是很熟悉?

public void commit(); throws HibernateException {
if (!begun); throw new TransactionException(“Transaction not successfully started”);;
log.debug(“commit”);;
try {
if ( session.getFlushMode();!=FlushMode.NEVER ); session.flush();;
try {
session.connection();.commit();;
committed = true;
}
catch (SQLException e); {
log.error(“Commit failed”, e);;
throw new TransactionException(“Commit failed with SQL exception: “, e);;
}
}
finally {
session.afterTransactionCompletion();;
}
toggleAutoCommit();;
}

这是提交方法,看到connection().commit() 了吗?下面就不用我多说了,这个类代码非常简单易懂,通过阅读使我们明白Hibernate的Transaction都在干了些什么?我现在把用Hibernate写的例子翻译成JDBC,大家就一目了然了:

Connection conn = …; conn.setAutoCommit(false);; … conn.commit();; conn.setAutoCommit(true);;
conn.close();;

看明白了吧,Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中,Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写Transaction的话,数据库根本就没有反应。

二、JTATransaction

如果你在EJB中使用Hibernate,或者准备用JTA来管理跨Session的长事务,那么就需要使用JTATransaction,先看一个例子:

javax.transaction.UserTransaction tx = new InitialContext().lookup(“javax.transaction.UserTransaction”);
Session s1 = sf.openSession();

s1.flush();
s1.close();

Session s2 = sf.openSession();

s2.flush();
s2.close();
tx.commit();

这是标准的使用JTA的代码片断,Transaction是跨Session的,它的生命周期比Session要长。如果你在EJB中使用Hibernate,那么是最简单不过的了,你什么Transaction代码统统都不要写了,直接在EJB的部署描述符上配置某某方法是否使用事务就可以了。

现在我们来分析一下JTATransaction的源代码, net.sf.hibernate.transaction.JTATransaction:

public void begin(InitialContext context, …

ut = (UserTransaction); context.lookup(utName);;

看清楚了吗? 和我上面写的代码 tx = new InitialContext().lookup(“javax.transaction.UserTransaction”); 是不是完全一样?

public void commit(); …

if (newTransaction); ut.commit();;

JTATransaction的控制稍微复杂,不过仍然可以很清楚的看出来Hibernate是如何封装JTA的Transaction代码的。

但是你现在是否看到了什么问题? 仔细想一下,Hibernate Transaction是从Session中获得的,tx = session.beginTransaction(),最后要先提交tx,然后再session.close,这完全符合JDBC的Transaction的操作顺序,但是这个顺序是和JTA的Transactioin操作顺序彻底矛盾的!!! JTA是先启动Transaction,然后启动Session,关闭Session,最后提交Transaction,因此当你使用JTA的Transaction的时候,那么就千万不要使用Hibernate的Transaction,而是应该像我上面的JTA的代码片断那样使用才行。

总结:

1、在JDBC上使用Hibernate

必须写上Hibernate Transaction代码,否则数据库没有反应。此时Hibernate的Transaction就是Connection.commit而已

2、在JTA上使用Hibernate

写JTA的Transaction代码,不要写Hibernate的Transaction代码,否则程序会报错

3、在EJB上使用Hibernate

什么Transactioin代码都不要写,在EJB的部署描述符里面配置
Java代码
|—CMT(Container Managed Transaction);
|
|—BMT(Bean Managed Transaction);
|
|—-JDBC Transaction
|
|—-JTA Transaction

你说“Hibernate的JDBCTransaction根本就是conn.commit而已,根本毫无神秘可言,只不过在Hibernate中,Session打开的时候,就会自动conn.setAutoCommit(false),不像一般的JDBC,默认都是true,所以你最后不写commit也没有关系,由于Hibernate已经把AutoCommit给关掉了,所以用Hibernate的时候,你在程序中不写Transaction的话,数据库根本就没有反应”
但sf.opengSession()时,并没有setAutoCommit(false),我想问的是,如果不编写任何事务代码,如:
Java代码
Session s = sf.openSession();;
……
s.close();;
数据库会不会有反应(此时应该是默认AutoCommit为true)。

另外,我想问一下:
1. s.flush()是不是必须的
2. s.close()是不是一定要关闭
比如你上面提到的:

javax.transaction.UserTransaction tx = new InitialContext();.lookup(“javax.transaction.UserTransaction”);;
Session s1 = sf.openSession();;

s1.flush();;
s1.close();;
..
Session s2 = sf.openSession();;

s2.flush();;
s2.close();;
tx.commit();;

s1不关闭,使用s2进行操作的代码中使用s1可不可以(我觉得这样更加节约资源,不需要反复的连接、关闭)

引用
但sf.opengSession()时,并没有setAutoCommit(false),我想问的是,如果不编写任何事务代码,如:
Session s = sf.openSession();
……
s.close();
数据库会不会有反应(此时应该是默认AutoCommit为true)。
不会有反应。在sf.openSession() 创建Session实例的时候,就已经调用了conn.setAutoCommit(false)了。
引用
另外,我想问一下:
1. s.flush()是不是必须的
2. s.close()是不是一定要关闭
s.flush不是必须的,s.close()会调用一次s.flush()

s.close()正常情况下应该关闭,除非你是用ThreadLocal管理Session。
引用
s1不关闭,使用s2进行操作的代码中使用s1可不可以(我觉得这样更加节约资源,不需要反复的连接、关闭)
在这个例子中看不出来JTA的作用。
假设

Class A {
find(); {
Session s1 = sf.openSession();;

s1.flush();;
s1.close();;
}
}

Class B {
find(); {
Session s2 = sf.openSession();;

s2.flush();;
s2.close();;
}
}

Main {

tx = …;
A.find();;
B.find();;
tx.commit();;
}

看明白了吗?JTA的Transaction管理是跨类调用的。

HACKED BY SudoX — HACK A NICE DAY.

发表评论

电子邮件地址不会被公开。 必填项已用*标注