spring事务相关

Myth丶恋晨 2022-12-28 06:25 201阅读 0赞

之前去面试的时候，被问到一句spring嵌套事务的情况怎么解决。被问到哑口无言，恰好现在的项目正好用到嵌套事务。并且也正在尝试分布式事务。所以现在也是自己学习了一些嵌套事务相关的东西。

## 事务隔离级别的概念 ##

事务传播 - Propagation
    REQUIRED: 使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；
                     如果当前存在事务，则加入这个事务，成为一个整体。
                   举例：领导没饭吃，我有钱，我会自己买了自己吃；领导有的吃，会分给你一起吃。
    SUPPORTS: 如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。
                     举例：领导没饭吃，我也没饭吃；领导有饭吃，我也有饭吃。
    MANDATORY: 该传播属性强制必须存在一个事务，如果不存在，则抛出异常
                      举例：领导必须管饭，不管饭没饭吃，我就不乐意了，就不干了（抛出异常）
    REQUIRES_NEW: 如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；
                       如果当前没有事务，则同 REQUIRED
                                        举例：领导有饭吃，我偏不要，我自己买了自己吃
        NOT_SUPPORTED: 如果当前有事务，则把事务挂起，自己不适用事务去运行数据库操作
                        举例：领导有饭吃，分一点给你，我太忙了，放一边，我不吃
    NEVER: 如果当前有事务存在，则抛出异常
                 举例：领导有饭给你吃，我不想吃，我热爱工作，我抛出异常
    NESTED: 如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚；
                                     如果当前没有事务，则同 REQUIRED。
                  但是如果主事务提交，则会携带子事务一起提交。
                  如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。
                  举例：领导决策不对，老板怪罪，领导带着小弟一同受罪。小弟出了差错，领导可以推卸责任。

## 几种不同情况的尝试 ##

### 父子事务均无事务隔离级别 ###

@Service
    public class StuServiceImpl implements StuService {
        @Autowired
        StuMapper stuMapper;
    
        @Override
        //@Transactional
        public void saveStuChild() {
            saveChildren1();
            int i =1/0;
            saveChildren2();
        }
    
        public void  saveChildren1(){
            Stu stu = new Stu();
            stu.setAge(11);
            stu.setName("test1");
            stuMapper.insert(stu);
        }
    
        public void  saveChildren2(){
            Stu stu = new Stu();
            stu.setAge(22);
            stu.setName("test1");
            stuMapper.insert(stu);
        }
    
        @Override
        //@Transactional(propagation = Propagation.REQUIRED)
        public void saveStuParent() {
            Stu stu = new Stu();
            stu.setAge(30);
            stu.setName("parent");
            stuMapper.insert(stu);
        }
    }

父级事务的情况

@Service
    public class TestTransServiceImpl implements TestTransService {
    
        @Autowired
        StuService stuService;
        @Override
        public void saveStudent() {
          stuService.saveStuParent();
    
          stuService.saveStuChild();
        }
    }

@Test
        public void TestNoTransactional(){
            testTransService.saveStudent();
        }

异常之前的数据都被保存了。异常之后的数据都没有保存 ![file][]

### 父事务有Required级别事务，子事务无事务 ###

@Service
    public class TestTransServiceImpl implements TestTransService {
    
        @Autowired
        StuService stuService;
        @Override
            @Transactional(propagation = Propagation.REQUIRED)
        public void saveStudent() {
          stuService.saveStuParent();
    
          stuService.saveStuChild();
        }
    }

stuService代码相同

![file][file 1]

事务全部回滚，数据均没有插入数据库。即当子事务没有事务时。子方法是同样在一个事务的。即事务被传递到了子事务

### 子事务有Required级别事务，父事务无事务 ###

@Override
        @Transactional(propagation = Propagation.REQUIRED)
        public void saveStuChild() {
            saveChildren1();
            int i =1/0;
            saveChildren2();
        }

![file][file 2] 可以看到子事务只会影响到子事务。父事务不会被影响。父事务没有事务的方法不受影响

### 子事务为support级别事务，父方法有事务或无事务的两种情况 ###

*  父方法无事务子方法无事务时。加上注解 @Transactional(propagation = Propagation.SUPPORTS)
    
        @Transactional(propagation = Propagation.SUPPORTS)
          public void saveStuChild() {
              saveChildren1();
              int i =1/0;
              saveChildren2();
          }
    
    ![file][file 3] j即跟初始状态无事务的状态一样
 *  父方法事务级别为required,同理可以这种情况跟之前一样也是无法插入数据

### 子方法事务级别为MANDATORY ###

Propagation.MANDATORY要求必须为事务包裹，否则会抛出异常

### 子方法事务级别为REQUIRES\_NEW ###

如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；即自己用自己的事务。如果当前没有事务，则同 REQUIRED。同样是自己使用自己的事务

### 子方法事务隔离级别为NOT\_SUPPORTED。即不支持事务 ###

父方法同样无事务注解的情况下和无事务的情况一样的。

@Transactional(propagation = Propagation.NOT_SUPPORTED)
        public void saveStuChild() {
            saveChildren1();
            int i =1/0;
            saveChildren2();
        }

### 子方法事务隔离级别为NEVER， ###

如果父方法有事务则会抛出异常

### 子方法事务隔离级别为NESTED ###

如果当前有事务，则开启子事务（嵌套事务），嵌套事务是独立提交或者回滚； 如果当前没有事务，则同 REQUIRED。 但是如果主事务提交，则会携带子事务一起提交。 如果主事务回滚，则子事务会一起回滚。相反，子事务异常，则父事务可以回滚或不回滚。

当父方法有事务且发生异常时，子事务一起回滚。当子事务发生异常时。服务器try.catch之后可以选择不回滚 日常用到最多的就是这种模式。刚好最近也用上了。

> 欢迎搜索关注本人与朋友共同开发的微信面经小程序【大厂面试助手】和公众号【微瞰技术】

![file][file 4] ![file][file 5]

[file]: /images/20221120/8f861b46cdc7463686be71bd96f9230a.png
[file 1]: /images/20221120/19e5df81a45641d5ac2de8d594d121eb.png
[file 2]: https://img-blog.csdnimg.cn/20201215095422836.png
[file 3]: https://img-blog.csdnimg.cn/2020121509542395.png
[file 4]: https://img-blog.csdnimg.cn/20201215095423308.png
[file 5]: https://img-blog.csdnimg.cn/20201215095423584.png