spring事务管理相关的文章已经有很多了，

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

初级使用：

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

官方介绍：

默认回滚配置实验：

 

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

实验准备：

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

 

[html]  

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"/><!--默认回滚机制是RuntimeException-->  
12.         </tx:attributes>  
13.     </tx:advice>      
14.      
15.     <aop:config>  
16.         <aop:pointcut id="service" expression="execution(* com.my.test..*Service*.*(..))" /><!--声明所有包含Service的类的所有方法使用事务-->  
17.         <aop:advisor advice-ref="txAdvice" pointcut-ref="service" />  
18.     </aop:config>  

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

 

[java]  

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

 

[java]  

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

 

[java]  

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]  

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]  

 

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]  

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

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

 

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

 

[html]  

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

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

 

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

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

 

[java]  

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]  

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]  

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

[java]  

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]  

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. }