Spring中的事务传播属性详解
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring中的事务传播属性详解相关的知识，希望对你有一定的参考价值。
参考技术A在使用Spring时 大部分会用到他的声明式事务 简单的在配置文件中进行一些规则配置 利用Spring的AOP功能就能轻松搞定事务问题 这里面就涉及到一个事务的传播属性问题Propagation 它在TransactionDefinition接口中定义 以供PlatfromTransactionManager使用 PlatfromTransactionManager是spring事务管理的核心接口
TransactionDefinition
public interface TransactionDefinition
int getPropagationBehavior();
int getIsolationLevel();
int getTimeout();
boolean isReadOnly();
getTimeout()方法 它返回事务必须在多少秒内完成
isReadOnly() 事务是否只读 事务管理器能够根据这个返回值进行优化 确保事务是只读的
getIsolationLevel()方法返回事务的隔离级别 事务管理器根据它来控制另外一个事务可以看到本事务内的哪些数据
在TransactionDefinition接口中定义了五个不同的事务隔离级别 ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别 使用数据库默认的事务隔离级别 另外四个与JDBC的隔离级别相对应 ISOLATION_READ_UNMITTED 这是事务最低的隔离级别 它充许别外一个事务可以看到这个事务未提交的数据 这种隔离级别会产生脏读 不可重复读和幻像读
在TransactionDefinition接口 *** 有 种选项可用
PROPAGATION_REQUIRED 支持当前事务 如果当前没有事务 就新建一个事务 这是最常见的选择
PROPAGATION_SUPPORTS 支持当前事务 如果当前没有事务 就以非事务方式执行
PROPAGATION_MANDATORY 支持当前事务 如果当前没有事务 就抛出异常
PROPAGATION_REQUIRES_NEW 新建事务 如果当前存在事务 把当前事务挂起
PROPAGATION_NOT_SUPPORTED 以非事务方式执行操作 如果当前存在事务 就把当前事务挂起
PROPAGATION_NEVER 以非事务方式执行 如果当前存在事务 则抛出异常
PROPAGATION_NESTED 支持当前事务 新增Savepoint点 与当前事务同步提交或回滚
现在结合一个实例 应用以上各种传播属性来进行说明 首先声明两个bean ServiceA和ServiceB 其中ServiceB被引用
ServiceA
void methodA()
thodB();
ServiceB
void methodB()
接下来 我们就一一分析下
PROPAGATION_REQUIRED
加入当前正要执行的事务不在另外一个事务里 那么就起一个新的事务 比如说 thodB的事务级别定义为PROPAGATION_REQUIRED 那么由于执行thodA的时候 thodA已经起了事务 这时调用thodB thodB看到自己已经运行在thodA 的事务内部 就不再起新的事务 而假如thodA运行的时候发现自己没有在事务中 他就会为自己分配一个事务 这样 在thodA或者在thodB内的任何地方出现异常 事务都会被回滚 即使thodB的事务已经被 提交 但是thodA在接下来fail要回滚 thodB也要回滚
PROPAGATION_SUPPORTS
如果当前在事务中 即以事务的形式运行 如果当前不再一个事务中 那么就以非事务的形式运行
PROPAGATION_MANDATORY
必须在一个事务中运行 也就是说 他只能被一个父事务调用 否则 他就要抛出异常
PROPAGATION_REQUIRES_NEW
比如我们设计thodA的事务级别为PROPAGATION_REQUIRED thodB的事务级别为PROPAGATION_REQUIRES_NEW 那么当执行到thodB的时候 thodA所在的事务就会挂起 thodB会起一个新的事务 等待thodB的事务完成以后 他才继续执行 他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了 因为thodB是新起一个事务 那么就是存在 两个不同的事务 如果thodB已经提交 那么thodA失败回滚 thodB是不会回滚的 如果thodB失败回滚 如果他抛出的异常被thodA捕获 thodA事务仍然可能提交
PROPAGATION_NOT_SUPPORTED
当前不支持事务 比如thodA的事务级别是PROPAGATION_REQUIRED 而thodB的事务级别是PROPAGATION_NOT_SUPPORTED 那么当执行到thodB时 thodA的事务挂起 而他以非事务的状态运行完 再继续thodA的事务
PROPAGATION_NEVER
不能在事务中运行 假设thodA的事务级别是PROPAGATION_REQUIRED 而thodB的事务级别是PROPAGATION_NEVER 那么thodB就要抛出异常了
PROPAGATION_NESTED
理解Nested的关键是savepoint 他与PROPAGATION_REQUIRES_NEW的区别是 PROPAGATION_REQUIRES_NEW另起一个事务 将会与他的父事务相互独立 而Nested的事务和他的父事务是相依的 他的提交是要等和他的父事务一块提交的 也就是说 如果父事务最后回滚 他也要回滚的 而Nested事务的好处也是他有一个savepoint
ServiceA
void methodA()
try
thodB();
catch (Exception e)
thodC();
lishixinzhi/Article/program/Java/ky/201311/28910
Spring事务传播行为详解（示例版）
内容来自: https://segmentfault.com/a/1190000013341344?utm_source=tag-newest
Spring中七种事务传播行为
| 事务传播行为类型 | 说明 |
|---|---|
| PROPAGATION_REQUIRED | 如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。这是最常见的选择。 |
| PROPAGATION_SUPPORTS | 支持当前事务，如果当前没有事务，就以非事务方式执行。 |
| PROPAGATION_MANDATORY | 使用当前的事务，如果当前没有事务，就抛出异常。 |
| PROPAGATION_REQUIRES_NEW | 新建事务，如果当前存在事务，把当前事务挂起。 |
| PROPAGATION_NOT_SUPPORTED | 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 |
| PROPAGATION_NEVER | 以非事务方式执行，如果当前存在事务，则抛出异常。 |
| PROPAGATION_NESTED | 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。 |
代码验证
文中代码以传统三层结构中两层呈现，即Service和Dao层，由Spring负责依赖注入和注解式事务管理，DAO层由Mybatis实现，你也可以使用任何喜欢的方式，例如，Hibernate,JPA,JDBCTemplate等。数据库使用的是MySQL数据库，你也可以使用任何支持事务的数据库，并不会影响验证结果。
首先我们在数据库中创建两张表：
user1
CREATE TABLE `user1` (
`id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(45) NOT NULL DEFAULT '',
PRIMARY KEY(`id`)
)
ENGINE = InnoDB;user2
CREATE TABLE `user2` (
`id` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`name` VARCHAR(45) NOT NULL DEFAULT '',
PRIMARY KEY(`id`)
)
ENGINE = InnoDB;然后编写相应的Bean和DAO层代码：
User1
public class User1
private Integer id;
private String name;
//get和set方法省略...
User2
public class User2
private Integer id;
private String name;
//get和set方法省略...
User1Mapper
public interface User1Mapper
int insert(User1 record);
User1 selectByPrimaryKey(Integer id);
//其他方法省略...
User2Mapper
public interface User2Mapper
int insert(User2 record);
User2 selectByPrimaryKey(Integer id);
//其他方法省略...
最后也是具体验证的代码由service层实现，下面我们分情况列举。
1.PROPAGATION_REQUIRED
我们为User1Service和User2Service相应方法加上Propagation.REQUIRED属性。
User1Service方法：
@Service
public class User1ServiceImpl implements User1Service
//省略其他...
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequired(User1 user)
user1Mapper.insert(user);
User2Service方法：
@Service
public class User2ServiceImpl implements User2Service
//省略其他...
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequired(User2 user)
user2Mapper.insert(user);
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequiredException(User2 user)
user2Mapper.insert(user);
throw new RuntimeException();
1.1 场景一
此场景外围方法没有开启事务。
验证方法1：
@Override
public void notransaction_exception_required_required()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequired(user2);
throw new RuntimeException();
验证方法2：
@Override
public void notransaction_required_required_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiredException(user2);
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”、“李四”均插入。 | 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。 |
| 2 | “张三”插入，“李四”未插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。 |
结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
1.2 场景二
外围方法开启事务，这个是使用率比较高的场景。
验证方法1：
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_exception_required_required()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequired(user2);
throw new RuntimeException();
验证方法2：
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_required_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiredException(user2);
验证方法3：
@Transactional
@Override
public void transaction_required_required_exception_try()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
try
user2Service.addRequiredException(user2);
catch (Exception e)
System.out.println("方法回滚");
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，外围方法回滚，内部方法也要回滚。 |
| 2 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，外围方法感知异常致使整体事务回滚。 |
| 3 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部方法加入外围方法事务，内部方法抛出异常回滚，即使方法被catch不被外围方法感知，整个事务依然回滚。 |
结论： 以上试验结果我们证明在外围方法开启事务的情况下Propagation.REQUIRED修饰的内部方法会加入到外围方法的事务中，所有Propagation.REQUIRED修饰的内部方法和外围方法均属于同一事务，只要一个方法回滚，整个事务均回滚。
2.PROPAGATION_REQUIRES_NEW
我们为User1Service和User2Service相应方法加上Propagation.REQUIRES_NEW属性。
User1Service方法：
@Service
public class User1ServiceImpl implements User1Service
//省略其他...
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNew(User1 user)
user1Mapper.insert(user);
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void addRequired(User1 user)
user1Mapper.insert(user);
User2Service方法：
@Service
public class User2ServiceImpl implements User2Service
//省略其他...
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNew(User2 user)
user2Mapper.insert(user);
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addRequiresNewException(User2 user)
user2Mapper.insert(user);
throw new RuntimeException();
2.1 场景一
外围方法没有开启事务。
验证方法1：
@Override
public void notransaction_exception_requiresNew_requiresNew()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequiresNew(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNew(user2);
throw new RuntimeException();
验证方法2：
@Override
public void notransaction_requiresNew_requiresNew_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequiresNew(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNewException(user2);
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”插入，“李四”插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,外围方法抛出异常回滚不会影响内部方法。 |
| 2 | “张三”插入，“李四”未插入 | 外围方法没有开启事务，插入“张三”方法和插入“李四”方法分别开启自己的事务，插入“李四”方法抛出异常回滚，其他事务不受影响。 |
结论：通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
2.2 场景二
外围方法开启事务。
验证方法1：
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_exception_required_requiresNew_requiresNew()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNew(user2);
User2 user3=new User2();
user3.setName("王五");
user2Service.addRequiresNew(user3);
throw new RuntimeException();
验证方法2：
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_requiresNew_requiresNew_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNew(user2);
User2 user3=new User2();
user3.setName("王五");
user2Service.addRequiresNewException(user3);
验证方法3：
@Override
@Transactional(propagation = Propagation.REQUIRED)
public void transaction_required_requiresNew_requiresNew_exception_try()
User1 user1=new User1();
user1.setName("张三");
user1Service.addRequired(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addRequiresNew(user2);
User2 user3=new User2();
user3.setName("王五");
try
user2Service.addRequiresNewException(user3);
catch (Exception e)
System.out.println("回滚");
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”未插入，“李四”插入，“王五”插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中，外围方法抛出异常只回滚和外围方法同一事务的方法，故插入“张三”的方法回滚。 |
| 2 | “张三”未插入，“李四”插入，“王五”未插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入 “王五”方法的事务被回滚，异常继续抛出被外围方法感知，外围方法事务亦被回滚，故插入“张三”方法也被回滚。 |
| 3 | “张三”插入，“李四”插入，“王五”未插入。 | 外围方法开启事务，插入“张三”方法和外围方法一个事务，插入“李四”方法、插入“王五”方法分别在独立的新建事务中。插入“王五”方法抛出异常，首先插入“王五”方法的事务被回滚，异常被catch不会被外围方法感知，外围方法事务不回滚，故插入“张三”方法插入成功。 |
结论： 在外围方法开启事务的情况下Propagation.REQUIRES_NEW修饰的内部方法依然会单独开启独立事务，且与外部方法事务也独立，内部方法之间、内部方法和外部方法事务均相互独立，互不干扰。
3.PROPAGATION_NESTED
我们为User1Service和User2Service相应方法加上Propagation.NESTED属性。
User1Service方法：
@Service
public class User1ServiceImpl implements User1Service
//省略其他...
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNested(User1 user)
user1Mapper.insert(user);
User2Service方法：
@Service
public class User2ServiceImpl implements User2Service
//省略其他...
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNested(User2 user)
user2Mapper.insert(user);
@Override
@Transactional(propagation = Propagation.NESTED)
public void addNestedException(User2 user)
user2Mapper.insert(user);
throw new RuntimeException();
3.1 场景一
此场景外围方法没有开启事务。
验证方法1：
@Override
public void notransaction_exception_nested_nested()
User1 user1=new User1();
user1.setName("张三");
user1Service.addNested(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addNested(user2);
throw new RuntimeException();
验证方法2：
@Override
public void notransaction_nested_nested_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addNested(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addNestedException(user2);
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”、“李四”均插入。 | 外围方法未开启事务，插入“张三”、“李四”方法在自己的事务中独立运行，外围方法异常不影响内部插入“张三”、“李四”方法独立的事务。 |
| 2 | “张三”插入，“李四”未插入。 | 外围方法没有事务，插入“张三”、“李四”方法都在自己的事务中独立运行,所以插入“李四”方法抛出异常只会回滚插入“李四”方法，插入“张三”方法不受影响。 |
结论： 通过这两个方法我们证明了在外围方法未开启事务的情况下Propagation.NESTED和Propagation.REQUIRED作用相同，修饰的内部方法都会新开启自己的事务，且开启的事务相互独立，互不干扰。
3.2 场景二
外围方法开启事务。
验证方法1：
@Transactional
@Override
public void transaction_exception_nested_nested()
User1 user1=new User1();
user1.setName("张三");
user1Service.addNested(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addNested(user2);
throw new RuntimeException();
验证方法2：
@Transactional
@Override
public void transaction_nested_nested_exception()
User1 user1=new User1();
user1.setName("张三");
user1Service.addNested(user1);
User2 user2=new User2();
user2.setName("李四");
user2Service.addNestedException(user2);
验证方法3：
@Transactional
@Override
public void transaction_nested_nested_exception_try()
User1 user1=new User1();
user1.setName("张三");
user1Service.addNested(user1);
User2 user2=new User2();
user2.setName("李四");
try
user2Service.addNestedException(user2);
catch (Exception e)
System.out.println("方法回滚");
分别执行验证方法，结果：
| 验证方法序号 | 数据库结果 | 结果分析 |
|---|---|---|
| 1 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，外围方法回滚，内部方法也要回滚。 |
| 2 | “张三”、“李四”均未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，内部方法抛出异常回滚，且外围方法感知异常致使整体事务回滚。 |
| 3 | “张三”插入、“李四”未插入。 | 外围方法开启事务，内部事务为外围事务的子事务，插入“张三”内部方法抛出异常，可以单独对子事务回滚。 |
结论： 以上试验结果我们证明在外围方法开启事务的情况下Propagation.NESTED修饰的内部方法属于外部事务的子事务，外围主事务回滚，子事务一定回滚，而内部子事务可以单独回滚而不影响外围主事务和其他子事务
- REQUIRED,REQUIRES_NEW,NESTED异同
由“1.2 场景二”和“3.2 场景二”对比，我们可知：
NESTED和REQUIRED修饰的内部方法都属于外围方法事务，如果外围方法抛出异常，这两种方法的事务都会被回滚。但是REQUIRED是加入外围方法事务，所以和外围事务同属于一个事务，一旦REQUIRED事务抛出异常被回滚，外围方法事务也将被回滚。而NESTED是外围方法的子事务，有单独的保存点，所以NESTED方法抛出异常被回滚，不会影响到外围方法的事务。
由“2.2 场景二”和“3.2 场景二”对比，我们可知：
NESTED和REQUIRES_NEW都可以做到内部方法事务回滚而不影响外围方法事务。但是因为NESTED是嵌套事务，所以外围方法回滚之后，作为外围方法事务的子事务也会被回滚。而REQUIRES_NEW是通过开启新的事务实现的，内部事务和外围事务是两个事务，外围事务回滚不会影响内部事务。
以上是关于Spring中的事务传播属性详解的主要内容，如果未能解决你的问题，请参考以下文章