关于spring事物的一些测试

墨蓝 2022-07-21 02:12 184阅读 0赞

spring事物的传播方式主要有以下几种：

PROPAGATION\_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。  
PROPAGATION\_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行。  
PROPAGATION\_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常。  
PROPAGATION\_REQUIRES\_NEW：新建事务，如果当前存在事务，把当前事务挂起。  
PROPAGATION\_NOT\_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。  
PROPAGATION\_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。  
PROPAGATION\_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务，如果当前没有事务，就新建一个事务。

下面我建一个web工程开始测试以上几种事物。

TestService:主要是往aa表中插入一条数据，然后调用TestService2的outterYesSave方法。

package com.syz.tx.service;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class TestService {
        private JdbcTemplate jdbcTemplate;
    
        public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
            this.jdbcTemplate = jdbcTemplate;
        }
    
        private TestService2 testService2;
    
        public void setTestService2(TestService2 testService2) {
            this.testService2 = testService2;
        }
    
        public void currYesSave() {
            String sql = "insert into aa(name,gold) values(?,?)";
            jdbcTemplate.update(sql, new Object[] { "cur_yes", 100.0 });
            testService2.outterYesSave();
        }
    
    }

TestService2:往bb表中插入一条数据。

package com.syz.tx.service;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class TestService2 {
        private JdbcTemplate jdbcTemplate;
    
        public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
            this.jdbcTemplate = jdbcTemplate;
        }
    
        public void outterYesSave() {
            String sql = "insert into bb(name,money) values(?,?)";
            jdbcTemplate.update(sql, new Object[] { "out_yes", 200.0 });
        }
    }

开始测试：

1.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="REQUIRED"

调用TestService.currYesSave执行结果：

![Center][]

可以看到执行TestService.currYesSave时创建了一个事物，而TestService2.outterYesSave时，它直接引用了上面已经存在的事物。解释了：PROPAGATION\_REQUIRED：支持当前事务。

2.TestService.currYesSave：propagation="SUPPORTS"，TestService2.outterYesSave：propagation="REQUIRED"

调用TestService.currYesSave执行结果：

![Center 1][]

可以看到执行TestService.currYesSave时，直接创建了一个连接就执行了sql，此处没有开启事物。解释了：PROPAGATION\_SUPPORTS：如果当前没有事务，就以非事务方式执行。执行TestService2.outterYesSave时创建了一个事物。解释了：PROPAGATION\_REQUIRED：如果当前没有事务，就新建一个事务。

3.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="SUPPORTS"

调用TestService.currYesSave执行结果：

![Center 2][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时直接引用了上面已经存在的事物。解释了：PROPAGATION\_SUPPORTS：支持当前事务。

4.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="MANDATORY"

调用TestService.currYesSave执行结果：

![Center 3][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时直接引用了上面已经存在的事物。解释了：PROPAGATION\_MANDATORY：支持当前事务。

5.TestService.currYesSave：propagation="SUPPORTS"，TestService2.outterYesSave：propagation="MANDATORY"

调用TestService.currYesSave执行结果：

![Center 4][]

可以看到执行TestService.currYesSave时，直接就执行了sql。执行TestService2.outterYesSave时，发现没有事物，直接就报异常了。解释了：PROPAGATION\_MANDATORY：如果当前没有事务，就抛出异常。在这里说一下此次数据库的数据，aa表新加了一条数据，bb表没有。

6.TestService.currYesSave：propagation="SUPPORTS"，TestService2.outterYesSave：propagation="REQUIRES\_NEW"

调用TestService.currYesSave执行结果：

![Center 5][]

可以看到执行TestService.currYesSave时，直接就执行了sql。执行TestService2.outterYesSave时，新建了一个事物。解释了：PROPAGATION\_REQUIRES\_NEW：新建事务。

7.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="REQUIRES\_NEW"

调用TestService.currYesSave执行结果：

![Center 6][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时，挂起当前事物，新建了一个事物。解释了：PROPAGATION\_REQUIRES\_NEW：如果当前存在事务，把当前事务挂起。

8.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="NOT\_SUPPORTED"

调用TestService.currYesSave执行结果：

![Center 7][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时，挂起当前事物，然后直接执行了sql。解释了：PROPAGATION\_NOT\_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

9.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="NEVER"

调用TestService.currYesSave执行结果：

![Center 8][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时，直接就抛出异常了。解释了：PROPAGATION\_NEVER：如果当前存在事务，则抛出异常。此时数据库中aa和bb都没有加进数据。aa插入语句回滚了，bb插入语句没执行。

10.TestService.currYesSave：propagation="SUPPORTS"，TestService2.outterYesSave：propagation="NEVER"

调用TestService.currYesSave执行结果：

![Center 9][]

可以看到执行TestService.currYesSave时，直接执行了sql。执行TestService2.outterYesSave时，直接直接执行了sql。解释了：PROPAGATION\_NEVER：以非事务方式执行。

11.TestService.currYesSave：propagation="SUPPORTS"，TestService2.outterYesSave：propagation="NESTED"

调用TestService.currYesSave执行结果：

![Center 10][]

可以看到执行TestService.currYesSave时，直接执行了sql。执行TestService2.outterYesSave时，新建了一个事物。解释了：PROPAGATION\_NESTED：如果当前没有事务，就新建一个事务。

12.TestService.currYesSave：propagation="REQUIRED"，TestService2.outterYesSave：propagation="NESTED"

调用TestService.currYesSave执行结果：

![Center 11][]

可以看到执行TestService.currYesSave时，创建了一个事物。执行TestService2.outterYesSave时，创建了一个嵌套事物。解释了：PROPAGATION\_NESTED：支持当前事务，如果当前事务存在，则执行一个嵌套事务。那么此时创建了几个事物呢？答案是一个，注意和PROPAGATION\_REQUIRES\_NEW的区别，这里是Create nested transaction，而REQUIRES\_NEW是Create new transaction，故7中有两个事物。

测试完了，说一下感受吧。虽然事物的传播方式有7种，但我们经常用的估计就两种，REQUIRED和SUPPORTS，对于有更新操作的设置为REQUIRED，其它都设置为SUPPORTS，一般就能满足我们的需求了。

以上是ServiceA.methodA中调用ServiceB.methodB的情况，下面我们来看看ServiceA.methodA中调用ServiceA.methodB的情况：

TestService3：methodA向aa表插入数据，然后调用methodB。mehtodB向bb表插入数据。

package com.syz.tx.service;
    
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class TestService3 {
        private JdbcTemplate jdbcTemplate;
    
        public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
            this.jdbcTemplate = jdbcTemplate;
        }
    
        public void methodA() {
            String sql = "insert into aa(name,gold) values(?,?)";
            jdbcTemplate.update(sql, new Object[] { "cur_yes", 100.0 });
            methodB();
        }
    
        public void methodB() {
            String sql = "insert into bb(name,money) values(?,?)";
            jdbcTemplate.update(sql, new Object[] { "out_yes", 200.0 });
        }
    
    }

1.TestService3.mehtodA：propagation="SUPPORTS"，TestService3.methodB：propagation="REQUIRES\_NEW"

调用TestService3.methodA结果：

![Center 12][]

可以看到执行TestService3.methodA时，直接执行了sql，执行TestService3.methodB时，也是直接执行了sql。测试结果：完全没有创建事物。

2.TestService3.mehtodA：propagation="SUPPORTS"，TestService3.methodB：propagation="REQUIRES\_NEW"

调用TestService3.methodA结果：

![Center 13][]

可以看到执行TestService3.methodA时，创建了一个事物。执行TestService3.methodB时，直接执行了sql。测试结果：只创建了一个事物。

总结：通过以上两个测试，可以得出结论，在同一个类中，嵌套调用本类的其它方法，相当于直接把嵌套方法复制到了当前方法。对于是否创建了事物，得看当前方法有没有事物。如1，methodA无事物，调用methodB，结果没有创建事物；又如2，methodA有事物，调用methodB，结果methodB被合并到methodA了，共用一个事物。

[Center]: /images/20220720/834d149efecf4dd78ca766002e747453.png
[Center 1]: /images/20220720/671b98998213498c9d95de8c92c545c2.png
[Center 2]: /images/20220720/aab5240484f34ee2915ebbeb0fd89415.png
[Center 3]: /images/20220720/a927635168664a40930c0a471e587de5.png
[Center 4]: /images/20220720/ba9c3ef2268245af8198521a7fac6388.png
[Center 5]: /images/20220720/e2c46b19c3954c22857b4f3e78cd70a1.png
[Center 6]: /images/20220720/07396944adae4f0e939beff833c1e13b.png
[Center 7]: /images/20220720/920853af75b147f0be133905f4b830e8.png
[Center 8]: /images/20220720/d5ba1632440c42d8a214480cc957d748.png
[Center 9]: /images/20220720/0850904d3070415e8b896c4de9a7fbea.png
[Center 10]: /images/20220720/c4eaf1410c6b4046bc950a977f4c38f1.png
[Center 11]: /images/20220720/6d588237b88d4f4ca1a0184633244c69.png
[Center 12]: /images/20220720/bccbf9ef1b384d44a6bc766240ab87d9.png
[Center 13]: /images/20220720/02e0ee1974374c2381faf71f8acc9079.png

发表评论取消回复

表情：

评论列表（有 0 条评论，184人围观）

还没有评论，来说两句吧...

相关阅读

相关关于测试金字塔的一些思考

以下为作者观点： > 这是关于自动化测试金字塔的指南–一个经常被误用的常见概念。在我从事软件测试和测试自动化工作的近十年中，我遇到测试金字塔这个词的次数可能多到数不清。

约定不等于承诺〃/ 2023年10月08日 19:59/ 0 赞/ 39 阅读

相关 spring事物

SPRING的事物关健在类org.springframework.orm.hibernate3.HibernateTransactionManager，而不在org.spr

浅浅的花香味﹌/ 2022年08月25日 14:45/ 0 赞/ 157 阅读

相关关于spring事物的一些测试

spring事物的传播方式主要有以下几种： PROPAGATION\_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGA

墨蓝/ 2022年07月21日 02:12/ 0 赞/ 185 阅读

相关关于spring和springboot +mybatis事物管理的问题！

注意这只是和mybatis相关的，其他与数据库相关的框架未测试！ 1、在ssm框架中，配置开启事务管理注解后，注解加service的接口里面，注意是接口，并不是clas

清疚/ 2022年06月12日 23:57/ 0 赞/ 205 阅读

相关 Spring事物回滚机制测试

1、直接在service写两个插入语句，让第二个异常，也不做任何try catch, 此时能回滚，控制器做异常处理 public int insertSelectiv

我不是女神ヾ/ 2022年06月08日 23:19/ 0 赞/ 248 阅读

相关关于事物、关于MySql的锁

看了一篇关于mysql事物、锁的文章，[原文点击这里][Link 1] 亲自进行了测试，确实是这样的。在一个事物中，如果update的where条件中存在主键条件或者索引

心已赠人/ 2022年05月29日 02:56/ 0 赞/ 297 阅读

相关关于Linux系统缓存的一些测试

LRU缓存回收策略的验证环境信息: 准备工作：操作步骤：

小鱼儿/ 2022年05月25日 02:16/ 0 赞/ 186 阅读

相关 spring事物

@Transactional(rollbackFor=Exception.class) 意思是指定回滚的异常，直接就指定了Exception。只要是Exception或者是E

小鱼儿/ 2022年05月11日 16:22/ 0 赞/ 292 阅读

相关关于JWPlayer播放器的一些测试学习

[关于JWPlayer播放器的一些测试学习][JWPlayer] 1. <!DOCTYPE html> <html> <head>

- 日理万妓/ 2022年04月24日 05:08/ 0 赞/ 183 阅读

相关 Spring事物

Spring事物基本原理（AOP）：对执行方法前后进行拦截，然后在目标方法开始之前创建或加入一个事物，在执行完目标方法之后，根据执行情况提交或者回滚事

「爱情、让人受尽委屈。」/ 2022年02月20日 05:37/ 0 赞/ 270 阅读