CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Spring声明式事务在哪些情况下会失效？由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

编程式事务

  。

在Spring中事务管理的方式有两种，编程式事务和声明式事务。先详细介绍一下两种事务的实现方式. 。

配置类 。

1. @Configuration 
2. @EnableTransactionManagement 
3. @ComponentScan("com.javashitang") 
4. public class AppConfig { 
5.  
6.     @Bean 
7.     public DruidDataSource dataSource() { 
8.         DruidDataSource ds = new DruidDataSource(); 
9.         ds.setDriverClassName("com.mysql.jdbc.Driver"); 
10.         ds.setUrl("jdbc:mysql://localhost:3306/test?characterEncoding=utf8&useSSL=true"); 
11.         ds.setUsername("test"); 
12.         ds.setPassword("test"); 
13.         ds.setInitialSize(5); 
14.         return ds; 
15.     } 
16.  
17.     @Bean 
18.     public DataSourceTransactionManager dataSourceTransactionManager() { 
19.         return new DataSourceTransactionManager(dataSource()); 
20.     } 
21.  
22.     @Bean 
23.     public JdbcTemplate jdbcTemplate(DataSource dataSource) { 
24.         return new JdbcTemplate(dataSource); 
25.     } 
26.  
27.     @Bean 
28.     public TransactionTemplate transactionTemplate() { 
29.         return new TransactionTemplate(dataSourceTransactionManager()); 
30.     } 
31. } 

1. public interface UserService { 
2.     void addUser(String name, String location); 
3.     default void doAdd(String name) {}; 
4. } 

1. @Service 
2. public class UserServiceV1Impl implements UserService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.     @Autowired 
7.     private TransactionTemplate transactionTemplate; 
8.  
9.     @Override 
10.     public void addUser(String name, String location) { 
11.         transactionTemplate.execute(new TransactionCallbackWithoutResult() { 
12.  
13.             @Override 
14.             protected void doInTransactionWithoutResult(TransactionStatus status) { 
15.                 try { 
16.                     String sql = "insert into user (`name`) values (?)"; 
17.                     jdbcTemplate.update(sql, new Object[]{name}); 
18.                     throw new RuntimeException("保存用户信息失败"); 
19.                 } catch (Exception e) { 
20.                     e.printStackTrace(); 
21.                     status.setRollbackOnly(); 
22.                 } 
23.             } 
24.         }); 
25.     } 
26. } 

可以看到编程式事务的方式并不优雅，因为业务代码和事务代码耦合到一块，当发生异常的时候还得需要手动回滚事务(比使用JDBC方便多类，JDBC得先关闭自动自动提交，然后根据情况手动提交或者回滚事务) 。

如果让你优化事务方法的执行?你会如何做？

「其实我们完全可以用AOP来优化这种代码，设置好切点，当方法执行成功时提交事务，当方法发生异常时回滚事务，这就是声明式事务的实现原理」 。

使用AOP后，当我们调用事务方法时，会调用到生成的代理对象，代理对象中加入了事务提交和回滚的逻辑.

声明式事务

  。

Spring aop动态代理的方式有如下几种方法 。

JDK动态代理实现(基于接口)(JdkDynamicAopProxy) 。

CGLIB动态代理实现(动态生成子类的方式)(CglibAopProxy) 。

AspectJ适配实现 。

spring aop默认只会使用JDK和CGLIB来生成代理对象 。

@Transactional可以用在哪里？

@Transactional可以用在类，方法，接口上 。

用在类上，该类的所有public方法都具有事务 。

用在方法上，方法具有事务。当类和方法同时配置事务的时候，方法的属性会覆盖类的属性 。

用在接口上，一般不建议这样使用，因为只有基于接口的代理会生效，如果Spring AOP使用cglib来实现动态代理，会导致事务失效(因为注解不能被继承) 。

@Transactional失效的场景 。

@Transactional注解应用到非public方法(除非特殊配置，例如使用AspectJ 静态织入实现 AOP) 。

自调用，因为@Transactional是基于动态代理实现的 。

异常在代码中被你自己try catch了 。

异常类型不正确，默认只支持RuntimeException和Error，不支持检查异常 。

事务传播配置不符合业务逻辑 。

@Transactional注解应用到非public方法 。

「为什么只有public方法上的@Transactional注解才会生效?」 。

首相JDK动态代理肯定只能是public，因为接口的权限修饰符只能是public。cglib代理的方式是可以代理protected方法的(private不行哈，子类访问不了父类的private方法)如果支持protected，可能会造成当切换代理的实现方式时表现不同，增大出现bug的可能醒，所以统一一下.

「如果想让非public方法也生效，你可以考虑使用AspectJ」 。

自调用，因为@Transactional是基于动态代理实现的 。

当自调用时，方法执行不会经过代理对象，所以会导致事务失效。例如通过如下方式调用addUser方法时，事务会失效 。

1. // 事务失效 
2. @Service 
3. public class UserServiceV2Impl implements UserService { 
4.  
5.     @Autowired 
6.     private JdbcTemplate jdbcTemplate; 
7.  
8.     @Override 
9.     public void addUser(String name, String location) { 
10.         doAdd(name); 
11.     } 
12.  
13.     @Transactional 
14.     public void doAdd(String name) { 
15.         String sql = "insert into user (`name`) values (?)"; 
16.         jdbcTemplate.update(sql, new Object[]{name}); 
17.         throw new RuntimeException("保存用户失败"); 
18.     } 
19. } 

可以通过如下方式解决 。

1. @Autowired注入自己，假如为self，然后通过self调用方法
2. @Autowired ApplicationContext，从ApplicationContext通过getBean获取自己，然后再调用

1. // 事务生效 
2. @Service 
3. public class UserServiceV2Impl implements UserService { 
4.  
5.     @Autowired 
6.     private JdbcTemplate jdbcTemplate; 
7.     @Autowired 
8.     private UserService userService; 
9.  
10.     @Override 
11.     public void addUser(String name, String location) { 
12.         userService.doAdd(name); 
13.     } 
14.  
15.     @Override 
16.     @Transactional 
17.     public void doAdd(String name) { 
18.         String sql = "insert into user (`name`) values (?)"; 
19.         jdbcTemplate.update(sql, new Object[]{name}); 
20.         throw new RuntimeException("保存用户失败"); 
21.     } 
22. } 

异常在代码中被你自己try catch了 。

这个逻辑从源码理解比较清晰，只有当执行事务抛出异常才能进入completeTransactionAfterThrowing方法，这个方法里面有回滚的逻辑，如果事务方法都没抛出异常就只会正常提交 。

1. // org.springframework.transaction.interceptor.TransactionAspectSupport#invokeWithinTransaction 
2.  
3. try { 
4.   // This is an around advice: Invoke the next interceptor in the chain. 
5.   // This will normally result in a target object being invoked. 
6.   // 执行事务方法 
7.   retVal = invocation.proceedWithInvocation(); 
8. } 
9. catch (Throwable ex) { 
10.   // target invocation exception 
11.   completeTransactionAfterThrowing(txInfo, ex); 
12.   throw ex; 
13. } 
14. finally { 
15.   cleanupTransactionInfo(txInfo); 
16. } 

异常类型不正确，默认只支持RuntimeException和Error，不支持检查异常 。

异常体系图如下。当抛出检查异常时，spring事务不会回滚。如果抛出任何异常都回滚，可以配置rollbackFor为Exception 。

1. @Transactional(rollbackFor = Exception.class) 

事务传播配置不符合业务逻辑

  。

假如说有这样一个场景，用户注册，依次保存用户基本信息到user表中，用户住址信息到地址表中，当保存用户住址信息失败时，我们也要保证用户信息注册成功.

1. public interface LocationService { 
2.     void addLocation(String location); 
3. } 

1. @Service 
2. public class LocationServiceImpl implements LocationService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.  
7.     @Override 
8.     @Transactional 
9.     public void addLocation(String location) { 
10.         String sql = "insert into location (`name`) values (?)"; 
11.         jdbcTemplate.update(sql, new Object[]{location}); 
12.         throw new RuntimeException("保存地址异常"); 
13.     } 
14. } 

1. @Service 
2. public class UserServiceV3Impl implements UserService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.     @Autowired 
7.     private LocationService locationService; 
8.  
9.     @Override 
10.     @Transactional 
11.     public void addUser(String name, String location) { 
12.         String sql = "insert into user (`name`) values (?)"; 
13.         jdbcTemplate.update(sql, new Object[]{name}); 
14.         locationService.addLocation(location); 
15.     } 
16. } 

调用发现user表和location表都没有插入数据，并不符合我们期望，你可能会说抛出异常了，事务当然回滚了。好，我们把调用locationService的部分加上try catch 。

1. @Service 
2. public class UserServiceV3Impl implements UserService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.     @Autowired 
7.     private LocationService locationService; 
8.  
9.     @Override 
10.     @Transactional 
11.     public void addUser(String name, String location) { 
12.         String sql = "insert into user (`name`) values (?)"; 
13.         jdbcTemplate.update(sql, new Object[]{name}); 
14.         try { 
15.             locationService.addLocation(location); 
16.         } catch (Exception e) { 
17.             e.printStackTrace(); 
18.         } 
19.     } 
20. } 

调用发现user表和location表还是都没有插入数据。这是因为在LocationServiceImpl中事务已经被标记成回滚了，所以最终事务还会回滚.

要想最终解决就不得不提到Spring的事务传播行为了，不清楚的小伙伴看《面试官：Spring事务的传播行为有几种?》 。

Transactional的事务传播行为默认为Propagation.REQUIRED。「如果当前存在事务，则加入该事务。如果当前没有事务，则创建一个新的事务」 。

此时我们把LocationServiceImpl中Transactional的事务传播行为改成Propagation.REQUIRES_NEW即可 。

「创建一个新事务，如果当前存在事务，则把当前事务挂起」 。

所以最终的解决代码如下 。

1. @Service 
2. public class UserServiceV3Impl implements UserService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.     @Autowired 
7.     private LocationService locationService; 
8.  
9.     @Override 
10.     @Transactional 
11.     public void addUser(String name, String location) { 
12.         String sql = "insert into user (`name`) values (?)"; 
13.         jdbcTemplate.update(sql, new Object[]{name}); 
14.         try { 
15.             locationService.addLocation(location); 
16.         } catch (Exception e) { 
17.             e.printStackTrace(); 
18.         } 
19.     } 
20. } 
21. @Service 
22. public class LocationServiceImpl implements LocationService { 
23.  
24.     @Autowired 
25.     private JdbcTemplate jdbcTemplate; 
26.  
27.     @Override 
28.     @Transactional(propagation = Propagation.REQUIRES_NEW) 
29.     public void addLocation(String location) { 
30.         String sql = "insert into location (`name`) values (?)"; 
31.         jdbcTemplate.update(sql, new Object[]{location}); 
32.         throw new RuntimeException("保存地址异常"); 
33.     } 
34. } 

1. @Service 
2. public class LocationServiceImpl implements LocationService { 
3.  
4.     @Autowired 
5.     private JdbcTemplate jdbcTemplate; 
6.  
7.     @Override 
8.     @Transactional(propagation = Propagation.REQUIRES_NEW) 
9.     public void addLocation(String location) { 
10.         String sql = "insert into location (`name`) values (?)"; 
11.         jdbcTemplate.update(sql, new Object[]{location}); 
12.         throw new RuntimeException("保存地址异常"); 
13.     } 
14. } 

原文地址：https://mp.weixin.qq.com/s/u-x0twt63TTGbYGI9bwWxg 。

最后此篇关于Spring声明式事务在哪些情况下会失效？的文章就讲到这里了,如果你想了解更多关于Spring声明式事务在哪些情况下会失效？的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。