《Spring技术内幕》学习笔记16——Spring具体事务处理器的实现

原文链接http://blog.csdn.net/chjttony/article/details/6538452

1.Spring的事务处理中，通用的事务处理流程框架是由抽象事务管理器AbstractPlatformTransactionManager来提供的，而具体的底层事务处理实现，由PlatformTransactionManager的具体实现类来实现，如DataSourceTransactionManager 、JtaTransactionManager和 HibernateTransactionManager等。我们以Spring中最常用的DataSourceTransactionManager和 HibernateTransactionManager为例，来分析具体事务处理器的底层实现事务创建、提交和回滚的处理操作。
2.AbstractPlatformTransactionManager抽象事物处理器：
上一篇博客中，我们已经分析了抽象事物管理器AbstractPlatformTransactionManager的源码，了解它实现了PlatformTransactionManager平台事务管理器接口，提供了一系列设计好的事务模板方法，如事务提交、回滚等，这些模板方法的具体实现由具体的事务处理器来提供。
3.DataSourceTransactionManager事务处理器的实现：
DataSourceTransactionManager数据源事务处理器是针对JDBC连接提供的事务处理器实现，即数据源事务处理器把数据库Connection连接和当前线程进行绑定，通过直接调用数据库连接Connection的提交和回滚方法实现事务的提供和回滚处理。其源码如下：

[java] view plain copy

public class DataSourceTransactionManager extends AbstractPlatformTransactionManager  
        implements ResourceTransactionManager, InitializingBean {  
    //注入数据源  
    private DataSource dataSource;  
//数据源事务处理器默认构造方法，创建一个数据源事务处理器实例，并设置允许嵌套事务  
    public DataSourceTransactionManager() {  
        setNestedTransactionAllowed(true);  
    }  
    //根据给定数据源，创建一个数据源事务处理器实例  
    public DataSourceTransactionManager(DataSource dataSource) {  
        this();  
        setDataSource(dataSource);  
        afterPropertiesSet();  
    }  
    //设置数据源  
    public void setDataSource(DataSource dataSource) {  
        if (dataSource instanceof TransactionAwareDataSourceProxy) {  
            //如果数据源是一个事务包装数据源代理，则获取事务包装代理的目标数据源   
            this.dataSource = ((TransactionAwareDataSourceProxy) dataSource).getTargetDataSource();  
        }  
        else {  
            this.dataSource = dataSource;  
        }  
    }  
    //获取数据源  
    public DataSource getDataSource() {  
        return this.dataSource;  
    }  
    //数据源事务处理器对象构造方法的回调函数  
    public void afterPropertiesSet() {  
        if (getDataSource() == null) {  
            throw new IllegalArgumentException("Property 'dataSource' is required");  
        }  
    }  
public Object getResourceFactory() {  
        return getDataSource();  
    }  
//创建事务，对数据库而言，是由Connection来完成事务工作的。该方法把数据库的//Connection对象放到一个ConnectionHolder对象中，然后封装到一个  
//DataSourceTransactionObject对象中  
    protected Object doGetTransaction() {  
        //创建数据源事务对象  
        DataSourceTransactionObject txObject = new DataSourceTransactionObject();  
        //设置数据源事务对象对嵌套事务使用保存点  
        txObject.setSavepointAllowed(isNestedTransactionAllowed());  
        //从事务管理容器中获取存放数据库Connection的对象  
        ConnectionHolder conHolder =  
            (ConnectionHolder) TransactionSynchronizationManager.getResource(this.dataSource);  
        txObject.setConnectionHolder(conHolder, false);  
        return txObject;  
    }  
    //判断是否已经存在事务  
    protected boolean isExistingTransaction(Object transaction) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
    //根据存放数据库连接的ConnectionHolder的isTransactionActive属性来判断  
        return (txObject.getConnectionHolder() != null && txObject.getConnectionHolder().isTransactionActive());  
    }  
    //处理事务开始的方法  
    protected void doBegin(Object transaction, TransactionDefinition definition) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        Connection con = null;  
        try {  
            //如果数据源事务对象的ConnectionHolder为null或者是事务同步的  
            if (txObject.getConnectionHolder() == null ||  
        txObject.getConnectionHolder().isSynchronizedWithTransaction()) {  
                //获取当前数据源的数据库连接  
                Connection newCon = this.dataSource.getConnection();  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");  
                }  
                //为数据源事务对象设置ConnectionHolder  
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);  
            }  
    //设置数据源事务对象的事务同步    txObject.getConnectionHolder().setSynchronizedWithTransaction(true);  
            //获取数据源事务对象的数据库连接  
            con = txObject.getConnectionHolder().getConnection();  
            //根据数据连接和事务属性，获取数据库连接的事务隔离级别  
            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);  
    //为数据源事务对象设置事务隔离级别  
    txObject.setPreviousIsolationLevel(previousIsolationLevel);  
            //如果数据库连接设置了自动事务提交属性，则关闭自动提交  
            if (con.getAutoCommit()) {  
                //保存数据库连接设置的自动连接到数据源事务对象中  
                txObject.setMustRestoreAutoCommit(true);  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Switching JDBC Connection [" + con + "] to manual commit");  
                }  
                //设置数据库连接自动事务提交属性为false，即禁止自动事务提交  
                con.setAutoCommit(false);  
            }  
            //激活当前数据源事务对象的事务配置  
            txObject.getConnectionHolder().setTransactionActive(true);  
            //获取事务配置的超时时长  
int timeout = determineTimeout(definition);  
//如果事务配置的超时时长不等于事务的默认超时时长  
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {  
        //数据源事务对象设置超时时长  
        txObject.getConnectionHolder().setTimeoutInSeconds(timeout);  
            }  
            //把当前数据库Connection和线程绑定  
            if (txObject.isNewConnectionHolder()) {  
        TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());  
            }  
        }  
        catch (Exception ex) {  
            DataSourceUtils.releaseConnection(con, this.dataSource);  
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);  
        }  
    }  
    //事务挂起  
    protected Object doSuspend(Object transaction) {  
        //获取事务对象  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        //将事务对象中的ConnectionHolders设置为null  
        txObject.setConnectionHolder(null);  
        ConnectionHolder conHolder = (ConnectionHolder)  
        //解除事务对象和当前线程的绑定    TransactionSynchronizationManager.unbindResource(this.dataSource);  
        return conHolder;  
    }  
    //事务恢复  
    protected void doResume(Object transaction, Object suspendedResources) {  
        //获取已暂停事务的ConnectionHolder  
        ConnectionHolder conHolder = (ConnectionHolder) suspendedResources;  
        //重新将事务对象和当前线程绑定  
        TransactionSynchronizationManager.bindResource(this.dataSource, conHolder);  
    }  
    //事务提交  
    protected void doCommit(DefaultTransactionStatus status) {  
        //获取事务对象  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();  
        //通过事务对象获取数据库连接  
        Connection con = txObject.getConnectionHolder().getConnection();  
        if (status.isDebug()) {  
            logger.debug("Committing JDBC transaction on Connection [" + con + "]");  
        }  
        try {  
            //使用数据库连接手动进行事务提交  
            con.commit();  
        }  
        catch (SQLException ex) {  
            throw new TransactionSystemException("Could not commit JDBC transaction", ex);  
        }  
    }  
    //事务回滚  
    protected void doRollback(DefaultTransactionStatus status) {  
        //获取事务对象  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();  
        //通过事务对象获取数据库连接  
        Connection con = txObject.getConnectionHolder().getConnection();  
        if (status.isDebug()) {  
            logger.debug("Rolling back JDBC transaction on Connection [" + con + "]");  
        }  
        try {  
            //通过调用数据库连接的回滚方法完成事务回滚操作  
            con.rollback();  
        }  
        catch (SQLException ex) {  
            throw new TransactionSystemException("Could not roll back JDBC transaction", ex);  
        }  
    }  
    //设置回滚  
    protected void doSetRollbackOnly(DefaultTransactionStatus status) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();  
        if (status.isDebug()) {  
            logger.debug("Setting JDBC transaction [" + txObject.getConnectionHolder().getConnection() +  
                    "] rollback-only");  
        }  
        txObject.setRollbackOnly();  
    }  
    //操作完成之后清除操作  
    protected void doCleanupAfterCompletion(Object transaction) {  
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;  
        //移除当前线程绑定的ConnectionHolder  
        if (txObject.isNewConnectionHolder()) {  
    TransactionSynchronizationManager.unbindResource(this.dataSource);  
        }  
        Connection con = txObject.getConnectionHolder().getConnection();  
        try {  
        //如果事务对象保存了自动事务提交属性，则设置数据库连接的自动事务提交属性  
            if (txObject.isMustRestoreAutoCommit()) {  
                con.setAutoCommit(true);  
            }  
            //事务结束后重置数据库连接  
            DataSourceUtils.resetConnectionAfterTransaction(con, txObject.getPreviousIsolationLevel());  
        }  
        catch (Throwable ex) {  
            logger.debug("Could not reset JDBC Connection after transaction", ex);  
        }  
        //如果事务对象中有新的ConnectionHolder   
        if (txObject.isNewConnectionHolder()) {  
            if (logger.isDebugEnabled()) {  
                logger.debug("Releasing JDBC Connection [" + con + "] after transaction");  
            }  
            //释放数据库连接  
            DataSourceUtils.releaseConnection(con, this.dataSource);  
        }  
        //清除事务对象的ConnectionHolder  
        txObject.getConnectionHolder().clear();  
    }  
//数据源事务对象，内部类  
    private static class DataSourceTransactionObject extends JdbcTransactionObjectSupport {  
        //是否有新的ConnectionHolder  
        private boolean newConnectionHolder;  
        //是否保存自动提交  
        private boolean mustRestoreAutoCommit;  
        //设置ConnectionHolder  
        public void setConnectionHolder(ConnectionHolder connectionHolder, boolean newConnectionHolder) {  
            //为父类JdbcTransactionObjectSupport设置ConnectionHolder  
            super.setConnectionHolder(connectionHolder);  
            this.newConnectionHolder = newConnectionHolder;  
        }  
        public boolean isNewConnectionHolder() {  
            return this.newConnectionHolder;  
        }  
        //调用父类JdbcTransactionObjectSupport的相关方法，查询收费存在事务  
        public boolean hasTransaction() {  
            return (getConnectionHolder() != null && getConnectionHolder().isTransactionActive());  
        }  
        //设置是否保存自动提交  
        public void setMustRestoreAutoCommit(boolean mustRestoreAutoCommit) {  
            this.mustRestoreAutoCommit = mustRestoreAutoCommit;  
        }  
        public boolean isMustRestoreAutoCommit() {  
            return this.mustRestoreAutoCommit;  
        }  
        //设置数据库连接在操作失败是，是否只回滚处理  
        public void setRollbackOnly() {  
            getConnectionHolder().setRollbackOnly();  
        }  
        public boolean isRollbackOnly() {  
            return getConnectionHolder().isRollbackOnly();  
        }  
    }  
}  

通过上述对数据源事务处理器的源码分析，我们看到，事务的提交、回滚等操作是通过直接调用数据库连接Connection的提交和回滚方法实现的，由于自动事务提交对应用程序性能影响很大，因此在进行事务提交时，我们首先禁止数据库连接的自动事务提交，事务提供操作通过手动实现。
4.HibernateTransactionManager事务处理器的实现：
相对于数据源的事务处理器来说，Hibernate的事务处理器相对要复杂一些，它是通过对Hibernate的会话Session的管理来完成事务处理实现的。Hibernate事务处理器的事务处理相关源码如下：

[java] view plain copy

public class HibernateTransactionManager extends AbstractPlatformTransactionManager  
        implements ResourceTransactionManager, BeanFactoryAware, InitializingBean {  
    ……  
    //获取Hibernate事务  
    protected Object doGetTransaction() {  
        //创建Hibernate事务对象  
        HibernateTransactionObject txObject = new HibernateTransactionObject();  
        //根据是否允许嵌套事务设置事务对象是否允许保存点  
        txObject.setSavepointAllowed(isNestedTransactionAllowed());  
        //从线程中获取SessionHolder,SessionHolder是在事务开始时与线程绑定的。  
        SessionHolder sessionHolder =  
                (SessionHolder) TransactionSynchronizationManager.getResource(getSessionFactory());  
        //如果获取到的SessionHolder不为null  
        if (sessionHolder != null) {  
            if (logger.isDebugEnabled()) {  
                logger.debug("Found thread-bound Session [" +  
                SessionFactoryUtils.toString(sessionHolder.getSession()) + "] for Hibernate transaction");  
            }  
            //把获取到的SessionHolder设置到Hibernate事务对象中  
            txObject.setSessionHolder(sessionHolder);  
        }  
        //如果当前Hibernate事务处理器有被管理的Hibernate Session  
        else if (this.hibernateManagedSession) {  
            try {  
                //获取当前的Hibernate Session  
                Session session = getSessionFactory().getCurrentSession();  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Found Hibernate-managed Session [" +  
                            SessionFactoryUtils.toString(session) + "] for Spring-managed transaction");  
                }  
                //设置Hibernate事务对象已经存在指定的Session  
                txObject.setExistingSession(session);  
            }  
            catch (HibernateException ex) {  
                throw new DataAccessResourceFailureException(  
                        "Could not obtain Hibernate-managed Session for Spring-managed transaction", ex);  
            }  
        }  
        //如果获取到的数据源不为null  
        if (getDataSource() != null) {  
            //将获取到的数据源和当前线程绑定  
            ConnectionHolder conHolder = (ConnectionHolder)  
    TransactionSynchronizationManager.getResource(getDataSource());  
            txObject.setConnectionHolder(conHolder);  
        }  
        return txObject;  
    }  
    //是否已存在事务  
    protected boolean isExistingTransaction(Object transaction) {  
        HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;  
//根据事务对象是否存在Spring管理的事务，或者通过判断是否存在Hibernate //Session或者事务对象中有被Hibernate管理的事务  
        return (txObject.hasSpringManagedTransaction() ||  
                (this.hibernateManagedSession && txObject.hasHibernateManagedTransaction()));  
    }  
    //处理事务开始  
    protected void doBegin(Object transaction, TransactionDefinition definition) {  
        //获取事务对象  
        HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;  
        //如果事务对象有ConnectionHolder，且事务对象的数据库连接不是事务同步的  
        if (txObject.hasConnectionHolder() && !txObject.getConnectionHolder().isSynchronizedWithTransaction()) {  
            throw new IllegalTransactionStateException(  
                    "Pre-bound JDBC Connection found! HibernateTransactionManager does not support " +  
                    "running within DataSourceTransactionManager if told to manage the DataSource itself. " +  
                    "It is recommended to use a single HibernateTransactionManager for all transactions " +  
                    "on a single DataSource, no matter whether Hibernate or JDBC access.");  
        }  
        Session session = null;  
        try {  
            //如果事务对象的SessionHolder为null，或者事务对象Hibernate  
            //Session是事务同步的  
            if (txObject.getSessionHolder() == null || txObject.getSessionHolder().isSynchronizedWithTransaction()) {  
                //获取Hibernate事务处理器中的实体拦截器  
                Interceptor entityInterceptor = getEntityInterceptor();  
                //获取Hibernate Session，如果实体拦截器不为null，则打开指定  
//实体拦截器的Session，如果实体拦截器为null，则打开新Session  
                Session newSession = (entityInterceptor != null ?  
                    getSessionFactory().openSession(entityInterceptor) : getSessionFactory().openSession());  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Opened new Session [" + SessionFactoryUtils.toString(newSession) +  
                            "] for Hibernate transaction");  
                }  
                //将获取的Hibernate Session设置到事务对象中  
                txObject.setSession(newSession);  
            }  
//如果Hibernate事务处理器中的SessionHolder不为null，则  
//获取SessionHolder中已有的Hibernate Session  
            session = txObject.getSessionHolder().getSession();  
            //允许为JDBC连接改变事务设置  
            if (this.prepareConnection && isSameConnectionForEntireSession(session)) {  
                if (logger.isDebugEnabled()) {  
                    logger.debug(  
                            "Preparing JDBC Connection of Hibernate Session [" + SessionFactoryUtils.toString(session) + "]");  
                }  
                //获取Session连接  
                Connection con = session.connection();  
                //获取事务的隔离级别  
                Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);  
            //设置事务对象的事务隔离级别 txObject.setPreviousIsolationLevel(previousIsolationLevel);  
            }  
            //不允许为JDBC连接改成事务设置  
            else {  
                //如果事务隔离级别不是默认事务隔离级别  
                if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {  
                    throw new InvalidIsolationLevelException(  
                            "HibernateTransactionManager is not allowed to support custom isolation levels: " +  
                            "make sure that its 'prepareConnection' flag is on (the default) and that the " +  
                            "Hibernate connection release mode is set to 'on_close' (SpringTransactionFactory's default). " +  
                            "Make sure that your LocalSessionFactoryBean actually uses SpringTransactionFactory: Your " +  
                            "Hibernate properties should *not* include a 'hibernate.transaction.factory_class' property!");  
                }  
                if (logger.isDebugEnabled()) {  
                    logger.debug(  
                            "Not preparing JDBC Connection of Hibernate Session [" + SessionFactoryUtils.toString(session) + "]");  
                }  
            }  
            //如果事务是只读，且事务对象是新的Hibernate Session  
            if (definition.isReadOnly() && txObject.isNewSession()) {  
                //设置Hibernate Session刷新模式为手动  
                session.setFlushMode(FlushMode.MANUAL);  
            }  
            //如果事务是非只读的，且事务对象不是新Hibernate Session  
            if (!definition.isReadOnly() && !txObject.isNewSession()) {  
                //或者Hibernate的刷新模式  
                FlushMode flushMode = session.getFlushMode();  
                //设置Session的刷新模式  
                if (flushMode.lessThan(FlushMode.COMMIT)) {  
                    session.setFlushMode(FlushMode.AUTO);  
                //为事务对象设置刷新模式   txObject.getSessionHolder().setPreviousFlushMode(flushMode);  
                }  
            }  
            Transaction hibTx;  
            //获取事务超时时长  
            int timeout = determineTimeout(definition);  
            //如果事务配置的超时时长不是事务默认超时时长  
            if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {  
                //获取Hibernate Session事务  
                hibTx = session.getTransaction();  
                //为事务对象设置超时时长  
                hibTx.setTimeout(timeout);  
                //开启事务  
                hibTx.begin();  
            }  
            //如果事务配置的超时时长是默认超时时长  
            else {  
                //通过Hibernate Session直接开启事务  
                hibTx = session.beginTransaction();  
            }  
            //把事务设置到事务对象的SessionHolder中，并且线程绑定  
            txObject.getSessionHolder().setTransaction(hibTx);  
            //如果数据源不为null，即设置了数据源  
            if (getDataSource() != null) {  
                //使用Hibernate Session打开数据库连接  
                Connection con = session.connection();  
                //创建ConnectionHolder  
                ConnectionHolder conHolder = new ConnectionHolder(con);  
                //设置超时时长  
                if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {  
                    conHolder.setTimeoutInSeconds(timeout);  
                }  
                if (logger.isDebugEnabled()) {  
                    logger.debug("Exposing Hibernate transaction as JDBC transaction [" + con + "]");  
                }  
            //将数据源和JDBC ConnectionHolder绑定到当前线程 TransactionSynchronizationManager.bindResource(getDataSource(), conHolder);  
                //将创建的JDBC ConnectionHolder设置到事务对象中  
                txObject.setConnectionHolder(conHolder);  
            }  
            //如果事务对象中的SessionHolder是新的  
            if (txObject.isNewSessionHolder()) {  
            //当SessionHolder和当前线程绑定起来   TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());  
            }  
        //设置事务对象中的SessionHolder是事务同步的   txObject.getSessionHolder().setSynchronizedWithTransaction(true);  
        }  
        //事务开启过程中异常处理  
        catch (Exception ex) {  
            if (txObject.isNewSession()) {  
                try {  
                    //如果Session的事务上激活的，回滚Session的事务  
                    if (session.getTransaction().isActive()) {  
                        session.getTransaction().rollback();  
                    }  
                }  
                catch (Throwable ex2) {  
                    logger.debug("Could not rollback Session after failed transaction begin", ex);  
                }  
                finally {  
                    //关闭Session  
                    SessionFactoryUtils.closeSession(session);  
                }  
            }  
            throw new CannotCreateTransactionException("Could not open Hibernate Session for transaction", ex);  
        }  
    }  
    //事务挂起  
    protected Object doSuspend(Object transaction) {  
        HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;  
        //把当前的SessionHolder从线程中和事务对象中释放  
        txObject.setSessionHolder(null);  
        //解析SessionHolder和线程的绑定  
        SessionHolder sessionHolder =  
                (SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory());  
        txObject.setConnectionHolder(null);  
        ConnectionHolder connectionHolder = null;  
        //解除数据源和线程的绑定  
        if (getDataSource() != null) {  
            connectionHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(getDataSource());  
        }  
        return new SuspendedResourcesHolder(sessionHolder, connectionHolder);  
    }  
    //事务恢复  
    protected void doResume(Object transaction, Object suspendedResources) {  
        SuspendedResourcesHolder resourcesHolder = (SuspendedResourcesHolder) suspendedResources;  
        //如果事务管理器中有SessionFactory  
        if (TransactionSynchronizationManager.hasResource(getSessionFactory())) {  
    //解除SessionFactory和当前线程的绑定  
    TransactionSynchronizationManager.unbindResource(getSessionFactory());  
        }  
    //如果事务管理器中没有SessionFactory，则将Session和当前线程绑定 TransactionSynchronizationManager.bindResource(getSessionFactory(), resourcesHolder.getSessionHolder());  
        if (getDataSource() != null) {  
        TransactionSynchronizationManager.bindResource(getDataSource(), resourcesHolder.getConnectionHolder());  
        }  
    }  
    //准备提交  
    protected void prepareForCommit(DefaultTransactionStatus status) {  
        //如果事务配置为FlushBeforeCommit，并且是新事务  
        if (this.earlyFlushBeforeCommit && status.isNewTransaction()) {  
            //获取事务对象  
            HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();  
            //回去事务对象中的Session  
            Session session = txObject.getSessionHolder().getSession();  
            //如果Session的刷新模式不低于COMMIT  
            if (!session.getFlushMode().lessThan(FlushMode.COMMIT)) {  
                logger.debug("Performing an early flush for Hibernate transaction");  
                try {  
                    //刷新Session  
                    session.flush();  
                }  
                catch (HibernateException ex) {  
                    throw convertHibernateAccessException(ex);  
                }  
                finally {  
                    //把Session的刷新模式设置为MANUAL  
                    session.setFlushMode(FlushMode.MANUAL);  
                }  
            }  
        }  
    }  
    //提交处理  
    protected void doCommit(DefaultTransactionStatus status) {  
        //获取当前的Hibernate事务对象  
        HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();  
        if (status.isDebug()) {  
            logger.debug("Committing Hibernate transaction on Session [" +SessionFactoryUtils.toString(txObject.getSessionHolder().getSession()) + "]");  
        }  
        try {  
            //通过Hibernate事务完成提交  
            txObject.getSessionHolder().getTransaction().commit();  
        }  
        catch (org.hibernate.TransactionException ex) {  
            throw new TransactionSystemException("Could not commit Hibernate transaction", ex);  
        }  
        catch (HibernateException ex) {  
            throw convertHibernateAccessException(ex);  
        }  
    }  
    //回滚处理  
    protected void doRollback(DefaultTransactionStatus status) {  
        //获取Hibernate事务对象  
        HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();  
        if (status.isDebug()) {  
            logger.debug("Rolling back Hibernate transaction on Session ["+SessionFactoryUtils.toString(txObject.getSessionHolder().getSession()) + "]");  
        }  
        try {  
            //通过Hibernate事务执行回滚操作  
            txObject.getSessionHolder().getTransaction().rollback();  
        }  
        catch (org.hibernate.TransactionException ex) {  
            throw new TransactionSystemException("Could not roll back Hibernate transaction", ex);  
        }  
        catch (HibernateException ex) {  
            throw convertHibernateAccessException(ex);  
        }  
        finally {  
            if (!txObject.isNewSession() && !this.hibernateManagedSession) {  
                //清除事务对象中的Hibernate Session  
                txObject.getSessionHolder().getSession().clear();  
            }  
        }  
    }  
……  
    }  

通过上面对Hibernate事务处理器的分析，我们看到真正执行提交、回滚等事务操作的还是Hibernate Transaction事务对象，这与单独直接使用Hibernate没有什么区别，只是Spring将其做了通用封装，更加方便使用。