Spring事务传播设置有如下类型:

1
2
3
4
5
6
7
8
9
10
/**
* 保存user,id是唯一的,否则insert会报错
* REQUIRED :如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。==> 会跟随service层方法回滚事务
* SUPPORTS :如果当前存在事务,则加入该事务;如果当前没有事务,则以非事务的方式继续运行。==> 会跟随service层方法回滚事务
* MANDATORY :如果当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。==> 会跟随service层方法回滚事务
* REQUIRES_NEW :创建一个新的事务,如果当前存在事务,则把当前事务挂起。 ==> 即使service层的方法也加了事务,也无法回滚dao层的事务(内层已经提交了,外层回滚个屁啊)。
* NOT_SUPPORTED :以非事务方式运行,如果当前存在事务,则把当前事务挂起。 ==> 即使service层的方法也加了事务,也无法回滚dao层的事务(内层已经提交了,外层回滚个屁啊)。
* NEVER :以非事务方式运行,如果当前存在事务,则抛出异常。 ==> service层无事务的方法可以运行,也就是说,他只能被一个父事务调用。否则,他就要抛出异常。
* NESTED :如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;如果当前没有事务,则该取值等价于 REQUIRED
*/

上述只是单事务方法的情况,如果存在事务嵌套呢??比如serviceA.methodA()内部调用了serviceB.methodB()方法,methodA()methodB()都是有事务的。这种情况下可以根据如下表格对照:

PROPAGATION TYPE DESCRIPTION
PROPAGATION_REQUIRED 支持当前事务,如果当前没有事务,就新建一个事务。这是最常见的选择。 如果正要执行的事务不在另外一个事务里,那么就起一个新的事务; 比如说,ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候, ServiceA.methodA已经起了事务,这时调用ServiceB.methodBServiceB.methodB看到自己已经运行在ServiceA.methodA 的事务内部,就不再起新的事务。而假如ServiceA.methodA运行的时候ServiceB.methodB发现自己没有在事务中,他就会为自己新建一个事务。 这样,在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常,事务都会被回滚。即使ServiceB.methodB的事务已经被提交,但是ServiceA.methodA在接下来fail要回滚,ServiceB.methodB也要回滚。
PROPAGATION_SUPPORTS 支持当前事务,如果当前没有事务,就以非事务方式执行。 如果当前在事务中,即以事务的形式运行,如果当前不在一个事务中,那么就以非事务的形式运行。
PROPAGATION_MANDATORY 支持当前事务,如果当前没有事务,就抛出异常。 必须在一个事务中运行,也就是说,他只能被一个父事务调用。否则,他就要抛出异常。
PROPAGATION_REQUIRES_NEW 新建事务,如果当前存在事务,把当前事务挂起。 比如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIREDServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW,那么当执行到ServiceB.methodB的时候,ServiceA.methodA所在的事务就会挂起,ServiceB.methodB会起一个新的事务,等待ServiceB.methodB的事务完成以后,他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务,那么就是存在两个不同的事务。如果ServiceB.methodB已经提交,那么ServiceA.methodA失败回滚,ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚,如果他抛出的异常被ServiceA.methodA捕获,ServiceA.methodA事务仍然可能提交。
PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。 不支持当前事务。比如ServiceA.methodA的事务级别是PROPAGATION_REQUIRED,而ServiceB.methodB的事务级别是PROPAGATION_NOT_SUPPORTED,那么当执行到ServiceB.methodB时,ServiceA.methodA的事务挂起,而ServiceB.methodB则以非事务的方式运行完,再继续ServiceA.methodA的事务。
PROPAGATION_NEVER 以非事务方式执行,如果当前存在事务,则抛出异常。 不能在事务中运行。假设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED,而ServiceB.methodB的事务级别是PROPAGATION_NEVER, 那么ServiceB.methodB就要抛出异常了。
PROPAGATION_NESTED 支持当前事务,新增Savepoint点,与当前事务同步提交或回滚。 理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是,PROPAGATION_REQUIRES_NEW另起一个事务,将会与他的父事务相互独立,而Nested的事务和他的父事务是相依的,他的提交是要等和他的父事务一块提交的。也就是说,如果父事务最后回滚,他也要回滚的。 而Nested事务的好处也是他有一个savepoint。

简单示例:

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
68
69
70
71
72
73
package com.ubuntuvim.mybatis.service;


import java.util.Random;
import java.util.UUID;

import javax.annotation.Resource;

import com.ubuntuvim.mybatis.dao.UserMapper;
import com.ubuntuvim.mybatis.entity.User;

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
* @Author: ubuntuvim
* @Date: 2020/9/8 下午10:18
*/
@Service
public class UserServiceImpl implements UserService {

@Resource
UserMapper userMapper;

@Override
public void saveOneNoTransition() {
userMapper.save(new User(UUID.randomUUID().toString(), "王五service无事务"+new Random().nextInt(10), "M"));
}

@Transactional(rollbackFor = Exception.class)
@Override
public void saveOneHasTransition() {
userMapper.save(new User(UUID.randomUUID().toString(), "ubuntuvim,service有事务"+new Random().nextInt(10), "M"));
}

@Override
public void saveUsersNoTransition() {
String id = UUID.randomUUID().toString();
userMapper.save(new User(UUID.randomUUID().toString(), "张三service无事务", "M"));
userMapper.save(new User(id, "张三2service无事务", "F"));
userMapper.save(new User(UUID.randomUUID().toString(), "张三3service无事务", "F"));
userMapper.save(new User(UUID.randomUUID().toString(), "张三4service无事务", "M"));
// 这个save的id和第二个相同会导致数据库id主键冲突报错,因为当前方法没有加事务不会回滚前面的save持久化
userMapper.save(new User(id, "张三5service无事务", "M"));
userMapper.save(new User(UUID.randomUUID().toString(), "张三6service无事务", "F"));
userMapper.save(new User(UUID.randomUUID().toString(), "张三7service无事务", "M"));
}

/**
* 由于此方法上添加了事务,即使在调用的userMapper.save()方法上也添加事务也会回滚。
* 但是如果dao的save方法的事务传播属性声明为propagation = Propagation.REQUIRES_NEW则无法回滚,在dao层已经提交了事务。service层回滚不了了。
*
*/
@Transactional(rollbackFor = Exception.class)
@Override
public void saveUsersHasTransition() {

String id = UUID.randomUUID().toString();
userMapper.save(new User(UUID.randomUUID().toString(), "李四service有事务", "F"));
userMapper.save(new User(id, "李四2service有事务", "F"));
userMapper.save(new User(UUID.randomUUID().toString(), "李四3service有事务", "F"));
userMapper.save(new User(UUID.randomUUID().toString(), "李四4service有事务", "M"));
/*
@Transactional(rollbackFor = Exception.class)
这个save的id和第二个相同会导致数据库id主键冲突报错,但是当前方法加了事务会从异常这个回滚前面的save
最终结果是这个方法内的save都不会持久化
*/
userMapper.save(new User(id, "张三5service有事务", "M"));
userMapper.save(new User(UUID.randomUUID().toString(), "李四6service有事务", "M"));
userMapper.save(new User(UUID.randomUUID().toString(), "李四7service有事务", "F"));

}
}

service调用dao的方法。

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
package com.ubuntuvim.mybatis.dao;

import com.ubuntuvim.mybatis.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
* @Author: ubuntuvim
* @Date: 2020/8/2 20:54
*/
public interface UserMapper {

@Select("select * from user t where t.name = #{name}")
User getUser(User user);

/**
* 保存user,id是唯一的,否则insert会报错
* REQUIRED :如果当前存在事务,则加入该事务;如果当前没有事务,则创建一个新的事务。==> 会跟随service层方法回滚事务
* SUPPORTS :如果当前存在事务,则加入该事务;如果当前没有事务,则以非事务的方式继续运行。==> 会跟随service层方法回滚事务
* MANDATORY :如果当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。==> 会跟随service层方法回滚事务
* REQUIRES_NEW :创建一个新的事务,如果当前存在事务,则把当前事务挂起。 ==> 即使service层的方法也加了事务,也无法回滚dao层的事务(内层已经提交了,外层回滚个屁啊)。
* NOT_SUPPORTED :以非事务方式运行,如果当前存在事务,则把当前事务挂起。 ==> 即使service层的方法也加了事务,也无法回滚dao层的事务(内层已经提交了,外层回滚个屁啊)。
* NEVER :以非事务方式运行,如果当前存在事务,则抛出异常。 ==> service层无事务的方法可以运行,也就是说,他只能被一个父事务调用。否则,他就要抛出异常。
* NESTED :如果当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;如果当前没有事务,则该取值等价于 REQUIRED
* @param user
*/
@Transactional(rollbackFor = Exception.class, propagation = Propagation.NESTED)
@Insert("insert into user(id, name, sex) value (#{id}, #{name}, #{sex})")
void save(User user);
}

测试类:

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
package com.ubuntuvim.mybatis.service;

import javax.annotation.Resource;

import com.ubuntuvim.mybatis.MybatisTest;
import org.junit.Test;
import org.junit.runner.RunWith;

import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
* UserServiceImpl Tester.
*
* @author <Authors name>
* @since <pre>9月 8, 2020</pre>
* @version 1.0
*/
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MybatisTest.class)
public class UserServiceImplTest {

@Resource
UserService userServiceImpl;

@Test
public void testSaveUsersNoTransition() throws Exception {
userServiceImpl.saveUsersNoTransition();
}

@Test
public void testSaveUsersHasTransition() throws Exception {
userServiceImpl.saveUsersHasTransition();
}

@Test
public void testSaveOneNoTransation() {
userServiceImpl.saveOneNoTransition();
}

@Test
public void testSaveOneHasTransation() {
userServiceImpl.saveOneHasTransition();
}
}