SpringBoot事务传播

事务方法

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

测试事务

TestTransServiceImpl

@Service
public class TestTransServiceImpl implements TestTransService {

    @Autowired
    private StuService stuService;

    @Transactional(propagation = Propagation.REQUIRED) //父事务
    @Override
    public void testPropagationTrans() {
        stuService.saveParent();
//        try {
//            // save point
//            stuService.saveChildren();
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
        stuService.saveChildren();

//        int a = 1 / 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

StuService

package com.imooc.service;

import com.imooc.pojo.Stu;

public interface StuService {

    public Stu getStuInfo(int id);

    public void saveStu();

    public void updateStu(int id);

    public void deleteStu(int id);

    public void saveParent();
    public void saveChildren();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

StuServiceImpl

@Service
public class StuServiceImpl implements StuService {

    @Autowired
    public StuMapper stuMapper;

    @Transactional(propagation = Propagation.SUPPORTS)
    @Override
    public Stu getStuInfo(int id) {
        return stuMapper.selectByPrimaryKey(id);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void saveStu() {

        Stu stu = new Stu();
        stu.setName("jack");
        stu.setAge(19);
        stuMapper.insert(stu);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void updateStu(int id) {

        Stu stu = new Stu();
        stu.setId(id);
        stu.setName("lucy");
        stu.setAge(20);
        stuMapper.updateByPrimaryKey(stu);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    @Override
    public void deleteStu(int id) {
        stuMapper.deleteByPrimaryKey(id);
    }


    public void saveParent() {
        Stu stu = new Stu();
        stu.setName("parent");
        stu.setAge(19);
        stuMapper.insert(stu);
    }
    @Transactional(propagation = Propagation.NESTED) //子事务
    public void saveChildren() {
        saveChild1();
        int a = 1 / 0;
        saveChild2();
    }

    public void saveChild1() {
        Stu stu1 = new Stu();
        stu1.setName("child-1");
        stu1.setAge(11);
        stuMapper.insert(stu1);
    }
    public void saveChild2() {
        Stu stu2 = new Stu();
        stu2.setName("child-2");
        stu2.setAge(22);
        stuMapper.insert(stu2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

测试主类

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class TransTest {

    @Autowired
    private StuService stuService;

    @Autowired
    private TestTransService testTransService;

    @Test
    public void myTest() {
        testTransService.testPropagationTrans();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@EnableTransactionManagement

为什么不使用@EnableTransactionManagement开启事务管理

• 原因：spring会自动加载

1. 点击Ctrl+鼠标左键 @SpringBootApplication
2. 点击Ctrl+鼠标左键 @EnableAutoConfiguration 53行
3. 点击Ctrl+鼠标左键 AutoConfigurationImportSelector 83行
4. 点击Ctrl+鼠标左键 getAutoConfigurationEntry 98行
5. 找到174行 META-INF/spring.factories 点击小圈搜索对应依赖
6. 展开META-INF找到spring.factories搜索TransactionAutoConfiguration然后进去

org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\

/**
 * {@link org.springframework.boot.autoconfigure.EnableAutoConfiguration
 * Auto-configuration} for Spring transaction.
 *
 * @author Stephane Nicoll
 * @since 1.3.0
 */
1
2
3
4
5
6
7
8
9