源码解析：Hibernate 事务设计（版本 3.1.3）_throw new transactionexception-优快云博客

本文链接：https://blog.youkuaiyun.com/conquer0715/article/details/50974427

本文介绍了Hibernate ORM框架的基本概念，包括SessionFactory的创建与使用，以及如何通过配置文件建立对象与数据库表之间的映射关系。此外，还深入探讨了Hibernate中事务管理的实现机制，包括JDBC事务、JTA事务及容器管理事务的不同实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 相互作用一些事务时间回调而已，具体代码就不贴了。