1. 事务基础

1.1 什么是事务

所谓事务就是用户定义的一个数据库操作序列，这些操作要么全做，要么全不做，是一个不可分割的工作单位。

1.2 事务的特性

原子性：事务以原子为工作单位。对于数据修改，要么全做，要么全不做。
一致性：事务在完成时，必须使所有的数据都保持一致状态，以保持所有数据的完整性。
隔离性：一个事务的执行不能被其他事务干扰，寄一个事务的内部操作以及使用的数据对其他并发事务是隔离的。
持续性：一个事务一旦提交，它对数据库中数据的改变是永久性的。

1.3 事务并发操作带来的问题

1.3.1 丢失修改

两个事务T1和T2读入同一个数据并修改，T2提交的结果破坏了T1提交的结果，导致T1的修改被丢失。

1.3.2 不可重复读

事务T1读取数据后，事务T2执行更新操作，使得T1无法再现前一次读到的结果。
事务T1读取某一数据后，T2对其做了修改，当T1再次读该数据后，得到与前一不同的值

1.3.3 读脏数据

T1修改某一个数据并将其写会磁盘，事务T2读到T1修改之后的数据，这时T1由于某种原因被撤销，数据恢复到原来的值，T1读到的数据为脏数据。

1.3.4 幻读

按一定条件从数据库中读取了某些记录后，T2删除了其中部分记录，当T1再次按相同条件读取数据时，发现某些记录消失。
T1按一定条件从数据库中读取某些数据记录后，T2插入了一些记录，当T1再次按相同条件读取数据时，发现多了一些记录

1.4 事务管理器PlatformTransactionManager

Spring为不同的持久化框架提供了不同的PlatformTransacetionManager

1.5 TransacrionDefinition事务定义信息（隔离，传播，超时，只读）

事务设置隔离级别可以防止并发导致的问题

事务隔离级别

如果选择DEFAULT则是数据库默认的隔离级别。

mysql 默认REPEATABLE_READ

oracle 默认READ_COMMITTED

1.6 事务传播行为

PROPAGATION_REQUIRED -- 支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS -- 支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY -- 支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW -- 新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED -- 以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER -- 以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED -- 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

前六个策略类似于EJB CMT，第七个（PROPAGATION_NESTED）是Spring所提供的一个特殊变量。

它要求事务管理器或者使用JDBC 3.0 Savepoint API提供嵌套事务行为（如Spring的DataSourceTransactionManager）

PROPAGATION_REQUIRED 两个事务一定一起执行

PROPAGATION_REQUIRES_NEW 两个事务一定不一起执行

PROPAGATION_NESTED 设置savepoint

PROPAGATION_REQUIRES_NEW启动一个新的，不依赖于环境的“内部”事务。这个事务将被完全commited或rolled back而不依赖于外部事务，它拥有自己的隔离范围，自己的锁等等。当内部事务开始执行时，外部事务将被挂起，内部事务结束后，外部事务将继续执行。

另一方面，PROPAGATION_NESTED开始一个“嵌套的”事务，它是已经存在事务的一个真正的子事务，嵌套事务开始执行时，它将取得一个savepoint。如果这个嵌套事务失败，我们将回滚到此savepoint。嵌套事务是外部事务的一部分，只有外部事务结束后它才会被提交。

二者最大区别是：PROPAGATION_REQUIRES_NEW完全是一个新的事务，PROPAGATION_NESTED是一个已存在的外部事务的子事务，受外部事务影响，如果外部事务commit或rollback，嵌套事务也会被commit或rollback。

外部事务利用嵌套事务的savepoint特性

ServiceA {
    /**
    *事务属性配置为PROPAGATION_REQUIRES
    */
    void methodA() {
        ServiceB.methodB();
    }
}

ServiceB {
    /**
    *事务属性配置为PROPAGATION_REQUIRES_NEW
    */
    void methodB() {
    }
}

这种情况下, 因为 ServiceB#methodB 的事务属性为 PROPAGATION_REQUIRES_NEW, 所以两者不会发生任何关系, ServiceA#methodA 和 ServiceB#methodB 不会因为对方的执行情况而影响事务的结果, 因为它们根本就是两个事务, 在 ServiceB#methodB 执行时 ServiceA#methodA 的事务已经挂起了。

ServiceA {        
    /** 
     * 事务属性配置为 PROPAGATION_REQUIRED 
     */  
    void methodA() {  
        ServiceB.methodB();  
    }   
}  
  
ServiceB {        
    /** 
     * 事务属性配置为 PROPAGATION_NESTED 
     */   
    void methodB() {  
    }   
}

现在的情况就变得比较复杂了, ServiceB#methodB 的事务属性被配置为 PROPAGATION_NESTED, 此时两者之间又将如何协作呢? 从 Juergen Hoeller 的原话中我们可以找到答案, ServiceB#methodB 如果 rollback, 那么内部事务(即 ServiceB#methodB) 将回滚到它执行前的 SavePoint(注意, 这是本文中第一次提到它, 潜套事务中最核心的概念), 而外部事务(即 ServiceA#methodA) 可以有以下两种处理方式:

1. 改写 ServiceA 如下

ServiceA {        
    /** 
     * 事务属性配置为 PROPAGATION_REQUIRED 
     */  
    void methodA() {  
        try {  
            ServiceB.methodB();  
        } catch (SomeException) {  
            // 执行其他业务, 如 ServiceC.methodC();  
        }  
    }   
}

这种方式也是潜套事务最有价值的地方, 它起到了分支执行的效果, 如果 ServiceB.methodB 失败, 那么执行 ServiceC.methodC(), 而 ServiceB.methodB 已经回滚到它执行之前的 SavePoint, 所以不会产生脏数据(相当于此方法从未执行过), 这种特性可以用在某些特殊的业务中, 而 PROPAGATION_REQUIRED 和 PROPAGATION_REQUIRES_NEW 都没有办法做到这一点。

2.代码不做任何修改

那么如果内部事务(即 ServiceB#methodB) rollback, 那么首先 ServiceB.methodB 回滚到它执行之前的 SavePoint(在任何情况下都会如此), 外部事务(即 ServiceA#methodA) 将根据具体的配置决定自己是 commit 还是 rollback (+MyCheckedException)。

2.Spring事务代理

拦截器先创建一个TransactionInfo 对象：

TransactionInfo txInfo = new TransactionInfo(txAttr, method);

只要被调用的方法设置了事务属性(txAttr),不管是什么属性都会调用:

txInfo.newTransactionStatus(this.transactionManager.getTransaction(txAttr));

根据该方法的事务属性(definition )的不同,this.transactionManager.getTransaction(txAttr)的返回值会有所不同(代码见AbstractPlatformTransactionManager),具体为以下几种情况:

1.当前没有事务时(即以下代码中的((HibernateTransactionObject) transaction).hasTransaction()返回false),会返回以下几种:

//检查新事务的定义设置
  if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
   throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
  }
 
  // 找不到现有的事务 - >检查传播行为，以了解如何行为。
  if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
   throw new IllegalTransactionStateException(
     "Transaction propagation 'mandatory' but no existing transaction found");
  }
  else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
    definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
      definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
   if (debugEnabled) {
    logger.debug("Creating new transaction with name [" + definition.getName() + "]");
   }
   doBegin(transaction, definition);
   boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);
   return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);
  }
  else {
   // 创建“空”事务：没有实际的事务，但潜在的同步
   boolean newSynchronization = (this.transactionSynchronization == SYNCHRONIZATION_ALWAYS);
   return newTransactionStatus(definition, null, false, newSynchronization, debugEnabled, null);
  }

2.当前有事务时

/** 
 * 为现有事务创建一个TransactionStatus 
 */  
private TransactionStatus handleExistingTransaction(  
        TransactionDefinition definition, Object transaction, boolean debugEnabled)  
        throws TransactionException {  
  
   ... 
  
    if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {  
        if (!isNestedTransactionAllowed()) {  
            throw new NestedTransactionNotSupportedException(  
                    "Transaction manager does not allow nested transactions by default - " +  
                    "specify 'nestedTransactionAllowed' property with value 'true'");  
        }  
        if (debugEnabled) {  
            logger.debug("Creating nested transaction with name [" + definition.getName() + "]");  
        }  
        if (useSavepointForNestedTransaction()) {  
            // 在现有的Spring管理事务中创建保存点
            // 通过TransactionStatus实现的SavepointManager API
            // 通常使用JDBC 3.0保存点。不激活Spring同步
            DefaultTransactionStatus status =  
                    newTransactionStatus(definition, transaction, false, false, debugEnabled, null);  
            status.createAndHoldSavepoint();  
            return status;  
        }  
        else {  
            //嵌套事务通过嵌套的开始和提交/回滚调用  
            // 通常仅适用于JTA：Spring同步可能会在此处激活  
            // 在预先存在的JTA事务中。
            doBegin(transaction, definition);  
            boolean newSynchronization = (this.transactionSynchronization != SYNCHRONIZATION_NEVER);  
            return newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, null);  
        }  
    }  
} 

最后，txInfo被绑定到当前线程上作为当前事务：

txInfo.bindToThread（）

然后，调用实际的目标类的方法并捕捉异常：

 try {
    // This is an around advice.
    // Invoke the next interceptor in the chain.
    // This will normally result in a target object being invoked.
    retVal = invocation.proceed();
   }
   catch (Throwable ex) {
    // target invocation exception
    doCloseTransactionAfterThrowing(txInfo, ex);
    throw ex;
   }
   finally {
    doFinally(txInfo);
   }
   doCommitTransactionAfterReturning(txInfo);
   return retVal;
  }

另外一点,TransactionInfo的newTransactionStatus调用时如果参数的不是null,TransactionInfo.hasTransaction()方法返回true;

重要提示:
在spring中创建的事务代理类并是目标类的超类,只是一个实现这目标类接口的类,该类会调用目标类的方法,所在如果一个目标类中的方法调用自身的另一个事务方法,另一个方法只是作为普通方法来调用,并不会加入事务机制

如果要使用PROPAGATION_NESTED
1.设置 transactionManager 的 nestedTransactionAllowed 属性为 true, 注意, 此属性默认为 false
再看 AbstractTransactionStatus的createAndHoldSavepoint() 方法

/** 
 * Create a savepoint and hold it for the transaction. 
 * @throws org.springframework.transaction.NestedTransactionNotSupportedException 
 * if the underlying transaction does not support savepoints 
 */  
public void createAndHoldSavepoint() throws TransactionException {  
    setSavepoint(getSavepointManager().createSavepoint());  
}  

可以看到 Savepoint 是 SavepointManager.createSavepoint 实现的, 再看 SavepointManager 的层次结构, 发现 其 Template 实现是 JdbcTransactionObjectSupport, 常用的 DatasourceTransactionManager, HibernateTransactionManager 中的 TransactonObject 都是它的子类
JdbcTransactionObjectSupport 告诉我们必须要满足两个条件才能 createSavepoint :
2. java.sql.Savepoint 必须存在, 即 jdk 版本要 1.4+

3.Connection.getMetaData().supportsSavepoints() 必须为 true, 即 jdbc drive 必须支持 JDBC 3.0 确保以上条件都满足后, 你就可以尝试使用 PROPAGATION_NESTED 了

参考资料：
1.http://www.iteye.com/topic/35907
2.Spring源代码https://docs.spring.io/spring/docs/current/javadoc-api/
3.百度百科https://baike.baidu.com/item/数据库事务/9744607?fr=aladdin