文档章节

Spring具体事务处理器的实现

紫萱格主
 紫萱格主
发布于 2015/05/14 00:16
字数 3378
阅读 168
收藏 15

1.Spring的事务处理中,通用的事务处理流程框架是由抽象事务管理器AbstractPlatformTransactionManager来提供的,而具体的底层事务处理实现,由PlatformTransactionManager的具体实现类来实现,如  DataSourceTransactionManager 、JtaTransactionManager和  HibernateTransactionManager等。我们以Spring中最常用的DataSourceTransactionManager和  HibernateTransactionManager为例,来分析具体事务处理器的底层实现事务创建、提交和回滚的处理操作。

2.AbstractPlatformTransactionManager抽象事物处理器:

上一篇博客中,我们已经分析了抽象事物管理器AbstractPlatformTransactionManager的源码,了解它实现了PlatformTransactionManager平台事务管理器接口,提供了一系列设计好的事务模板方法,如事务提交、回滚等,这些模板方法的具体实现由具体的事务处理器来提供。

3.DataSourceTransactionManager事务处理器的实现:

DataSourceTransactionManager数据源事务处理器是针对JDBC连接提供的事务处理器实现,即数据源事务处理器把数据库Connection连接和当前线程进行绑定,通过直接调用数据库连接Connection的提交和回滚方法实现事务的提供和回滚处理。其源码如下:

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事务处理器的事务处理相关源码如下:

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将其做了通用封装,更加方便使用。

 

本文转载自:http://blog.csdn.net/chjttony/article/details/6538452

紫萱格主
粉丝 2
博文 42
码字总数 36233
作品 0
南京
私信 提问
Java框架 Spring 核心机制

概念 轻量级的(面向切面AOP)、(IOC控制反转)容器框架。 Spring优点 1.降低组件之间的耦合性 2.专注于自己业务逻辑,统一的行为(日志、安全等)抽象出来统一处理 3.易于单元测试 4.方...

java知识分子
2018/09/28
19
0
spring事务和jdbc事务

Spring事务的基本原理 Spring事务的本质其实就是数据库对事务的支持,没有数据库的事务支持,spring是无法提供事务功能的。对于纯JDBC操作数据库,想要用到事务,可以按照以下步骤进行: 获取...

TonyStarkSir
2018/04/16
335
0
精华:关于Spring的15点总结

1.Spring 中 AOP 的应用场景、Aop 原理、好处? 答:AOP 用来封装横切关注点,具体可以在下面的 场景中使用: Authentication 权限、Caching缓存、Contextpassing内容传递、Errorhandling错误...

java菜分享
05/09
6
0
SpringBoot的事务管理你会了么?

Springboot内部提供的事务管理器是根据autoconfigure来进行决定的。 比如当使用jpa的时候,也就是pom中加入了spring-boot-starter-data-jpa这个starter之后(之前我们分析过springboot的自动化...

Java高级架构师
2018/08/31
0
0
Spring事务——Spring 2.X的事务配置策略

Spring 2.X的事务配置策略 虽然前面介绍的TransactionProxyFactoryBean配置策略简单易懂,但配置起来极为麻烦:每个目标Bean都需要配置一个TransactionProxyFactoryBean代理,这种方式将导致...

摆渡者
2014/03/27
646
0

没有更多内容

加载失败,请刷新页面

加载更多

rime设置为默认简体

转载 https://github.com/ModerRAS/ModerRAS.github.io/blob/master/_posts/2018-11-07-rime%E8%AE%BE%E7%BD%AE%E4%B8%BA%E9%BB%98%E8%AE%A4%E7%AE%80%E4%BD%93.md 写在开始 我的Arch Linux上......

zhenruyan
今天
4
0
简述TCP的流量控制与拥塞控制

1. TCP流量控制 流量控制就是让发送方的发送速率不要太快,要让接收方来的及接收。 原理是通过确认报文中窗口字段来控制发送方的发送速率,发送方的发送窗口大小不能超过接收方给出窗口大小。...

鏡花水月
今天
8
0
OSChina 周日乱弹 —— 别问,问就是没空

Osc乱弹歌单(2019)请戳(这里) 【今日歌曲】 @tom_tdhzz :#今日歌曲推荐# 分享容祖儿/彭羚的单曲《心淡》: 《心淡》- 容祖儿/彭羚 手机党少年们想听歌,请使劲儿戳(这里) @wqp0010 :周...

小小编辑
今天
897
11
golang微服务框架go-micro 入门笔记2.1 micro工具之micro api

micro api micro 功能非常强大,本文将详细阐述micro api 命令行的功能 重要的事情说3次 本文全部代码https://idea.techidea8.com/open/idea.shtml?id=6 本文全部代码https://idea.techidea8....

非正式解决方案
今天
5
0
Spring Context 你真的懂了吗

今天介绍一下大家常见的一个单词 context 应该怎么去理解,正确的理解它有助于我们学习 spring 以及计算机系统中的其他知识。 1. context 是什么 我们经常在编程中见到 context 这个单词,当...

Java知其所以然
昨天
6
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部