源码解析：Hibernate 事务 设计 （版本 3.1.3）

Hibernate是一个ORM工具，即实现对象到关系型数据库的映射，使用者不需要关系SQ，只要通过曹组对象就可以实现数据的增删改查，简单了解Hibernate的使用：

要使用Hibernate，一个非常重要的入口组件就是 SessionFactory ，他是不可变的，即一旦设置完毕就不能改变，一个应用只需要有一个SessionFactory 实例就够了，他的作用就是产生与数据库交互的会话对象Session，SessionFactory存储了所有配置Session需要的信息，如数据库连接属性、表与类对应关系、事务属性等，一个典型的创建代码如下：

主配置文件：

<!DOCTYPE hibernate-configuration PUBLIC        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"><hibernate-configuration>    <session-factory>        <property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>        <property name="hibernate.connection.url">jdbc:oracle:thin:@168.1.50.20:1522:orcl</property>        <property name="hibernate.connection.username">scott</property>        <property name="hibernate.connection.password">scott</property>        <property name="hibernate.show_sql">true</property>        <!-- 方言：为每一种数据库提供适配器，方便转换 -->        <!--<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JDBCTransactionFactory</property>-->        <property name="hibernate.transaction.factory_class">org.hibernate.transaction.JTATransactionFactory</property>        <property name="jta.UserTransaction">UserTransaction</property>        <property name="hibernate.connection.datasource">DataSource1</property>        <property name="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</property>        <mapping resource="User.hbm.xml"/>    </session-factory></hibernate-configuration>

SessionFactory创建方式：

Configuration cfg = new Configuration();        SessionFactory sf = cfg.configure("/hibernate.cfg.xml").buildSessionFactory();

这段代码就通过hibernate的工具类解析hibernate.cfg.xml配置文件，构造出一个SessionFactory示例（PS：该实例只需要初始化一次就够了，可以缓存起来多次使用，但请注意线程安全性），一个典型的使用hibernate保存对象的代码如下：

Configuration cfg = new Configuration();        SessionFactory sf = cfg.configure("/hibernate.cfg.xml").buildSessionFactory();        Session session = sf.openSession();        session.beginTransaction();        session.save(s);        session.getTransaction().commit();        session.close();        sf.close();

public class User {    private String id;    private String name;    public String getName() {        return name;    }    public String getId() {        return id;    }    public void setId(String id) {        this.id = id;    }    public void setName(String name) {        this.name = name;    }}

hibernate之所以知道 对象 到 数据库表及字段的对应关系，是因为这个配置文件（PS：新版本的hibernate已经支持注解，即直接将对应关系标记到类上，就可以不需要此文件了）：

<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.test.hibernate">    <class name="User" table="STUDENT">        <id name="id">            <generator class="uuid"/>        </id>        <property name="name"/>    </class></hibernate-mapping>

好了，hibernate是如此简单就让我们拜托了数据库SQL的苦恼，但你如果以为hibernate就这点能耐就该好好补补了，hibernate有很多集成、缓存、优化等方面的设计，现在我们只介绍下最重要也是我们最关系的：事务，上面的java代码我们通过 org.hibernate.Session#beginTransaction() 获取到了一个事务，然后调用事务的 开始和结束（提交或回滚）方法就完成了事务操作，beginTransaction都作了什么事情，看下源码：

public Transaction beginTransaction() throws HibernateException {errorIfClosed();if ( rootSession != null ) {// todo : should seriously consider not allowing a txn to begin from a child session//      can always route the request to the root session...log.warn( "Transaction started on non-root session" );}Transaction result = getTransaction();result.begin();return result;}

public Transaction getTransaction() throws HibernateException {errorIfClosed();return jdbcContext.getTransaction();}

他从 JDBCContext 中获取事务对象，这里使用了 中介 模式，JDBCContext就是一个在持久化模型和数据源模型之间的中介，以使他们可以相互作用，

hibernate通过JDBCContext这种中介模式将事务相关的复杂交互与本身的持久化模型分离开了，提供了可维护性，JDBCContext获取事务的方式：

public Transaction getTransaction() throws HibernateException {if (hibernateTransaction==null) {hibernateTransaction = owner.getFactory().getSettings().getTransactionFactory().createTransaction( this, owner );}return hibernateTransaction;}

可以看到他通过获取一个事务工厂，然后从事务工厂中创建一个事务，该事务工厂是在最开始初始化SessionFactory的时候从配置文件中解析的来的，他有三种类型：

JDBCTransactionFactory：JDBCTransactionFactory是JDBC事务的工厂，他可产生的事务类型是JDBCTransaction

JTATransactionFactory：JTATransactionFactory是JTA事务的工厂，他可产生的事务类型是JTATransaction

CMTTransactionFactory：CMTTransactionFactory是容器管理的事务的工厂，他可产生的事务类型是CMTTransaction

好了，这样hibernate就拿到了事务对象，三种类型的事务都实现了统一的接口：org.hibernate.Transaction，他定义了事务的开始、提交、回滚接口，不同的事务的实现方式都是不同的，

JDBCTransaction

他的开始事务的逻辑：

public void begin() throws HibernateException {if (begun) {return;}if (commitFailed) {throw new TransactionException("cannot re-start transaction after failed commit");}log.debug("begin");try {toggleAutoCommit = jdbcContext.connection().getAutoCommit();if ( log.isDebugEnabled() ) {log.debug("current autocommit status: " + toggleAutoCommit);}if (toggleAutoCommit) {log.debug("disabling autocommit");jdbcContext.connection().setAutoCommit(false);}}catch (SQLException e) {log.error("JDBC begin failed", e);throw new TransactionException("JDBC begin failed: ", e);}callback = jdbcContext.registerCallbackIfNecessary();begun = true;committed = false;rolledBack = false;if ( timeout>0 ) {jdbcContext.getConnectionManager().getBatcher().setTransactionTimeout(timeout);}jdbcContext.afterTransactionBegin(this);}

可以看到，他的主要工作就是将当前的Connection设置为 false，这也是我们使用普通jdbc事务的做法，hibernate默认的事务类型就是此类型的，同时也看到他在事务开始逻辑中调用JDBCContext这个中介，以和事务相关逻辑进行交互，好了，那么我们也很容易想到JDBCTransaction的commit和rollback也主要是对jdbc Connection对象的提交和回滚了，看下：

public void commit() throws HibernateException {if (!begun) {throw new TransactionException("Transaction not successfully started");}log.debug("commit");if ( !transactionContext.isFlushModeNever() && callback ) {transactionContext.managedFlush(); //if an exception occurs during flush, user must call rollback()}beforeTransactionCompletion();if ( callback ) {jdbcContext.beforeTransactionCompletion( this );}try {commitAndResetAutoCommit();log.debug("committed JDBC Connection");committed = true;if ( callback ) {jdbcContext.afterTransactionCompletion( true, this );}afterTransactionCompletion( Status.STATUS_COMMITTED );}catch (SQLException e) {log.error("JDBC commit failed", e);commitFailed = true;if ( callback ) {jdbcContext.afterTransactionCompletion( false, this );}afterTransactionCompletion( Status.STATUS_UNKNOWN );throw new TransactionException("JDBC commit failed", e);}finally {closeIfRequired();}}private void commitAndResetAutoCommit() throws SQLException {try {jdbcContext.connection().commit();}finally {toggleAutoCommit();}}

public void rollback() throws HibernateException {if (!begun && !commitFailed) {throw new TransactionException("Transaction not successfully started");}log.debug("rollback");if (!commitFailed) {/*beforeTransactionCompletion();if ( callback ) {jdbcContext.beforeTransactionCompletion( this );}*/try {rollbackAndResetAutoCommit();log.debug("rolled back JDBC Connection");rolledBack = true;afterTransactionCompletion(Status.STATUS_ROLLEDBACK);}catch (SQLException e) {log.error("JDBC rollback failed", e);afterTransactionCompletion(Status.STATUS_UNKNOWN);throw new TransactionException("JDBC rollback failed", e);}finally {if ( callback ) {jdbcContext.afterTransactionCompletion( false, this );}closeIfRequired();}}}private void rollbackAndResetAutoCommit() throws SQLException {try {jdbcContext.connection().rollback();}finally {toggleAutoCommit();}}

代码中的 toggleAutoCommit 是要将之前强制设置为 autocommit为false的连接重置到初始状态。

再来看下JTATransaction，要使用JTA事务，是需要通过hibernate配置文件设置JTA事务的JNDI的，因为他需要一个JTA的事务管理器（或事务管理句柄），这是他的构造方法：

try {ut = (UserTransaction) context.lookup(utName);}catch (NamingException ne) {log.error("Could not find UserTransaction in JNDI", ne);throw new TransactionException("Could not find UserTransaction in JNDI: ", ne);}

JTA的用法就不多说了，hibernate对JTA事务的支持是通过从JNDI中获取JTA事务管理器来实现，他的工作可轻松多了，通过操作JTA提供的接口 UserTransaction 接口，轻松搞定，如对事务开始、提交、回滚分别调用的方法是：ut.begin(); ut.commit(); ut.rollback();，具体代码就不贴出来了。

PS：当使用hibernate的jta事务时，必需配合一个支持XA的数据源，因为hibernate只是调用了jta事务的开始、提交、回滚，并没有进行任何xa相关的操作，像XAResource的start和end这种xa的接口调用，hibernate并没有进行而是委托给了hibernate的ConnectionProvider来做的，如果hibernate的ConnectionProvider使用的是普通的jdbc的话是不会进行xa相关操作的，所以可以通过设置hibernate的ConnectionProvider为容器提供的数据源，完整设置如下：

<property name="hibernate.transaction.factory_class">org.hibernate.transaction.JTATransactionFactory</property>        <property name="jta.UserTransaction">UserTransaction</property>        <property name="hibernate.connection.datasource">DataSource1</property>

这样，hibernate就会通过jndi的UserTransaction查找到一个JTA事务，然后通过数据源DataSource1查找使用容器的数据源，这样数据源和事务管理就会相互配合完成分布式事务，一个简单原理就是，容器的数据源在进行数据库操作之前会检查当前线程（jta规范）是否具有事务，如果有事务则创建出一个XAResource出来，然后调用jta规范将本次数据库操作加入到事务中：javax.transaction.Transaction#enlistResource，就是这个方法，这就是数据源和事务管理器配合的原理。

最后的是 CMTTransaction ，他是容器管理事务的抽象，既然是容器管理事务的抽象，真正的工作就交给容器了，自己也不需要做什么的，开始、提交、回滚更简单了：

什么都不做，只是通过中介对象 transactionContext 相互作用一些事务时间回调而已，具体代码就不贴了。