spring 事务管理——回滚之service层（事务控制层）代码互调

旧城等待， 2022-05-25 02:12 289阅读 0赞

spring事务管理相关的文章已经有很多了，本人写此文章主要为自己的实验做一个记录，年纪大了，记性不好![偷笑][titter.gif]

首先先贴几个地址，有兴趣研读的同学可以参考一下：

初级使用：

[http://blog.csdn.net/xugangjava/article/details/6770799][http_blog.csdn.net_xugangjava_article_details_6770799]

初级容易犯的错：事务中catch异常

[http://blog.csdn.net/yipanbo/article/details/46048413][http_blog.csdn.net_yipanbo_article_details_46048413]

官方介绍：

[http://docs.spring.io/spring/docs/2.0.x/reference/transaction.html][http_docs.spring.io_spring_docs_2.0.x_reference_transaction.html]

默认回滚配置实验：

[http://blog.csdn.net/lovejavaydj/article/details/7635848][http_blog.csdn.net_lovejavaydj_article_details_7635848]

以上几个地址是从不同的角度来讲spring的事务处理的，本文并非重复的去做以上文中已做过的实验，本文的实验对象是两个事务方法之间的调用，检验是否产生回滚。

实验准备：

1、采用spring声明式事务，实现方式，spring的xml文件中进行配置，配置核心代码如下：

\[html\]  [view plain][]   [copy][view plain]

1.  **<****bean** id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"**>**  
2.          **<****property** name="dataSource" ref="zigbeeDataSource" **/>**  
3.      **</****bean****>**  
4.        
5.      **<****tx:advice** id="txAdvice" transaction-manager="txManager"**>**  
6.          **<****tx:attributes****>**  
7.              **<****tx:method** name="get\*" read-only="true"  **/>**  
8.              **<****tx:method** name="query\*" read-only="true"  **/>**  
9.              **<****tx:method** name="find\*" read-only="true" **/>**  
10.             **<****tx:method** name="is\*" read-only="true" **/>**  
11.             **<****tx:method** name="\*" rollback-for="Exception"**/>**  
12.         **</****tx:attributes****>**  
13.     **</****tx:advice****>**      
14.      
15.     **<****aop:config****>**  
16.         **<****aop:pointcut** id="service" expression="execution(\* com.my.test..\*Service\*.\*(..))" **/>**  
17.         **<****aop:advisor** advice-ref="txAdvice" pointcut-ref="service" **/>**  
18.     **</****aop:config****>**

2、测试类：接口，TestService，方法test() , test1()；测试类 TestMain，main方法（此处只是简要写明测试核心代码，真正测试方法中需要初始化spring），代码如下：

\[java\]  [view plain][]   [copy][view plain]

1.  **public** **interface** TestService \{  
2.          **void** test()**throws** Exception;  
3.      **void** test1()**throws** Exception;  
4.  \}

\[java\]  [view plain][]   [copy][view plain]

1.  //本文验证的代码，一下对两个方法的不同实现方式进行验证说明  
2.  @Service(value="testService")  
3.  **public** **class** TestServiceImpl  **implements** TestService \{  
4.      @Autowired  
5.      TestDao testDao;  
6.      @Override  
7.      **public** **void** test() **throws** Exception \{  
8.          // TODO  
9.      \}  
10.     @Override  
11.     **public** **void** test1() **throws** Exception \{  
12.         // TODO  
13.     \}  
14. \}

\[java\]  [view plain][]   [copy][view plain]

1.  **public** **class** TestMain \{  
2.          **public** **static** **void** main(String\[\] args) \{  
3.          testService.test1();  
4.      \}  
5.  \}

3、测试方案：

①根据配置文件txAdvice所示，test和test1都应有事务支持，当分别单独调用两个方法时，遇到异常抛出时，都应回滚。如TestMain中的main方法调用，在TestService中实现两个方法如下两种情况，事务都会回滚，PS：作者做过更多实验，将异常抛出的位置任意变换，都会进行回滚，数据库不会插入任何数据。

（结论：当两个都有事务回滚的方法之间进行相互调用，无论哪个方法中有异常，在任何位置进行异常抛出，两个方法执行的数据都会回滚）

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.           
12.         **throw** **new** Exception(); // 此处抛出异常  
13.     \}  
14.     @Override  
15.     **public** **void** test1() **throws** Exception \{  
16.         TestEntity te = **new** TestEntity();  
17.         te.setId(2);  
18.         te.setName("222");  
19.         testDao.insert(te);  
20.           
21.         **this**.test(); // 调用test()方法，在test方法中抛出异常  
22.           
23.     \}  
24. \}

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.     \}  
12.     @Override  
13.     **public** **void** test1() **throws** Exception \{  
14.         TestEntity te = **new** TestEntity();  
15.         te.setId(2);  
16.         te.setName("222");  
17.         testDao.insert(te);  
18.           
19.         **this**.test(); // 调用test()方法，test方法执行成功  
20.           
21.         **throw** **new** Exception(); // 此处抛出异常  
22.     \}  
23. \}

②我们修改一些配置文件中的txAdvice， 把<tx:method name="\*" rollback-for="Exception"/>改为默认值

\[html\]  [view plain][]   [copy][view plain]

1.  **<****tx:method** name="\*"**/>**

上述测试代码中的事务均不回滚，充分证明了 spring默认事务回滚机制为RuntimeException。

③我们继续修改配置文件中的txAdvice，继续使用<tx:method name="\*" rollback-for="Exception"/>，另外在这一行上面增加一行

\[html\]  [view plain][]   [copy][view plain]

1.  **<****tx:method** name="test1\*" no-rollback-for="Exception"**/>****</****span****>**

我们让test1方法失去事务回滚的控制

继续测试，test方法虽然还在事务控制之中，但是test1没有事务回滚机制，在test方法中抛出异常并不会使事务回滚，数据库会插入两条数据。另外一种验证，test方法执行成功，test1方法抛出异常仍然不会事务回滚，数据库插入两条数据。

而如果我们将main方法中的调用，改为test()的时候，事务有效，会回滚，不插入数据。

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl  **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.         **throw** **new** Exception(); // 此处抛出异常  
12.     \}  
13.     @Override  
14.     **public** **void** test1() **throws** Exception \{  
15.         TestEntity te = **new** TestEntity();  
16.         te.setId(2);  
17.         te.setName("222");  
18.         testDao.insert(te);  
19.           
20.         **this**.test(); // 调用test()方法，test方法中抛出异常  
21.     \}  
22. \}

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl  **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.     \}  
12.     @Override  
13.     **public** **void** test1() **throws** Exception \{  
14.         TestEntity te = **new** TestEntity();  
15.         te.setId(2);  
16.         te.setName("222");  
17.         testDao.insert(te);  
18.           
19.         **this**.test(); // 调用test()方法，test方法执行成功  
20.           
21.         **throw** **new** Exception(); // 此处抛出异常  
22.     \}  
23. \}

④延续③中的配置文件，我们再换一种测试，main方法中调用test，TestServiceImpl中，test调用test1， 因为test有事务回滚支持，因此无论在哪个方法中抛出异常，事务都会回滚。

\[java\]  [view plain][]   [copy][view plain]

1.  **public** **class** TestMain \{  
2.          **public** **static** **void** main(String\[\] args) \{  
3.          testService.test();  
4.      \}  
5.  \}

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl  **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.           
12.         **this**.test1(); // 调用test1()方法，在test1方法中抛出异常  
13.     \}  
14.     @Override  
15.     **public** **void** test1() **throws** Exception \{  
16.         TestEntity te = **new** TestEntity();  
17.         te.setId(2);  
18.         te.setName("222");  
19.         testDao.insert(te);  
20.           
21.         **throw** **new** Exception(); // 此处抛出异常  
22.     \}  
23. \}

\[java\]  [view plain][]   [copy][view plain]

1.  @Service(value="testService")  
2.  **public** **class** TestServiceImpl  **implements** TestService \{  
3.      @Autowired  
4.      TestDao testDao;  
5.      @Override  
6.      **public** **void** test() **throws** Exception \{  
7.          TestEntity te = **new** TestEntity();  
8.          te.setId(1);  
9.          te.setName("111");  
10.         testDao.insert(te);  
11.           
12.         **this**.test1(); // 调用test1()方法，test1方法执行成功  
13.           
14.         **throw** **new** Exception(); // 此处抛出异常  
15.     \}  
16.     @Override  
17.     **public** **void** test1() **throws** Exception \{  
18.         TestEntity te = **new** TestEntity();  
19.         te.setId(2);  
20.         te.setName("222");  
21.         testDao.insert(te);  
22.     \}  
23. \}

至此，本文的验证完毕，限于本人水平有限，文章难免有遗漏和不足支持，欢迎各位读者给予指导更正批评！

另外，对于文章中的代码，只是截取代码片段，如有错误请自行修改，并在回复中给予指出，切勿原文照搬测试。

[titter.gif]: /images/20220525/a841214c6edb45baba7782b20cbc63d3.png
[http_blog.csdn.net_xugangjava_article_details_6770799]: http://blog.csdn.net/xugangjava/article/details/6770799
[http_blog.csdn.net_yipanbo_article_details_46048413]: http://blog.csdn.net/yipanbo/article/details/46048413
[http_docs.spring.io_spring_docs_2.0.x_reference_transaction.html]: http://docs.spring.io/spring/docs/2.0.x/reference/transaction.html
[http_blog.csdn.net_lovejavaydj_article_details_7635848]: http://blog.csdn.net/lovejavaydj/article/details/7635848
[view plain]: https://blog.csdn.net/sundenskyqq/article/details/51232871#