事务传播

前言：事务传播行为是Spring框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。该篇文章本该放在srping文集下，但为了和mysql事务关联密切，故放此文集下。
多数转载自：https://blog.csdn.net/soonfly/article/details/70305683

一、总述

定义：事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。
例如：methodA事务方法调用methodB事务方法时，methodB是继续在调用者methodA的事务中运行呢，还是为自己开启一个新事务运行，这就是由methodB的事务传播行为决定的。

七种传播行为如下：

image.png

---

二、详述

以下内容，暂时不考虑AOP和各层之间如何控制事务传播。单纯的就是俩方法间如何传播事务。

2.1 PROPAGATION_REQUIRED required

• 定义：表示当前方法必须运行在事务中。如果存在一个事务，则支持当前事务。如果没有事务则开启一个新的事务。最常用的事务传播行为。

image.png

• 举例：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
 methodB();
}
@Transactional(propagation = Propagation.REQUIRED)
public void methodB() {
}

1. 单独调用methodB方法时，因为当前上下文不存在事务，所以会开启一个新的事务。或者调用方法B的方法未设置事务，则调用B时会开启新事务。
2. 调用methodA方法时，因为当前上下文不存在事务，所以会开启一个新的事务。当执行到methodB时，methodB发现当前上下文有事务，因此就加入到当前事务中来。

2.2 PROPAGATION_SUPPORTS supports

• 定义：如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行。但是对于事务同步的事务管理器，PROPAGATION_SUPPORTS与不使用事务有少许不同。
• 举例

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
 methodB();
}
// 事务属性为SUPPORTS
@Transactional(propagation = Propagation.SUPPORTS)
public void methodB() {
}

1. 单纯的调用methodB时，methodB方法是非事务的执行的。当调用methdA时,methodB则加入了methodA的事务中,事务地执行。
2. supports和required区别在于，上下文不存在事务时，是否会创建事务。若存在事务，两者都会融入到该事务中。
3. supports与不使用事务有少许不同，不同点在于不使用事务不管上下文有没有事务，都不会以事务运行。supports至少在上下文存在事务时，融入事务。

2.3 PROPAGATION_MANDATORY mandatory

• 定义：如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
• 举例：

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

1. 当单独调用methodB时，因为当前没有一个活动的事务，则会抛出异常throw new IllegalTransactionStateException(“Transaction propagation ‘mandatory’ but no existing transaction found”);
2. 当调用methodA时，methodB则加入到methodA的事务中，事务地执行。
3. 同以上两个事务传播行为，共同点很明显-会融入上下文的事务中，区别为上下文不存在事务时，该方法被调用时会抛出异常。

2.4 PROPAGATION_REQUIRED_NEW requiredNew

• 定义：它会开启一个新的事务。如果一个事务已经存在，则先将这个存在的事务挂起。
• 特性：使用PROPAGATION_REQUIRES_NEW,需要使用 JtaTransactionManager作为事务管理器。
• 举例：

@Transactional(propagation = Propagation.REQUIRED)
public void methodA() {
methodB();
}
// 事务属性为REQUIRES_NEW
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() {
}

当调用方法A时，相当于执行了以下代码：

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(RunTimeException ex) {
            ts2.rollback();//回滚第二个事务
        } finally {
            //释放资源
        }
        //methodB执行完后，恢复第一个事务
        tm.resume(ts1);
        doSomeThingB();
        ts1.commit();//提交第一个事务
    } catch(RunTimeException ex) {
        ts1.rollback();//回滚第一个事务
    } finally {
        //释放资源
    }
}

1. 把ts1称为外层事务，ts2称为内层事务。从上面的代码可以看出，ts2与ts1是两个独立的事务，互不相干。
2. Ts2是否成功并不依赖于 ts1。如果methodA方法在调用methodB方法后的doSomeThingB方法失败了，而methodB方法所做的结果依然被提交。而除了 methodB之外的其它代码导致的结果却被回滚了。
3. requiredNew和required共同点为不存在事务时，都会创建事务，而不是非事务执行（supported）或者报异常（mandatory）。
4. 不同点在于required是融合事务，而requiredNew是挂起外层事务，执行内层事务。且内外事务无关联性，不要求具有原子性。
5. 比如bo方法内调用另外bo的方法，但原则上是会融合事务，失败会导致一起回滚。现在我想被调用的bo方法执行完即提交，个人感觉可以用这个传播行为。

2.5 PROPAGATION_NOT_SUPPORTED notSupported

• 定义：PROPAGATION_NOT_SUPPORTED总是非事务地执行，并挂起任何存在的事务。
• 特性：使用PROPAGATION_NOT_SUPPORTED,也需要使用JtaTransactionManager作为事务管理器。

1. supported为存在上下文事务即融合，不存在则非事务运行。
2. notSupported为存在上下文事务时挂起外层事务，并非事务运行。不存在亦是非事务运行。

2.6 PROPAGATION_NEVER never

• 定义：总是非事务地执行，如果存在一个活动事务，则抛出异常。
• 区别：

1. mandatory为如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。

2.7 PROPAGATION_NESTED nested

• 定义：如果一个活动的事务存在，则运行在一个嵌套的事务中。 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行。
• 特性：
  1. 这是一个嵌套事务,使用JDBC 3.0驱动时,仅仅支持
  2. DataSourceTransactionManager作为事务管理器。
  3. 需要JDBC 驱动的java.sql.Savepoint类。使用PROPAGATION_NESTED，还需要把PlatformTransactionManager的nestedTransactionAllowed属性设为true(属性值默认为false)。
• 举例：如果单独调用methodB方法，则按REQUIRED属性执行。如果调用methodA方法，相当于下面的效果：

@Transactional(propagation = Propagation.REQUIRED)
methodA(){
  doSomeThingA();
  methodB();
  doSomeThingB();
}
@Transactional(propagation = Propagation.NEWSTED)
methodB(){
  ……
}
main(){
    Connection con = null;
    Savepoint savepoint = null;
    try{
        con = getConnection();
        con.setAutoCommit(false);
        doSomeThingA();
        savepoint = con2.setSavepoint();
        try{
            methodB();
        } catch(RuntimeException ex) {
            con.rollback(savepoint);
        } finally {
            //释放资源
        }
        doSomeThingB();
        con.commit();
    } catch(RuntimeException ex) {
        con.rollback();
    } finally {
        //释放资源
    }
}

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

遗留问题：

1. 每种事务传播行为的应用场景。-结合项目思考。
2. 当Spring的事务在同一个类时，它的自我调用时事务将失效？-代码验证。
3. spring声明式事务，了解常用配置方式后，思考同一bo内方法调用，不同bo方法调用，bo调dao，及bo同时调bo及dao。事务如何传播。