Spring事务使用场景

最新推荐文章于 2024-07-24 13:08:50 发布
最新推荐文章于 2024-07-24 13:08:50 发布
阅读量1.1w 收藏 29
点赞数 4
分类专栏： Spring 文章标签： 事务 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/peerless_hero/article/details/77509203
版权

常规调用

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
methodA{
    ……
    try{
        methodB();
    } catch (Exception e) {
        ……
    }
    localA();
    ……
}

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
methodB{
   ……
}

methodA调用methodB时，没有用try-catch语句包住，事务提交/回滚的结果如下：

场景同一个类非同一个类
localA异常回滚回滚
methodB捕获异常/无异常提交提交
methodB抛异常回滚回滚

methodA调用methodB时，用try-catch语句包住，事务提交/回滚的结果如下：

场景同一个类非同一个类
localA异常回滚回滚
methodB捕获异常/无异常提交提交
methodB抛异常提交回滚

这里要重点强调下两个method是否写在同一个类中的区别。
笔者这里是通过在配置文件中添加<tx:annotation-driven/> 来支持事务注解的，该标签会查找和它在相同的应用上下文件中定义的bean上面的@Transactional注解。打上@Transactional注解的类会生成一个代理类，调用时会被事务切面锁拦截。而如果写在同一个类中，methodA是通过this指针调用methodB，这样不会被事务切面所拦截的。

一、当事务方法被切面拦截后，是如何开启Spring事务的呢？
这里写图片描述

createTransactionIfNecessary方法会根据事务属性有需要地创建一个事务。实际的事务创建是在doBegin方法中，

    /**
     * This implementation sets the isolation level but ignores the timeout.
     */
    @Override
    protected void doBegin(Object transaction, TransactionDefinition definition) {
        DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
        Connection con = null;

        try {
            if (txObject.getConnectionHolder() == null ||
                    txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
                // 创建Connection 
                Connection newCon = this.dataSource.getConnection();
                if (logger.isDebugEnabled()) {
                    logger.debug("Acquired Connection [" + newCon + "] for JDBC transaction");
                }
                // 根据Connection创建ConnectionHolder
                txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
            }

            txObject.getConnectionHolder().setSynchronizedWithTransaction(true);
            con = txObject.getConnectionHolder().getConnection();

            Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
            txObject.setPreviousIsolationLevel(previousIsolationLevel);

            // Switch to manual commit if necessary. This is very expensive in some JDBC drivers,
            // so we don't want to do it unnecessarily (for example if we've explicitly
            // configured the connection pool to set it already).
            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);
            }

            // Bind the session holder to the thread.
            if (txObject.isNewConnectionHolder()) {
                // 重头戏在这里，将ConnectionHolder绑定到当前线程
                TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
            }
        }

        catch (Throwable ex) {
            if (txObject.isNewConnectionHolder()) {
                DataSourceUtils.releaseConnection(con, this.dataSource);
                txObject.setConnectionHolder(null, false);
            }
            throw new CannotCreateTransactionException("Could not open JDBC Connection for transaction", ex);
        }
    }

创建Connection后，通过bindResource方法，将ConnectionHolder相关信息存入ThreadLocal对象中，这样ConnectionHolder和线程就绑定起来了。

    public static void bindResource(Object key, Object value) throws IllegalStateException {
        Object actualKey = TransactionSynchronizationUtils.unwrapResourceIfNecessary(key);
        Assert.notNull(value, "Value must not be null");
        Map<Object, Object> map = resources.get();
        // set ThreadLocal Map if none found
        if (map == null) {
            map = new HashMap<Object, Object>();
            resources.set(map);
        }
        Object oldValue = map.put(actualKey, value);
        // Transparently suppress a ResourceHolder that was marked as void...
        if (oldValue instanceof ResourceHolder && ((ResourceHolder) oldValue).isVoid()) {
            oldValue = null;
        }
        if (oldValue != null) {
            throw new IllegalStateException("Already value [" + oldValue + "] for key [" +
                    actualKey + "] bound to thread [" + Thread.currentThread().getName() + "]");
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Bound value [" + value + "] for key [" + actualKey + "] to thread [" +
                    Thread.currentThread().getName() + "]");
        }
    }

    private static final ThreadLocal<Map<Object, Object>> resources =
            new NamedThreadLocal<Map<Object, Object>>("Transactional resources");

我们查看下resources.get()中的数据，

{
    CreateTime:"2017-08-21 11:36:04",
    ActiveCount:1,
    PoolingCount:2,
    CreateCount:3,
    DestroyCount:0,
    CloseCount:0,
    ConnectCount:1,
    Connections:[
        {ID:103750239, ConnectTime:"2017-08-21 11:36:05", UseCount:0, LastActiveTime:"2017-08-21 11:36:05"},
        {ID:1397252899, ConnectTime:"2017-08-21 11:36:05", UseCount:0, LastActiveTime:"2017-08-21 11:36:05"}
    ]
}

二、如果没有Spring事务托管，仅通过mybatis框架是如何管理事务的呢？
mybatis框架本身也可以做事务管理，和Spring管理事务类似，mybatis将sessionHolder保存在ThreadLocal对象中，这样sessionHolder和线程也绑定了起来。

  public static SqlSession getSqlSession(SqlSessionFactory sessionFactory, ExecutorType executorType, PersistenceExceptionTranslator exceptionTranslator) {

    notNull(sessionFactory, NO_SQL_SESSION_FACTORY_SPECIFIED);
    notNull(executorType, NO_EXECUTOR_TYPE_SPECIFIED);
    // 从ThreadLocal对象中获取SqlSessionHolder 
    SqlSessionHolder holder = (SqlSessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);

    SqlSession session = sessionHolder(executorType, holder);
    if (session != null) {
      return session;
    }

    if (LOGGER.isDebugEnabled()) {
      LOGGER.debug("Creating a new SqlSession");
    }
    // 如果不存在SqlSessionHolder，则执行openSession创建session
    session = sessionFactory.openSession(executorType);
    // 将session存入ThreadLocal对象中
    registerSessionHolder(sessionFactory, executorType, exceptionTranslator, session);

    return session;
  }

三、spring事务管理+mybatis事务管理，ThreadLocal对象中的数据如何？

{{
    CreateTime:"2017-08-21 10:54:03",
    ActiveCount:1,
    PoolingCount:2,
    CreateCount:3,
    DestroyCount:0,
    CloseCount:0,
    ConnectCount:1,
    Connections:[
        {ID:748532070, ConnectTime:"2017-08-21 10:54:03", UseCount:0, LastActiveTime:"2017-08-21 10:54:03"},
        {ID:250688639, ConnectTime:"2017-08-21 10:54:03", UseCount:0, LastActiveTime:"2017-08-21 10:54:03"}
    ]
}=org.springframework.jdbc.datasource.ConnectionHolder@44df9749, org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@4e44f87e=org.mybatis.spring.SqlSessionHolder@a8dab8e}

我们看到，resources.get()中的数据不仅包含了ConnectionHolder，又包含了SqlSessionHolder。而SqlSession又封装了Connection信息，我们认为ConnectionHolder和SqlSessionHolder都指向了同一个数据库连接。

四、我们来分析一下methodA在同一个类中调用methodB、methodB抛出异常的场景

methodA会开启Spring事务，methodB不走Spring事务，但methodB会从ThreadLocal对象中获取SqlSession信息，和methodA拥有同一个数据库连接。

(1) 如果methodA用try/catch语句块包住了methodB，
既然methodA会捕获异常，那么代码执行完毕会执行commitTransactionAfterReturning方法，最终会提交数据。

(2) 如果methodA没有用try/catch语句块包住了methodB，
那么代码执行完毕会执行completeTransactionAfterThrowing方法，最终会回滚数据。

五、我们再分析下methodA调用另一个类中的methodB方法、methodB捕获异常/无异常的场景

根据Spring事务传播性，methodA和methodB会加入同一个事务，由于执行过程无异常，methodA和methodB都会执行commitTransactionAfterReturning方法，但只会提交一次。

    private void processCommit(DefaultTransactionStatus status) throws TransactionException {
        try {
            boolean beforeCompletionInvoked = false;
            try {
                prepareForCommit(status);
                triggerBeforeCommit(status);
                triggerBeforeCompletion(status);
                beforeCompletionInvoked = true;
                boolean globalRollbackOnly = false;
                if (status.isNewTransaction() || isFailEarlyOnGlobalRollbackOnly()) {
                    globalRollbackOnly = status.isGlobalRollbackOnly();
                }
                if (status.hasSavepoint()) {
                    if (status.isDebug()) {
                        logger.debug("Releasing transaction savepoint");
                    }
                    status.releaseHeldSavepoint();
                }
                // 新事务才会执行doCommit方法
                else if (status.isNewTransaction()) {
                    if (status.isDebug()) {
                        logger.debug("Initiating transaction commit");
                    }
                    doCommit(status);
                }
                // Throw UnexpectedRollbackException if we have a global rollback-only
                // marker but still didn't get a corresponding exception from commit.
                if (globalRollbackOnly) {
                    throw new UnexpectedRollbackException(
                            "Transaction silently rolled back because it has been marked as rollback-only");
                }
            }
            ....

methodB率先执行commitTransactionAfterReturning方法，但是methodB并未开启新事务，是加入到methodA创建的事务的里，这样就无法执行doCommit方法。methodA再执行commitTransactionAfterReturning方法的时候，status.isNewTransaction()判断为真，执行doCommit方法，就将事务整体提交了。

新开线程调用

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
methodA{
    ……
    new Thread(new Runnable() {
        public void run() {
            methodB();
        }
    }).start();
    localA();
    ……
}

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
methodB{
   ……
}
场景同一个类非同一个类
localA异常A回滚，B提交A回滚，B提交
methodB捕获异常/无异常提交提交
methodB抛异常提交A提交，B回滚

这个场景的结果我们不用多分析了。既然事务信息是保存在ThreadLocal对象里，新开线程调用其它方法，不同线程维护各自的数据库连接，这必然无法保证事务一致。

新开事务

@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
methodA{
    ……
    methodB();
    localA();
    ……
}

@Transactional(propagation = Propagation.PROPAGATION_REQUIRES_NEW, rollbackFor = Exception.class)
methodB{
   ……
}
场景同一个类非同一个类
localA异常回滚A回滚，B提交
methodB捕获异常/无异常提交提交
methodB抛异常回滚回滚
同时更新同一条数据methodA更新值为准死锁

一、新开事务后，数据库连接是不是真的不一样?
我们来追踪下ThreadLocal对象中的值的变化。

(1) methodA

依次执行bindResource和registerSessionHolder后，ThreadLocal对象中的值如下：

{org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@6af9383b=org.mybatis.spring.SqlSessionHolder@35ccbc0b, {
    CreateTime:"2017-08-21 13:45:15",
    ActiveCount:1,
    PoolingCount:2,
    CreateCount:3,
    DestroyCount:0,
    CloseCount:0,
    ConnectCount:1,
    Connections:[
        {ID:1405383256, ConnectTime:"2017-08-21 13:45:15", UseCount:0, LastActiveTime:"2017-08-21 13:45:15"},
        {ID:1808673804, ConnectTime:"2017-08-21 13:45:15", UseCount:0, LastActiveTime:"2017-08-21 13:45:15"}
    ]
}=org.springframework.jdbc.datasource.ConnectionHolder@3f3d370a}

(2) methodB

由于methodB的传播性是PROPAGATION_REQUIRES_NEW，根据源码，其先后执行

    doGetTransaction
    suspend //挂起当前事务
    unbindResource //将methodA绑定在线程上数据库连接信息解绑，也就是resources.get()为null
    doBegin //新开启事务
    bindResource //将methodB的ConnectionHolder绑定在当前线程上
    registerSessionHolder //将methodB的SqlSessionHolder绑定在当前线程上

ThreadLocal对象中的值如下：

{org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@6af9383b=org.mybatis.spring.SqlSessionHolder@334a8b18, {
    CreateTime:"2017-08-21 13:45:15",
    ActiveCount:2,
    PoolingCount:1,
    CreateCount:3,
    DestroyCount:0,
    CloseCount:0,
    ConnectCount:2,
    Connections:[
        {ID:1405383256, ConnectTime:"2017-08-21 13:45:15", UseCount:0, LastActiveTime:"2017-08-21 13:45:15"}
    ]
}=org.springframework.jdbc.datasource.ConnectionHolder@78c36125}

大家看，明显这两个方法的数据库连接是不一样的，比如ActiveCount、PoolingCount等。接下来，methodB将继续执行：

    commitTransactionAfterReturning //无异常，执行commitTransactionAfterReturning
    doCommit //提交当前事务
    cleanupAfterCompletion

methodB执行完毕，methodA继续执行，

    resume //还原methodA被挂起时的数据库连接信息
    bindResource //绑定到当前线程

ThreadLocal对象中的值如下：

{org.apache.ibatis.session.defaults.DefaultSqlSessionFactory@6af9383b=org.mybatis.spring.SqlSessionHolder@35ccbc0b, {
    CreateTime:"2017-08-21 13:45:15",
    ActiveCount:1,
    PoolingCount:2,
    CreateCount:3,
    DestroyCount:0,
    CloseCount:1,
    ConnectCount:2,
    Connections:[
        {ID:1405383256, ConnectTime:"2017-08-21 13:45:15", UseCount:0, LastActiveTime:"2017-08-21 13:45:15"},
        {ID:1808673804, ConnectTime:"2017-08-21 13:45:15", UseCount:1, LastActiveTime:"2017-08-21 13:56:24"}
    ]
}=org.springframework.jdbc.datasource.ConnectionHolder@3f3d370a}

最后，methodA执行commitTransactionAfterReturning和doCommit等方法，提交事务。

二、重点分析一下methodA调用非同一个类中的methodB方法，同时这两个方法会更新同一条数据的情况

methodB新开事务时，methodA对应的事务被挂起。新事务执行完毕才会执行老的事务。而oracle在更新数据时，会把该行记录锁住，老事务迟迟不提交，新事务又无法获得锁，因此一直等待。这就会出现死锁的情况。

不开事务的方法调用开事务的方法

以ClassA中不带事务注解的methodA调用ClassB中带事务注解的methodB、methodB抛出异常为例，

(1) methodA
这里写图片描述

(2) methodB
这里写图片描述

看起来methodA和methodB的数据库连接是一样的，其实是methodA提交完了事务，将数据库连接释放后、methodB又从数据库连接池取得了相同的那个数据库连接。但它们并不在同一个数据库连接里，不能保持事务统一。methodA提交完毕，methodB回滚。

盖世胖胖
关注
  • 4
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring 事务失效的八种场景
流楚丶格念的博客
08-25 2543
而父容器和子容器的区别。比如父容器有a.b.c三个bean对象，子容器有d.e.f三个bean对象，子容器就可以通过getBean方法调用父容器的a.b.c bean对象，而父容器不能通过getBean拿到子容器的d.e.f三个bean对象。其中也要弄清楚的是父子容器并不是一种包含关系，而是平行关系，但是在子容器中有一个parent，指向父容器，也就是说子容器在通过getBean访问父容器中的bean对象时是通过parent访问。解法2：不要用父子容器，所有 bean 放在同一容器。
深入理解Spring事务原理
09-02
Spring事务管理是Spring框架的核心特性之一，它使得开发者能够在应用层面上轻松地处理数据库事务，无需直接接触底层的事务控制。本文将深入探讨Spring事务原理，包括事务的基本概念、Spring事务的传播属性、数据库...
Spring 事务总结
weixin_43281498的博客
03-16 1142
一、事务是什么 事务是逻辑处理原子性的保证手段，通过使用事务控制，可以极大的避免出现逻辑处理失败导致的脏数据等问题。 事务最重要的两个特性，是事务的传播级别和数据隔离级别。传播级别定义的是事务的控制范围，事务隔离级别定义的是事务在数据库读写方面的控制范围。 二、事务的四大特性（ACID） 原子性（Atomicity）： 一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务
SpringAOP 常见应用场景
Zyw907155124的博客
06-08 1350
常见应用场景:日志记录、权限检查、事务管理、异常处理、性能监控、缓存、参数校验和转换、API调用统计、SLF4J、Logback、Log4j等日志框架集成、自定义注解的处理。 1、AOP实现 性能监控；2、AOP实现 API调用统计；3、AOP实现 缓存；4、AOP实现自定义滑动窗口限流
Spring事务详解与使用
itzhuzhu的博客
01-10 1537
J2EE开发使用分层设计的思想进行，对于简单的业务层转调数据层的单一操作，事务开启在业务层或者数据层并无太大差别，当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并归属于同一个事务进行处理
Spring事务失效常见场景
热门推荐
qq_16268979的博客
03-24 2万+
一、事务方法访问修饰符非public，导致事务失效 1、实例 2、解决 方式一：将方法修饰符改为public 方式二：开启AspectJ代理模式 3、注意 　　如果事务是static、final的，同样无法通过动态代理，事务也是不会生效的。 　　Spring的声明式事务是基于动态代理实现的，我们无法重写final修饰的方法； 　　不管是JDK动态代理还是Cglib的动态代理，就是要通过代理的方式获取到代理的具体对象，而static方法修饰的方法是属于类的，不属于任何对象，所以static方法不能被重写，即
Spring事务失效场景
m0_51465608的博客
03-14 958
失效原因：Spring默认只会回滚非检查异常和error错误。解决办法：在@Transactional注解中添加。非检查异常：RuntimeException及其子类。❗注意事项❗。
详解Spring事务失效的八种常见场景
玦尘的博客
04-20 1514
当未正确定义事务管理器或使用不兼容的事务管理器时，Spring 将无法正确识别事务边界并进行事务管理，从而导致事务失效。场景：在 Spring 的配置文件（如 applicationContext.xml 或 application.properties）中未正确定义事务管理器。解决方法：确保在 Spring 的配置文件中定义了事务管理器。例如，在 Spring Boot 中，可以通过在 application.properties 文件中配置数据源相关属性来启用事务管理器。示例：Driver。
spring事务失效的11种场景
爪哇人的博客
04-28 8186
1 访问权限问题： java的访问权限有4种：private、default、protected、public，它们的权限从左到右，以此变大。如果在开发中，将事务方法定义了错误的访问权限，则事务功能会失效。 @Service public class EmpService { @Transactional private void add(UserModel userModel){ saveData(userModel); } } 如上：add方法的权限被定
Spring Event实现以及使用场景
fangxiang2008的博客
03-12 851
Spring Event实现以及使用场景
Spring 事务失效的 8 种场景！
磊哥聊Java
12-21 1万+
在日常工作中，如果对Spring的事务管理功能使用不当，则会造成Spring事务不生效的问题。而针对Spring事务不生效的问题，也是在跳槽面试中被问的比较频繁的一个问题。点击上方卡片关注...
spring事务案例分析.zip
03-23
7. **案例分析**："SPRING事务管理案例分析.docx"很可能包含了具体的项目实例，详细讲解了如何在Spring项目中配置和使用事务管理，以及如何解决实践中遇到的问题。而"studyspring"可能是源代码目录，包含了实现这些...
spring 事务传播 demo
06-05
总之，“spring 事务传播 demo”将展示如何利用Spring的事务传播特性来处理复杂的业务场景，帮助开发者更好地理解和运用这一强大的工具。通过学习和实践这个示例，你将能够掌握在多层方法调用中如何优雅地管理和协调...
spring 事务
07-11
Spring 提供了多种隔离级别以适应不同的场景需求。 4. **持久性**：一旦事务被提交，对数据库的所有更新都是永久的，即使系统出现故障也不例外。 #### 二、Spring 事务管理接口 1. **`PlatformTransactionManager`...
浅谈Spring事务传播行为实战
08-25
浅谈Spring事务传播行为实战 Spring框架提供了事务管理的标准实现，通过注解或者XML文件的方式声明和配置事务。事务管理是指按照给定的事务规则来执行事务的提交或者回滚操作。事务的机制实现很大一部依赖事务日志...
SpringBoot整合Elastic-Job 2.1.53版本任务调度，手动任务，动态添加任务演示
小哇
07-23 397
zookeeper安装并成功运行。
SpringBoot集成Tomcat、DispatcherServlet
最新发布
好记性不如烂笔头
07-24 1277
AbstractApplicationContext 的 refresh 方法是一个空壳方法，我们主要看它的实现类 ServletWebServerApplicationContext。
SpringBoot启动命令过长
tiantiantbtb的博客
07-24 350
Error running 'DromaraApplication': Command line is too long. Shorten command line for DromaraApplication or also for Spring Boot default configuration?
Spring 事务使用场景怎么用
03-04
Spring 事务可以用于需要保证数据一致性的场景，比如银行转账、订单支付等操作。在这些操作中，如果其中一个步骤出现异常，整个操作都应该回滚，保证数据的一致性。使用 Spring 事务可以方便地管理事务，避免手动...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值