分布式事务【3】【Spring的事务抽象】

﹏ヽ暗。殇╰゛Y 2023-03-13 05:19 9阅读 0赞

>  *  [https://docs.spring.io/spring/docs/5.2.6.RELEASE/spring-framework-reference/data-access.html\#spring-data-tier][https_docs.spring.io_spring_docs_5.2.6.RELEASE_spring-framework-reference_data-access.html_spring-data-tier]
>  *  [https://docs.spring.io/spring-framework/docs/current/javadoc-api/][https_docs.spring.io_spring-framework_docs_current_javadoc-api]

# 1 Spring的事务抽象 #

>  *  PlatformTransactionManager // 事务管理器——主要用于平台相关事务的管理
>  *  TransactionDefinition //事务定义信息(隔离、传播、超时、只读)
>  *  TransactionStatus //事务具体运行状态——事务管理过程中，每个时间点事务的状态信息。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70][]

## 1.1 PlatformTransactionManager ##

//https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/PlatformTransactionManager.html
    public interface PlatformTransactionManager extends TransactionManager {
        //根据事务定义TransactionDefinition获取事务
        TransactionStatus getTransaction(TransactionDefinition var1);
        //提交事务
        void commit(TransactionStatus var1);
        //回滚事务
        void rollback(TransactionStatus var1);
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1][]

<table> 
 <thead> 
  <tr> 
   <th style="width:463px;">事务</th> 
   <th style="width:436px;">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="width:463px;">org.springframework.jdbc.datasource.<span style="color:#f33b45;"><strong>DataSourceTransactionManager</strong></span></td> 
   <td style="width:436px;">使用&nbsp;<span style="color:#f33b45;">Spring JDBC</span><span style="color:#f33b45;">&nbsp;</span>或&nbsp;<span style="color:#f33b45;">MyBatis&nbsp;</span>进行持久化数据时使用</td> 
  </tr> 
  <tr> 
   <td style="width:463px;">org.springframework.orm.hibernate5.<strong>HibernateTransactionManager</strong></td> 
   <td style="width:436px;">使用 <span style="color:#f33b45;">Hibernate5.0</span> 版本进行持久化数据时使用</td> 
  </tr> 
  <tr> 
   <td style="width:463px;">org.springframework.orm.jpa.<span style="color:#f33b45;"><strong>JpaTransactionManager</strong></span></td> 
   <td style="width:436px;">使用&nbsp;<span style="color:#f33b45;">JPA&nbsp;</span>进行持久化时使用</td> 
  </tr> 
  <tr> 
   <td style="width:463px;">org.springframework.jdo.<strong>JdoTransactionManager</strong></td> 
   <td style="width:436px;">当持久化机制是 <span style="color:#f33b45;">Jdo</span> 时使用</td> 
  </tr> 
  <tr> 
   <td style="width:463px;">org.springframework.transaction.jta.<span style="color:#f33b45;"><strong>JtaTransactionManager</strong></span></td> 
   <td style="width:436px;">使用一个<span style="color:#f33b45;">JTA实现</span>来管理事务，在一个事务跨越多个资源时必须使用</td> 
  </tr> 
 </tbody> 
</table>

## 1.2 TransactionDefinition   ##

> 事务的隔离级别是数据库本身的事务功能，事务的传播属性则是Spring为我们提供的功能

//https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/TransactionDefinition.html
    public interface TransactionDefinition {
        // 隔离级别 https://blog.csdn.net/qq_40794973/article/details/104057217
        // 默认隔离机制（和数据库保持一致）
        ISOLATION_DEFAULT
        // 读未提交
        ISOLATION_READ_UNCOMMITTED
        // 读已提交
        ISOLATION_READ_COMMITTED
        // 可重复读
        ISOLATION_REPEATABLE_READ
        // 线性读
        ISOLATION_SERIALIZABLE
        // 传播行为 https://blog.csdn.net/qq_40794973/article/details/97522518
        // 支持当前事务；如果A方法已经在事务中，则B事务将直接使用；否则将创建新事务（默认）
        PROPAGATION_REQUIRED
        // 支持当前事务；如果A方法已经在事务中，则B事务将直接使用；否则将以非事务状态执行
        PROPAGATION_SUPPORTS
        // 支持当前事务；如果A方法没有事务，则抛出异常
        PROPAGATION_MANDATORY
        // 将创建新的事务，如果A方法已经在事务中，则将A事务挂起
        PROPAGATION_REQUIRES_NEW
        // 不支持当前事务，总是以非事务状态执行；如果A方法已经在事务中，则将其挂起
        PROPAGATION_NOT_SUPPORTED
        // 不支持当前事务，如果A方法在事务中，则抛出异常
        PROPAGATION_NEVER
        // 嵌套事务，只对DataSourceTransactionManager有效，底层使用JDBC的SavePoint机制，允许在同一个事务设置保存点，回滚保存点
        PROPAGATION_NESTED
        //-------------------------------------------------------------------------
        // 获取事务的传播行为
        int getPropagationBehavior();
        // 获取事务的隔离级别
        int getIsolationLevel();
        // 获取事务的名字
        String getName();
        // 获取事务的超时时间 (事务的有效期)
        int getTimeout();
        // 事务是否是只读
        boolean isReadOnly();
    }

//org.springframework.transaction.support
    public class DefaultTransactionDefinition implements TransactionDefinition{
        //事务的传播属性为PROPAGATION_REQUIRED，即当前没有事务的时候创建一个，如果有则使用当前事务 
        private int propagationBehavior = PROPAGATION_REQUIRED;
        //事务的隔离级别采用底层数据库默认的隔离级别 
        private int isolationLevel = ISOLATION_DEFAULT;
        //超时时间采用底层数据库默认的超时时间
        private int timeout = TIMEOUT_DEFAULT;
        //是否只读为false
        private boolean readOnly = false;
        //...
    }

> **事务传播行为**用于解决两个被事务管理的方法互相调用问题；当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。‘
> 
>  *  有些时候需要处于同一个事务(例如商场工作人员删除订单业务，删除用户删除完成之后，需要同时删除用户对应的订单，哪一个环境出现问题了都需要事务回滚)
>  *  有些时候不能在同一个事务( 例如ATM取款业务，取款是一 个事务操作， 打印凭条是一个事务操作，打印凭条失败取款事务不能回滚，这也回滚不了鸭)

<table>  事务传播机制（ 
 <strong><span style="color:#86ca5e;">https://blog.csdn.net/qq_40794973/article/details/97522518</span> | </strong>https://www.jianshu.com/p/c8140591a2a1&nbsp; ）  
 <thead> 
  <tr> 
   <th> <p>传播属性</p> </th> 
   <th> <p>描述</p> </th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>REQUIRED</td> 
   <td> <p>如果有事务在运行，当前的方法就在这个事务内运行；否则就启动一个新的事务，并在自己的事务内运行（默认）</p> </td> 
  </tr> 
  <tr> 
   <td>REQUIRES_NEW</td> 
   <td>当前的方法必须启动新事务，并在它自己的事务内运行；如果有事务正在运行，应该将它挂起</td> 
  </tr> 
  <tr> 
   <td>SUPPORTS</td> 
   <td>如果有事务在运行，当前的方法就在这个事务内运行；否则它可以不运行在事务中</td> 
  </tr> 
  <tr> 
   <td>NOT_SUPPORTED</td> 
   <td>当前的方法不应该运行在事务中；如果有运行的事务，将它挂起</td> 
  </tr> 
  <tr> 
   <td>MANDATORY</td> 
   <td>当前的方法必须运行在事务内部；如果没有正在运行的事务，就抛出异常</td> 
  </tr> 
  <tr> 
   <td>NEVER</td> 
   <td>当前的方法不应该运行在事务中；如果有运行的事务，就抛出异常</td> 
  </tr> 
  <tr> 
   <td>NESTED&nbsp;</td> 
   <td>如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行；否则就启动一个新的事务，并在它自己的事务内运行</td> 
  </tr> 
 </tbody> 
</table>

## 1.3 TransactionStatus ##

//事务在运行中的状态
    //https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/transaction/TransactionStatus.html
    //TransactionStatus它继承了SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装
    //TransactionStatus本身更多存储的是事务的一些状态信息
    public interface TransactionStatus extends TransactionExecution, SavepointManager, Flushable {
        // 是否是新的事务
        boolean isNewTransaction();
        // 是否有恢复点
        boolean hasSavepoint();
        // 设置为只回滚事务（用于测试，只是验证逻辑，并不修改数据）
        void setRollbackOnly();
        // 是否为只回滚事务
        boolean isRollbackOnly();
        // 是否已完成
        boolean isCompleted();
    }

--------------------

# 2 在Spring中使用事务 #

> 默认不是所有异常都会发生回滚，只有unchecked exception回滚，检查时异常就不会回滚，需要在@Transactional里面手动设置
> 
> [https://www.cnblogs.com/tianyuchen/p/6678084.html][https_www.cnblogs.com_tianyuchen_p_6678084.html]

## 2.1 使用代码方式实现 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2][]

## 2.2 Transactional标签方式实现 ##

> 可以在类上加@Transactional标签对这个类所有方法统一设置，然后在方法上加@Transactional可以覆盖相同的设置

//javax.transaction.Transactional ×
    //org.springframework.transaction.annotation.Transactional √
    public @interface Transactional {
    	// 当在配置文件中有多个TransactionManager , 可以用该属性指定选择哪个事务管理器
    	@AliasFor("transactionManager")
    	String value() default "";
    	@AliasFor("value")
    	String transactionManager() default "";
    	// 事务的传播行为
    	Propagation propagation() default Propagation.REQUIRED;
    	// 事务的隔离级别
    	Isolation isolation() default Isolation.DEFAULT;
    	// 事务的超时时间
    	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    	// 指定事务是否为只读事务，默认值为false（为了忽略那些不需要事务的方法，比如读取数据，可以设置 read-only 为 true）
    	boolean readOnly() default false;
    	// 用于指定能够或不能够触发事务回滚的异常类型（多个逗号分隔）
    	Class<? extends Throwable>[] rollbackFor() default {};
    	String[] rollbackForClassName() default {};
    	Class<? extends Throwable>[] noRollbackFor() default {};
    	String[] noRollbackForClassName() default {};
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1][]

[https_docs.spring.io_spring_docs_5.2.6.RELEASE_spring-framework-reference_data-access.html_spring-data-tier]: https://docs.spring.io/spring/docs/5.2.6.RELEASE/spring-framework-reference/data-access.html#spring-data-tier
[https_docs.spring.io_spring-framework_docs_current_javadoc-api]: https://docs.spring.io/spring-framework/docs/current/javadoc-api/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70]: /images/20230312/2be7a205cf164cde89411ca6456d224b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 1]: /images/20230312/b70d4f3660d54b81820a7eb2758456fd.png
[https_www.cnblogs.com_tianyuchen_p_6678084.html]: https://www.cnblogs.com/tianyuchen/p/6678084.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNzk0OTcz_size_16_color_FFFFFF_t_70 2]: /images/20230312/1e997a8589174ec09f5688a369a1f403.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20230312/0f380883933b4eec9f81413735298b92.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly95dWFueXUuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20230312/1e47e8ad4f464548a6a24d4d00d6dbab.png