Spring 事务嵌套和异常捕获的问题和解决方案

清疚 2023-01-10 05:10 203阅读 0赞

### 事务嵌套和异常捕获的问题和解决方案 ###

*   *   *  1. 无嵌套的正常事务
         *  2. 方法A调用带事务的方法B
         *  3. 加入异常捕获处理的事务
         *  4. 事务回滚的注意事项

![image-20200708160944615][]

### 1. 无嵌套的正常事务 ###

public class C{ 
        @Transactional
        public void a(){ 
             //TODO
        }
    }

【结论】：`出现异常，正常回滚。`

> 原因：
> 
> 事务的 ACID 特性中的 C，Consistency 一致性，事务内有操作失败时则数据将全部回滚到修改前的状态。

![img][]

### 2. 方法A调用带事务的方法B ###

public class C{ 
        public void a(){ 
            b();
        }
        @Transactional
        public void b(){ 
             //TODO
        }
    }

【结论】：`同一个类内，方法 A 调用了带事务的方法 B，则方法 B 的事务将失效。`

> 原因：
> 
> spring aop 动态代理机制给当前类 C 生成代理类 PolicyC，然后 A 调用 B 还是在 C 类中调用(而不是代理类 PolicyC)，代理类 PolicyC 中的 B 方法并没有被调用到。

![image-20210122235728136][]

> 解决方案：
> 
> `只有在不同的类 C 和 C1 中，C 类中的 A 方法调用 C1 类中的 B 方法，这样 B 中的事务就会生效。`
> 
>     public class C{ 
>         @Autowired 
>         private C1 c1;
>         //注入 C1 类调用 c1 类中的 B() 方法
>         public void A(){ 
>            c1.B();
>         }
>     }
>     public class C1{ 
>         @Transactional
>         public void B(){ 
>             //TODO
>         }
>     }

### 3. 加入异常捕获处理的事务 ###

public class C{ 
        @Transactional
        public void a(){ 
            try { 
                //TODO
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    }

【结论】：`事务方法中对原子操作进行普通的 try-catch 时，事务会失效。`

> 原因：
> 
> 默认spring事务只在发生未被捕获的 RuntimeExcetpion 时才回滚。
> 
> Spring 声明式事务默认会对非检查型异常和运行时异常进行回滚，而`对检查型异常不进行回滚`操作。Error和RuntimeException及其子类为非检查型异常。通过如下几种方式改变其规则：
> 
> 1）让 checked 异常也进行回滚，使用 @Transactional(rollbackFor = Exception.class)
> 
> 2）让 unchecked 异常也不回滚，使用 @Transactional(notRollbackFor = RunTimeException.class)
> 
> 3）不需要事务，@Transactional(propagation = Propagation.NOT\_SUPPORTED)
> 
> 4）如果不添加 rollbackFor 等属性，Spring碰到 Unchecked Exceptions 都会回滚，不仅是RuntimeException，也包括 Error。
> 
> 因此，本场景下会让 spring aop 无法正常捕捉到运行时的事务中的异常，从而事务失效。

![image-20210123001556309][]

> 解决方案：
> 
> 1.  在 catch 语句中，继续抛出 Exception。不建议这么做，不太友好(调用者需捕获处理异常)。
>     
>         public class C{ 
>             @Transactional
>             public void a() throws Exception { 
>                 try { 
>                     //TODO
>                 } catch (Exception e) { 
>                     e.printStackTrace();
>                     throw new Exception(); //或用 throw new RuntimeException() 则无需往上继续抛，可被 aop 捕获进而事务回滚
>                 }
>             }
>         }
> 2.  对于要进行事务的方法，不使用 try catch，在上层调用的时候处理异常；  
>     说明：同样不能再同一个类内，原因参考 方法A调用带事务的方法B 场景。
> 3.  在 catch 语句中增加 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();语句，手动回滚，这样上层就无需去处理异常。
>     
>         public class C{ 
>             @Transactional
>             public void a() { 
>                 try { 
>                     //TODO
>                 } catch (Exception e) { 
>                     e.printStackTrace();
>                     TransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); //手动回滚
>                 }
>             }
>         }

### 4. 事务回滚的注意事项 ###

1.  要想事务起作用，必须是主方法名上有 @Transactional 注解，方法体内不能用 try catch；如果用 try catch，则 catch 中必须用 throw new RuntimeException();
2.  @Transactional 注解应该只被应用到 public 方法上，不要用在 protected、private 等方法上，即使用了也将被忽略，不起作用，这是由 Spring AOP 决定的。
3.  只有来自外部的方法调用才会被 AOP 代理捕捉，类内部方法调用类内部的其他方法，子方法并会不引起事务行为，即使被调用的方法上使用有 @Transactional 注解。
4.  类内部方法调用内部的其他方法，被调用的方法体中如果有 try catch，则 catch 中必须用 throw new RuntimeException()，否则即使主方法上加上 @Transactional 注解，如果被调用的子方法出错也不会抛出异常，不会引起事务起作用。

[image-20200708160944615]: /images/20221119/da650f021142412ca023270eae3abccc.png
[img]: /images/20221119/cff7596c742c4e22b4336a082e688b25.png
[image-20210122235728136]: /images/20221119/b4af572d82ad4a82bf2adf45b47e1bd7.png
[image-20210123001556309]: /images/20221119/b33e56c533ed49debb16642e1c730af7.png