Spring事务处理

作者: 执笔弄风月 | 来源:发表于2017-10-07 17:43 被阅读0次

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

事务	说明
org.springframework.jdbc.datasource.DataSourceTranasactionManager	使用Spring JDBC或Mybatis进行持久化数据时使用
org.springframework.hibernate3.HibernateTransactionManager	使用Hibernate3.0版本进行持久化数据时使用
org.springframework.orm.jpa.JpaTransactionManager	使用JPA进行持久化时使用
org.springframework.jdo,JdoTransactionManager	当持久化机制是Jdo时使用
org.springframework.transaction.jta.JtaTransactionManager	使用一个JTA实现来管理事务，在一个事务跨越多个资源时使用

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

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

事务隔离级别

隔离级别	含义
DEFAULT	使用后端数据库默认的隔离级别（Spring中的选择项）
READ_UNCOMMITED	允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读
READ_COMMITED	允许在并发事件已经提交后读取，可防止脏读，但幻读和不可重复读仍可发生
REPEATABLE_READ	对相同字段的多次读取是一致的，除非数据呗事务本身改变，可防止脏、不可重复读，但幻读仍可能发生
SERIALIZABLE	完全服从ACID的隔离级别，确保不发生脏，幻，不可重复读，这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的

如果选择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

Spring事务处理

1. 事务基础

1.1 什么是事务

1.2 事务的特性

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

1.3.1 丢失修改

1.3.2 不可重复读

1.3.3 读脏数据

1.3.4 幻读

1.4 事务管理器PlatformTransactionManager

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

1.6 事务传播行为

2.Spring事务代理

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

Spring