Spring 事务传播行为

一、PROPAGATION_REQUIRED

//事务属性是PROPAGATION_REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
methodA{
 methodB();
}
​

使用 spring 声明式事务，spring 使用 AOP 来支持声明式事务，会根据事务属性，自动在方法调用之间决定是否开启一个事务，并在方法执行之后决定事务提交或回滚事务。

单独调用 methodB 方法:

@Transactional(propagation = Propagation.REQUIRED)
main{
 methodB();
}
​

相当于

Main{
 Connection con = null;
 try{
 con = getConnection();
 con.setAutoCommit(false);
 //方法调用
 methodB();
 //提交事务
 con.commit();
 }catch(Exception e){
 con.rollback();
 }
}
​

Spring 保证在 methodB 方法中所有的调用都获得到一个相同的连接。在调用 methodB 时，没有一个存在的事务，所以获得一个新的连接，开启了一个新的事务。

第二个例子：

@Transaction(propagation = Propagation.REQUIRED)
methodA(){
 methodB();
}
@Transaction(propagation = Propagation.REQUIRED)
methodB(){
 // do somthing
}
​

单独调用 MethodA 时，在 MethodA 内又会调用 MethodB.

执行效果相当于:

main{
 Connection con = null;
 try{
 con = getConnection();
 methodA();
 con.commit();
 }catch(Exception e){
 con.rollback();
 }
}
​

调用 MethodA 时，环境中没有事务，所以开启一个新的事务。当在 MethodA 中调用 MethodB 时，环境中已经有一个事务，所以 methodB 就加入当前事务。

二、PROPAGATION_SUPPORTS 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。

//事务属性 PROPAGATION_REQUIRED
@Transaction(propagation = Propagation.REQUIRED)
methodA(){
 methodB();
}
//事务属性 PROPAGATION_SUPPORTS
@Transaction(propagation = Propagation.SUPPORTS)
methodB(){
 
}
​

单纯的调用 methodB 时，methodB 方法是非事务执行的。当调用 methodA 时，methodB 则加入了 methodA 的事务中，事务的执行。

三、PROPAGATION_MANDATORY 如果已经存在一个事务，支持当前事务。如果没有事务，则抛出异常。

​
@Transactional(propagation = Propagation.REQUIRED)
methodA(){
 methodB();
}
//事务属性MANDATORY
@Transactional(propagation = Propagation.MANDATORY)
methodB(){
  
}
​

当单独调用 methodB 时，因为当前没有一个活动的事务，则会抛出异常，当调用 methodA 时，methodB 则加入到 methodA 的事务中，事务地执行。

四、PROPAGATION_REQUIRES_NEW 总是开户一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。

//事务属性 PROPAGATION_REQUIRED
@Transactional(propagation = Propagation.REQUIRED)
methodA(){
 doSomeThingA();
 methodB();
 doSomeThingB();
}
//事务属性 PROPAGATION_REQUIRES_NEW
@Transactional(propagation = Propagation.REQUIRED_NEW)
methodB(){
 
}
​

调用 A 方法

main(){
 mehtodA();
}
​

相当于

main(){
 TransactionManager tm = null;
 try{
 //获得一个JTA事务管理器
 tm = getTransactionManager();
 tm.begin();//开户一个新的事务
 Transaction ts1 = tm.getTransaction();
 doSomeThing();
 tm.suspend();//挂起当前事务
 try{
 tm.begin();//重新开启第二个事务
 Transaction ts2 = tm.getTransaction();
  methodB();
  ts2.commit();//提交第二个事务
 }catch(Exception e){
 ts2.rollback();
 }
 tm.resume(ts1);
 doSomeThingB();
 ts1.commit();//提交第一个事务
 }catch(Exception e){
 ts1.rollback();
 }
}
​

在这，ts1 称为外层事务，ts2 称为内层事务。从上面的代码来看，ts2 与 ts1 是两个独立的事务，互不相干。ts2 是否成功并不依赖于 ts1。如果 methodA 方法在调用 methodB 方法后在 doSomeThingB 方法失败了，而 methodB 方法所做的结果依然被提交。而除了 methodB 之外的其他代码导致的结果去被回滚了。

五、PROPAGATION_NOT_SUPPORTED 总是非事务地执行，并挂起任何存在的事务。

六、PROPAGATION_NEVER 总是非事务地执行，如果存在一个活动事务，则抛出异常。

七、PROPAGATION_NESTED 如果一个活动的事务存在，则运行在一个嵌套的事务中，如果没有活动事务，则按 TransactionDefinition.PROPAGATION_REQUIRED 属性执行。

@Transctional(propagation = Propagetion.REQUIRED)
methodA(){
 doSomeThingA();
 methodB();
 doSomeThingB();
}
@Transctional(propagation = Propagation.NEWSTED)
methodB(){
 ....
}
​

如果单独调用 methodB 方法，则按 REQUIRED 属性执行。如果调用 methodA 方法相当于下面的效果：

main(){
 Connection con = null;
 Savepoint savepoint = null;
 try{
 con = getCoonnection();
 con.setAutoCommit(false);
 doSomeThingA();
 savepoint = con2.setSavepoint();
 try{
 methodB();
 }catch(RuntimeException ex){
 con.rollback(savepoint);
 }
 doSomeThingB();
 con.commit();
 }
}
​

当 methodB 方法调用之前，调用 setSavepoint 方法，保存当前的状态到 savepoint。如果 methodB 方法调用失败，则恢复到之前保存的状态。但是需要注意的是，这时的事务并没有进行提交，如果后续的代码(doSomeThingB())调用失败，则回滚包括 methodB 方法的所有操作。嵌套事务一个非常重要的概念就是内层事务依赖于外层事务。外层事务失败时，会回滚内层事务所做的动作。而内层事务操作失败并不会引起包层事务的回滚。