关于Spring的@Transaction注解说明

ゞ浴缸里的玫瑰 2022-01-27 15:49 279阅读 0赞

**数据库事务的几个特性：**

** 原子性(Atomicity )、一致性( Consistency )、隔离性或独立性( Isolation)和持久性(Durabilily)，简称就是ACID。**

**1：通常情况下，为保证一个service层的方法中执行多个非查询语句操作都会采用：**

> **![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70][]**
> 
> **使用  rollbackFor = Throwable.class 保证凡是抛出旗下子类的异常 ，都会进行回滚操作，因为Throwable 是一切异常类的父类：**
> 
> ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70 1][]

**2：在本地项目中，service层之间的方法调用情况：**

>  *        **当某service层中有两个方法A()    B() ，当方法A想要调用方法B时的标准事务一致性操作：**
> 
>     @Transactional(rollbackFor = Throwable.class) //
>         public void A() {
>             // TODO  代码略...
>             this.B();
>         }
>     
>         private void B() {
>         // TODO  代码略...
>         }
> 
>  （保证都在一个事务中，成功同时执行，异常则回滚。）
> 
>  
> 
>  *  **        当不同service层之间方法调用，则被调用的方法事务也还起作用，事务不太建议放到2个见service中。同一工程内，controller中调用第一个service声明了Transactional，service中再调用其他service中非声明的事务，如果遇到RunTimeException则还是事务回滚的，但是尽量使用事务的方法，都加上Transactional声明****：**
> 
> ![Center][]
> 
>  ![Center 1][]
> 
> ** **
> 
> Spring默认的传播行为是PROPAGATION\_REQUIRED，即如果当前存在事务，即加入该事务；如果当前没有事务，则新建一个新的事务。因此只开启了一个事务。
> 
>  
> 
> Spring事务的传播行为的7种类型
> 
>  *  TransactionDefinition.PROPAGATION\_REQUIRED：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。这是默认值。
>  *  TransactionDefinition.PROPAGATION\_REQUIRES\_NEW：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
>  *  TransactionDefinition.PROPAGATION\_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
>  *  TransactionDefinition.PROPAGATION\_NOT\_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
>  *  TransactionDefinition.PROPAGATION\_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常。
>  *  TransactionDefinition.PROPAGATION\_MANDATORY：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
>  *  TransactionDefinition.PROPAGATION\_NESTED：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于TransactionDefinition.PROPAGATION\_REQUIRED。
> 
> ** **

**3：当本地方法调用远程的执行方法时：**

*  **两阶段提交（2PC，不常用）：**

> 原理：在数据库机制中，有一个预处理的机制（就是数据已经提交到数据库，但未执行commit操作），即XA协议：
> 
>  *     第一阶段：事务协调器要求每个涉及到事务的数据库预提交(precommit)此操作，并反映是否可以提交.
>  *     第二阶段：事务协调器要求每个数据库提交数据。（执行commit操作）
>  *  ### 运行过程 ###
>     
>     1.1 准备阶段
>     
>     协调者询问参与者事务是否执行成功，参与者发回事务执行结果。
>     
>     ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70 2][]
>     
>     1.2 提交阶段
>     
>     如果事务在每个参与者上都执行成功，事务协调者发送通知让参与者提交事务；否则，协调者发送通知让参与者回滚事务。
>     
>     需要注意的是，在准备阶段，参与者执行了事务，但是还未提交。只有在提交阶段接收到协调者发来的通知后，才进行提交或者回滚。
>     
>     ![2.jpg][]
>     
>     ### 存在的问题 ###
>     
>     **2.1 同步阻塞** 所有事务参与者在等待其它参与者响应的时候都处于同步阻塞状态，无法进行其它操作。
>     
>     **2.2 单点问题** 协调者在 2PC 中起到非常大的作用，发生故障将会造成很大影响。特别是在阶段二发生故障，所有参与者会一直等待状态，无法完成其它操作。
>     
>     **2.3 数据不一致** 在阶段二，如果协调者只发送了部分 Commit 消息，此时网络发生异常，那么只有部分参与者接收到 Commit 消息，也就是说只有部分参与者提交了事务，使得系统数据不一致。
>     
>     **2.4 太过保守** 任意一个节点失败就会导致整个事务失败，没有完善的容错机制。

*  ** 补偿事务（TCC，常用）：**

> TCC 其实就是采用的补偿机制，其核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。它分为三个阶段：
> 
>  *  Try 阶段主要是对业务系统做检测及资源预留
>  *  Confirm 阶段主要是对业务系统做确认提交，Try阶段执行成功并开始执行 Confirm阶段时，默认 Confirm阶段是不会出错的。即：只要Try成功，Confirm一定成功。
>  *  Cancel 阶段主要是在业务执行错误，需要回滚的状态下执行的业务取消，预留资源释放。
> 
> 举个例子，假入 Bob 要向 Smith 转账，思路大概是： 我们有一个本地方法，里面依次调用
> 
> 1.  首先在 Try 阶段，要先调用远程接口把 Smith 和 Bob 的钱给冻结起来。
> 2.  在 Confirm 阶段，执行远程调用的转账的操作，转账成功进行解冻。
> 3.  如果第2步执行成功，那么转账成功，如果第二步执行失败，则调用远程冻结接口对应的解冻方法 (Cancel)。
> 
> **优点：** 跟2PC比起来，实现以及流程相对简单了一些，但数据的一致性比2PC也要差一些
> 
> **缺点：** 缺点还是比较明显的，在2,3步中都有可能失败。TCC属于应用层的一种补偿方式，所以需要程序员在实现的时候多写很多补偿的代码，在一些场景中，一些业务流程可能用TCC不太好定义及处理

*  **本地消息表（异步确保）**

> 本地消息表与业务数据表处于同一个数据库中，这样就能利用本地事务来保证在对这两个表的操作满足事务特性，并且使用了消息队列来保证最终一致性。
> 
> 1.  在分布式事务操作的一方完成写业务数据的操作之后向本地消息表发送一个消息，本地事务能保证这个消息一定会被写入本地消息表中。
> 2.  之后将本地消息表中的消息转发到 Kafka 等消息队列中，如果转发成功则将消息从本地消息表中删除，否则继续重新转发。
> 3.  在分布式事务操作的另一方从消息队列中读取一个消息，并执行消息中的操作。
> 
> ![3.jpg][]
> 
> **优点：** 一种非常经典的实现，避免了分布式事务，实现了最终一致性。
> 
> **缺点：** 消息表会耦合到业务系统中，如果没有封装好的解决方案，会有很多杂活需要处理。

*  **MQ 事务消息（常用）**

>  有一些第三方的MQ是支持事务消息的，比如RocketMQ，他们支持事务消息的方式也是类似于采用的二阶段提交，但是市面上一些主流的MQ都是不支持事务消息的，比如 RabbitMQ 和 Kafka 都不支持。
> 
> 以阿里的 RocketMQ 中间件为例，其思路大致为：
> 
> 第一阶段Prepared消息，会拿到消息的地址。 第二阶段执行本地事务，第三阶段通过第一阶段拿到的地址去访问消息，并修改状态。
> 
> 也就是说在业务方法内要想消息队列提交两次请求，一次发送消息和一次确认消息。如果确认消息发送失败了RocketMQ会定期扫描消息集群中的事务消息，这时候发现了Prepared消息，它会向消息发送者确认，所以生产方需要实现一个check接口，RocketMQ会根据发送端设置的策略来决定是回滚还是继续发送确认消息。这样就保证了消息发送与本地事务同时成功或同时失败。
> 
> ![4.png][]
> 
> **优点：** 实现了最终一致性，不需要依赖本地数据库事务。
> 
> **缺点：** 实现难度大，主流MQ不支持，RocketMQ事务消息部分代码也未开源。

[相关连接][Link 1]

[相关博客][Link 2]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70]: /images/20220127/4fc91bd1ecf54b0e8106fd8f4c238d7b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70 1]: /images/20220127/18f7748e869d4c39a303a42b32c203b6.png
[Center]: /images/20220127/34c9ddd111774a86b949e3cc21aa3b3f.png
[Center 1]: /images/20220127/2feaa789fc564e91a32d8e36e8a16280.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpbWVndXlz_size_16_color_FFFFFF_t_70 2]: /images/20220127/8c31366721c84e96ac6580a0c862e16b.png
[2.jpg]: /images/20220127/0d720fe8718a44209bd860e1f0c908d9.png
[3.jpg]: /images/20220127/92eac6011c50463eafb811cccdb8abd7.png
[4.png]: /images/20220127/c92551045ff34badad4e636edb74ee34.png
[Link 1]: https://hhbbz.github.io/2018/09/06/%E5%88%86%E5%B8%83%E5%BC%8F%E4%BA%8B%E5%8A%A1%E7%9A%84%E5%9B%9B%E7%A7%8D%E8%A7%A3%E5%86%B3%E6%96%B9%E6%A1%88/
[Link 2]: https://blog.csdn.net/u010425776/article/details/79516298