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.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
将使用JTATransaction
不管你准备让Hibernate使用JDBCTransaction，还是JTATransaction，我的忠告就是什么都不配，将让它保持默认状态，如下：
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JTATransactionFactory
#hibernate.transaction.factory_class net.sf.hibernate.transaction.JDBCTransactionFactory
在下面的分析中我会给出原因。
一、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 {
...
if (toggleAutoCommit) session.connection().setAutoCommit(false);
...
}
这是启动Transaction的方法，看到 connection().setAutoCommit(false) 了吗？是不是很熟悉？
再来看
public void commit() throws HibernateException {
...
try {
if ( session.getFlushMode()!=FlushMode.NEVER ) session.flush();
try {
session.connection().commit();
committed = true;
}
...
toggleAutoCommit();
}
这是提交方法，看到connection().commit() 了吗？下面就不用我多说了，这个类代码非常简单易懂，通过阅读使我们明白Hibernate的Transaction都在干了些什么？我现在把用 Hibernate写的例子翻译成JDBC，大家就一目了然了：
Connection conn = ...; <--- session = sf.openSession();
conn.setAutoCommit(false); <--- tx = session.beginTransactioin();
... <--- ...
conn.commit(); <--- tx.commit(); (对应左边的两句)
conn.setAutoCommit(true);
conn.close(); <--- session.close();
看明白了吧，Hibernate的JDBCTransaction根本就是conn.commit而已，根本毫无神秘可言，只不过在Hibernate 中，Session打开的时候，就会自动conn.setAutoCommit(false)，不像一般的JDBC，默认都是true，所以你最后不写 commit也没有关系，由于Hibernate已经把AutoCommit给关掉了，所以用Hibernate的时候，你在程序中不写 Transaction的话，数据库根本就没有反应。
如果你在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 Initial Context?().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的部署描述符里面配置
|---CMT(Container Managed Transaction)
|
|---BMT(Bean Managed Transaction)
|
|----JDBC Transaction
|
|----JTA Transaction
--------------------------------------------------------------------------------
提问：
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();
} （全文完）
数据库事务必须具备ACID特征,ACID是Atomic(原子性),Consistency(一致性),Isolation(隔离性),和Durability(持久性).
Atomic(原子性):指整个数据库事务是不可分割的工作单元,只有事务中所有的操作执行成功,才算整个事务成功.
Consistency(一致性):指数据库事务不能破换关系数据的完整性以及业务逻辑上的一致性(比如说银行转帐事务,不管事务成功还是
失败,应该保证事务结束后的存款总额为原来的.)
Isolation(隔离性):指在并发环境中,当不同的事务同时操纵相同的数据时,每个事务都有各自的完整数据空间.
Durability(持久性):指的是只要事务成功工结束,它对数据库所做的更新就必须永久保存下来,即使发生系统崩溃,从新启动数据库系统后,数据库还能恢复到事务成功结束时候的状态.
数据库管理系统采用日志来保证事务的原子性,一致性和持久性,日志记录了事务对数据库所做的更新,如果某个事务在执行过程中发生错误,就可以根据日志,撤消事务对数据库已做的更新,使数据库退回到执行事务前的初始状态.
数据库管理系统采用锁机制来实现事务的隔离性,当多个事务同时更新数据库中的相同的数据时,只允许只有锁的事务能更新该数据,其他事务必须等待,直到前一个事务释放了锁,其他事务才有机会更新该数据。
(POJOs IN ACTION中文版)
隔离的（isolated）数据库事务
有时，你可以直接依赖数据库本身处理共享数据的并发访问。可以将数据库配置成执行相互隔离（isolated，用数据库的行话来讲）的数据库事务。如果你还不熟悉这一概念，请别担心，第12章里会进行详细说明。眼下最关键的是要记住，如果应用程序使用完全隔离的事务，那么同时执行两个事务的效果将与一个接一个执行这两个事务完全等效。
从表面上看，这种方法看似非常简单，但这类事务也存在问题，由于隔离事务如何实现完全由数据库决定，因此有时它们会导致性能降低，令人无法接受。鉴于此，许多应用程序都避免使用这类事务，转而采用所谓的乐观（optimistic）或者悲观（pessimistic）锁，稍后将作描述。
乐观锁
处理并发更新的一种方式是使用乐观锁（optimistic locking）。乐观锁的工作原理是让应用程序检查它即将更新的数据是否已被另一个事务修改（自该数据上次读取以来）。实现乐观锁的一种常见做法是在每个表里添加一个版本字段，每次应用程序更新数据表记录时就增加这个版本字段。每个UPDATE语句中的WHERE子句会根据上次读取的值来判断这个版本号是否改变。通过查看PreparedStatement.executeUpdate()返回的记录数，应用程序可以判断UPDATE语句是否成功。如果这条记录已被另一个事务更新或删除，应用程序可以回滚这个事务，并重新开始。
在直接执行SQL语句的应用程序中，乐观锁机制的实现非常容易。不过，使用诸如JDO和Hibernate的持久层构架时，实现更为容易，因为它们已将乐观锁作为配置选项提供。一旦启用该配置选项，持久层框架会自动生成SQL UPDATE语句，执行版本检查。第12章将分析乐观锁的使用时机及其缺点，并向你展示怎样在iBATIS、JDO和Hibernate中使用乐观锁。
乐观锁的名称源自如下假定情况，即并发更新的几率极小，此外应用程序并不阻止并发更新，而是检测并发更新，并从并发更新中恢复过来。另一种方式是使用悲观锁（pessimistic locking），它假定并发更新将会发生，因此必须预先阻止。
悲观锁
不同于乐观锁的另一种方式是使用悲观锁。当读取某些记录时，事务先锁住这些记录，这样可以防止其他事务访问这些数据记录。具体细节要视数据库而定，不过糟糕的是，并非所有数据库都支持悲观锁。如果数据库支持悲观锁，在直接执行SQL语句的应用程序中，实现悲观锁非常容易。然而，正如你所预料的，在JDO或Hibernate应用程序中使用悲观锁更为容易。JDO以配置选项的方式提供悲观锁，而Hibernate则提供一个简单实用的API，来锁定对象。同样，在第12章，你将学习何时使用悲观锁，分析其缺点，并看看怎样在iBATIS、JDO和Hibernate中使用悲观锁。
除了处理单个数据库事务里的并发，通常你还必须处理跨一系列数据库事务的并发