Hibernate事务管理机制剖析-hibernate事务管理

在向大家详细介绍Hibernate事务管理机制之前，首先让大家了解下JTA事务管理，然后全面介绍Hibernate事务管理机制。

JTA 提供了跨Session 的事务管理能力。这一点是与JDBC Transaction ***的差异。JDBC 事务由Connnection管理，也就是说，事务管理实际上是在JDBC Connection中实现。事务周期限于Connection的生命周期之类。同样，对于基于JDBC Transaction的Hibernate事务管理机制而言，事务管理在Session 所依托的JDBC Connection中实现，事务周期限于Session的生命周期。

JTA事务管理则由 JTA 容器实现，JTA 容器对当前加入事务的众多Connection 进行调度，实现其事务性要求。JTA的事务周期可横跨多个JDBC Connection生命周期。同样对于基于JTA事务的Hibernate而言，JTA事务横跨可横跨多个Session。JTA 事务是由JTA Container 维护，而参与事务的Connection无需对事务管理进行干涉。这也就是说，如果采用JTA Transaction，我们不应该再调用HibernateTransaction功能。

上面基于JDBC Transaction的正确代码，这里就会产生问题：

public class ClassA{  
public void saveUser(User user){  
session = sessionFactory.openSession();  
Transaction tx = session.beginTransaction();  
session.save(user);  
tx.commit();  
session.close();  
}  
}  
public class ClassB{  
public void saveOrder(Order order){  
session = sessionFactory.openSession();  
Transaction tx = session.beginTransaction();  
session.save(order);  
tx.commit();  
session.close();  
}  
}  
public class ClassC{  
public void save(){  
……  
UserTransaction tx = new InitialContext().lookup(“……”);  
ClassA.save(user);  
ClassB.save(order);  
tx.commit();  
……  
}  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.

这里有两个类ClassA和ClassB，分别提供了两个方法：saveUsersaveOrder，用于保存用户信息和订单信息。在ClassC中，我们接连调用了ClassA.saveUser方法和ClassB.saveOrder 方法，同时引入了JTA 中的UserTransaction 以实现ClassC.save方法中的事务性。问题出现了，ClassA 和ClassB 中分别都调用了Hibernate 的Transaction 功能。在Hibernate 的JTA 封装中，Session.beginTransaction 同样也执行了InitialContext.lookup方法获取UserTransaction实例，Transaction.commit方法同样也调用了UserTransaction.commit方法。

实际上，这就形成了两个嵌套式的JTA Transaction：ClassC 申明了一个事务，而在ClassC 事务周期内，ClassA 和ClassB也企图申明自己的事务，这将导致运行期错误。因此，如果决定采用JTA Transaction，应避免再重复调用Hibernate 的Transaction功能，上面的代码修改如下：

public class ClassA{  
public void save(TUser user){  
session = sessionFactory.openSession();  
session.save(user);  
session.close();  
}  
……  
}  
public class ClassB{  
public void save (Order order){  
session = sessionFactory.openSession();  
session.save(order);  
session.close();  
}  
……  
}  
public class ClassC{  
public void save(){  
……  
UserTransaction tx = new InitialContext().lookup(“……”);  
classA.save(user);  
classB.save(order);  
tx.commit();  
……  
}  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.

上面代码中的ClassC.save方法，也可以改成这样：

public class ClassC{  
public void save(){  
……  
session = sessionFactory.openSession();  
Transaction tx = session.beginTransaction();  
classA.save(user);  
classB.save(order);  
tx.commit();  
……  
}  
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

实际上，这是利用Hibernate来完成启动和提交UserTransaction的功能，但这样的做法比原本直接通过InitialContext获取UserTransaction 的做法消耗了更多的资源，得不偿失。

在EJB 中使用JTA Transaction 无疑最为简便，我们只需要将save 方法配置为JTA事务支持即可，无需显式申明任何事务，下面是一个Session Bean的save方法，它的事务属性被申明为“Required”，EJB容器将自动维护此方法执行过程中的事务：

/**    
* @ejb.interface-method  
* view-type="remote"    
*    
* @ejb.transaction type = "Required"    
**/    
public void save(){     
//EJB环境中，通过部署配置即可实现事务申明，而无需显式调用事务     
classA.save(user);     
classB.save(log);     
}  
//方法结束时，如果没有异常发生，则事务由EJB容器自动提交。 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.

以上介绍Hibernate事务管理机制。

【编辑推荐】