事务（十一）

事务（十一）
Spring 事务失效的原因分析：

案例一

转载：https://www.cnblogs.com/huangjinyong/p/14142662.html

最近在做项目中有个业务是每天定时更新xx的数据,某条记录更新中数据出错,不影响整体数据,只需记录下来并回滚当条记录所关联的表数据; 好啊,这个简单,接到任务后,楼主我三下五除二就写完了,由于这个业务还是有些麻烦,我就在一个service里拆成了两个方法去执行,一个方法(A)是查询数据与验证组装数据,另外一个方法(B)更新这条数据所对应的表(执行的时候是方法A中调用方法B);由于这个数据是循环更新,所以我想的是,一条数据更新失败直接回滚此条数据就是,不会影响其他数据,其他的照常更新,所以我就在方法B上加了事务,方法A没有加; 以为很完美,自测一下正常,ok通过,再测试一下报错情况,是否回滚,一测,没回滚,懵圈儿?.以为代码写错了,改了几处地方,再测了几次,均没回滚.这下是真难受了.

下面开始一步步分析解决问题:

首先我们来看下spring事务的传播机制及原因分析;

PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。
PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。
PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
spring默认的是PROPAGATION_REQUIRED机制,如果方法A标注了注解@Transactional 是完全没问题的,执行的时候传播给方法B,因为方法A开启了事务,线程内的connection的属性autoCommit=false,并且执行到方法B时,事务传播依然是生效的,得到的还是方法A的connection,autoCommit还是为false,所以事务生效;反之,如果方法A没有注解@Transactional 时,是不受事务管理的,autoCommit=true,那么传播给方法B的也为true,执行完自动提交,即使B标注了@Transactional ;

在一个Service内部，事务方法之间的嵌套调用，普通方法和事务方法之间的嵌套调用，都不会开启新的事务.是因为spring采用动态代理机制来实现事务控制，而动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了！

所以以上就是为什么我在没有标注事务注解的方法A里去调用标注有事务注解的方法B而没有事务滚回的原因;

看到这里,有的看官可能在想,你在方法A上标个注解不就完了吗?为什么非要标注在方法B上?

由于我这里是循环更新数据,调用一次方法B就更新一次数据,涉及到几张表,需要执行几条update sql, 一条数据更新失败不影响所有数据,所以说一条数据更新执行完毕后就提交一次事务,如果标注在方法A上,要所有的都执行完毕了才提交事务,这样子是有问题滴.

原因:

spring 在扫描bean的时候会扫描方法上是否包含@Transactional注解，如果包含，spring会为这个bean动态地生成一个子类（即代理类，proxy），代理类是继承原来那个bean的。此时，当这个有注解的方法被调用的时候，实际上是由代理类来调用的，代理类在调用之前就会启动transaction。然而，如果这个有注解的方法是被同一个类中的其他方法调用的，那么该方法的调用并没有通过代理类，而是直接通过原来的那个bean，所以就不会启动transaction，我们看到的现象就是@Transactional注解无效。

为什么一个方法a()调用同一个类中另外一个方法b()的时候，b()不是通过代理类来调用的呢？可以看下面的例子（为了简化，用伪代码表示）：
```
 1 @Service
 2 class A{
 3     @Transactinal
 4     method b(){...}
 5     
 6     method a(){    //标记1
 7         this.b();  //本类中方法调用利用this，所以并没有通过代理对象中的方法调用，也就没有开启事务
 8     }
 9 }
10  
11 //Spring扫描注解后，创建了另外一个代理类，并为有注解的方法插入一个startTransaction()方法：
12 class proxy$A{
13     A objectA = new A();
14     method b(){    //标记2
15         startTransaction();
16         objectA.b();
17     }
18  
19     method a(){    //标记3
20         objectA.a();    //由于a()没有注解，所以不会启动transaction，而是直接调用A的实例的a()方法
21     }
22 }
```
当我们调用A的bean的a()方法的时候，也是被proxy

方法A:无事务控制

方法B:有事务控制

方法B处理失败手动抛出异常触发回滚:

  方法A调用方法B:

从上图可以看到,如果方法B中User更新出错后需要回滚RedPacket数据,所以User更新失败就抛出了继承自RuntimeException的自定义异常,并且在调用方把这个异常catch到重新抛出,触发事务回滚,但是并没有执行;

下面是解决方案:

1.把方法B抽离到另外一个XXService中去,并且在这个Service中注入XXService,使用XXService调用方法B;

显然,这种方式一点也不优雅,且要产生很多冗余文件,看起来很烦,实际开发中也几乎没人这么做吧?.反正我不建议采用此方案;

2.通过在方法内部获得当前类代理对象的方式,通过代理对象调用方法B

上面说了:动态代理最终都是要调用原始对象的，而原始对象在去调用方法时，是不会再触发代理了！

  所以我们就使用代理对象来调用,就会触发事务;

综上解决方案,我觉得第二种方式简直方便到炸. 那怎么获取代理对象呢? 这里提供两种方式:

1.使用 ApplicationContext 上下文对象获取该对象;

2.使用 AopContext.currentProxy() 获取代理对象,但是需要配置exposeProxy=true

我这里使用的是第二种解决方案,具体操作如下:

springboot启动类加上注解:@EnableAspectJAutoProxy(exposeProxy = true)

方法内部获取代理对象调用方法

  完了后再测试,数据顺利回滚,至此,问题得到解决!

案例二

在事务方法中调用另外一个事务方法，被调用方法的事务没起作用

转载：https://blog.csdn.net/sinat_35815559/article/details/88374566

问题描述：（例）

　　service层有两个事务方法insertUser1、insertUser2，当在insertUser1中调用insertUser2是，如果前面方法异常，后边方法不会保存

　　期望：不管insertUser1是否报错，insertUser2 都要报存数据
```
 1     @Transactional(propagation = Propagation.REQUIRED)
 2     public void insertUser1(){
 3         User user = new User("niu","男",19,"1000000");
 4         userDao.insertUser(user);
 5  
 6         this.insertUser2();
 7         //异常
 8         int a = 10/0;
 9     }
10  
11     @Transactional(propagation = Propagation.REQUIRES_NEW)
12     public void insertUser2(){
13         User user = new User("xing","女",19,"1111111");
14         userDao.insertUser(user);
15     }
```
产生问题的原因是：spring是通过代理代管理事务的，当在第一个方法insertUser1内直接调用insertUser2的时候，insertUser2上的事务是不会起作用的（也就是insertUser2是没有开启事务）

解决：

springboot：开始aop事务，在启动类application上添加注解@EnableAspectJAutoProxy(exposeProxy = true)
```
1 @SpringBootApplication
2 @EnableAspectJAutoProxy(exposeProxy = true)
3 public class TestbootApplication {
4  
5     public static void main(String[] args) {
6         SpringApplication.run(TestbootApplication.class, args);
7     }
8 }
```
同时在调用insertUser2时不直接调用，而是通过代理的方式调用：

将代码修改：
```
 1     @Transactional(propagation = Propagation.REQUIRED)
 2     public void insertUser1(){
 3         User user = new User("niu","男",19,"1000000");
 4         userDao.insertUser(user);
 5  
 6         //this.insertUser2();
 7         ((UserService)AopContext.currentProxy()).insertUser2();
 8         //异常
 9         int a = 10/0;
10     }
11  
12     @Transactional(propagation = Propagation.REQUIRES_NEW)
13     public void insertUser2(){
14         User user = new User("xing","女",19,"1111111");
15         userDao.insertUser(user);
16     }
```
这样在调用insertUser2的时候回起用事务管理（((UserService)AopContext.currentProxy()).insertUser2();方法的时候，会将当前事务挂起，重新开启另一个新的事务来执行语句）

可以通过以下代码来判断类是否是代理类：
```
boolean isProxy = AopUtils.isAopProxy((UserService)AopContext.currentProxy());
true：是代理类
false：不是代理类
 
详细博客：https://www.cnblogs.com/micrari/p/7612962.html
```
我的结论：

1.同一个类中，通过普通方法进入，内部调用事务方法，事务会失效；（见：案例一）

2.同一个类中，通过事务方法进入，内部调用普通方法，会是一个统一的事务；

3.同一个类中，通过事务方法A进入，内部调用事务方法B，则事务方法B会失效；（见：案例二）

4.一个类中的方法（事务方法或普通方法），调用另一个类中的方法（事务方法或普通方法），都不会失效；

（1、3两点结论失效的原因都是因为内部方法调用会使用this调用，并不会使用代理对象，所以事务会失效。其实事务失效也就是aop失效，后面会详解aop失效的情况，跟这里的原因是一样的。

这里简单讲一下：就是同一个类中，通过方法A（事务或普通方法）进入，调用该类中的另一个方法B，方法B添加了自定义的aop注解（例如AOP加锁注解），这时方法B的aop就会失效，不会进入aop的逻辑，原因也是方法B

通过this调用的，并不是通过aop代理对象调用的，解决方案跟这里也是一样的。）
带着疑问去思考，然后串联，进而归纳总结，不断追问自己，进行自我辩证，像侦查嫌疑案件一样看待技术问题，漆黑的街道，你我一起寻找线索，你就是技术界大侦探福尔摩斯
相关阅读:
如何限制Dedecms文章或产品描述的字数
 Python 进阶之 yield
Python 进阶之 contextlib模块
 JavaScript 之定时器延迟器
 Python 进阶之函数对象
 CSS入门之定义和应用格式
 Python 进阶之 socket模块
 Python 进阶之闭包变量
 Python 进阶之 else块巧(慎)用
 Python 进阶之 zip() izip() zip_longest函数
原文地址：https://www.cnblogs.com/cainiao-Shun666/p/14531322.html

事务（十一）

Spring 事务失效的原因分析：

案例一

案例二

在事务方法中调用另外一个事务方法，被调用方法的事务没起作用