Build SpringCloud Projects With Seata

序言

Jta+Atomikos 是传统的多数据源的分布式处理方案.

而Seata是分布式的处理方案.且像阿里自己说的双11的抢购都是它解决的.

官网:https://seata.io/zh-cn/docs/overview/what-is-seata.html

事务模式

seata的事务类型支持的种类有:

• AT:主打模式
• TCC
• SAGA 
•  XA 

AT模式

因为AT模式即阿里的TCC模式,所以AT会对我们的代码进行一定的代理,来实现自己的分布式处理.所有多少会对我们的代码框架有些要求cuiyaonan2000@163.com

要求

• 支持本地 ACID 事务的关系型数据库。
• Java 应用，通过 JDBC 访问数据库。

整体机制

两阶段提交协议的演变：

• 一阶段：业务数据和回滚日志记录在同一个本地事务中提交，释放本地锁和连接资源。

• 二阶段：

  • 提交异步化，非常快速地完成。
  • 回滚通过一阶段的回滚日志进行反向补偿。

写隔离

• 一阶段本地事务提交前，需要确保先拿到 全局锁 。------注意该全局锁是TC的锁,非数据库中的行级锁和表级锁cuiyaonan2000@163.com
• 拿不到 全局锁 ，不能提交本地事务。-----------没有TC的锁,其它的操作相同记录的事务不能提交
• 拿 全局锁 的尝试被限制在一定范围内，超出范围将放弃，并回滚本地事务，释放本地锁。

用例说明这个全局锁的在AT中的作用(其实这个全局锁是AT模式中非常关键的一个东西cuiyaonan2000@163.com)

两个全局事务 tx1 和 tx2，分别对 a 表的 m 字段进行更新操作，m 的初始值 1000。

1. tx1 先开始，开启本地事务，拿到本地锁，更新操作 m = 1000 - 100 = 900。本地事务提交前，先拿到该记录的 全局锁 ，本地提交释放本地锁。 tx2 后开始，开启本地事务，拿到本地锁，更新操作 m = 900 - 100 = 800。本地事务提交前，尝试拿该记录的 全局锁 ，tx1 全局提交前，该记录的全局锁被 tx1 持有，tx2 需要重试等待 全局锁 。
2. tx1 二阶段全局提交，释放 全局锁 。tx2 拿到 全局锁 提交本地事务。
3. tx1 的二阶段全局回滚，则 tx1 需要重新获取该数据的本地锁，进行反向补偿的更新操作，实现分支的回滚。此时，如果 tx2 仍在等待该数据的 全局锁，同时持有本地锁，则 tx1 的分支回滚会失败。分支的回滚会一直重试，直到 tx2 的 全局锁 等锁超时，放弃 全局锁 并回滚本地事务释放本地锁，tx1 的分支回滚最终成功。---------tx2回滚的条件就是全局锁获取时间超时,也只能通过该方法,使tx1获取该条记录的本地事务.

读隔离

在数据库本地事务隔离级别 读已提交（Read Committed） 或以上的基础上，Seata（AT 模式）的默认全局隔离级别是 读未提交（Read Uncommitted） 。

如果应用在特定场景下，必需要求全局的 读已提交 ，目前 Seata 的方式是通过 SELECT FOR UPDATE 语句的代理。

SELECT FOR UPDATE 语句的执行会申请 全局锁 ，如果 全局锁 被其他事务持有，则释放本地锁（回滚 SELECT FOR UPDATE 语句的本地执行）并重试。这个过程中，查询是被 block 住的，直到 全局锁 拿到，即读取的相关数据是 已提交 的，才返回。----这个设计对应数据库中的序列化的隔离级别了cuiyoanan2000@163.com

出于总体性能上的考虑，Seata 目前的方案并没有对所有 SELECT 语句都进行代理，仅针对 FOR UPDATE 的 SELECT 语句。

AT如何进行事务补偿(减少代码侵入)

以一个Update的实例来说明

update product set name = 'GTS' where name = 'TXC';

一阶段

• AT通过解析如上的SQL语句,反向生成如下的SQL,(目的是为了保存目标记录的原始值,以供将来回滚,所以这里是这个框架的一个非常重要的模块ciuyaonan2000@163.com)

select id, name, since from product where name = 'TXC';

• 插入回滚日志：把前后镜像数据以及业务 SQL 相关的信息组成一条回滚日志记录，插入到 UNDO_LOG 表中。-----阿里把这种存储的记录信息称为前镜像和后镜像.分别标识所修改记录的原始值,和被修改值
• 提交前，向 TC 注册分支：申请 product 表中，主键值等于 1 的记录的 全局锁 。---该全局锁是指修改这条记录的全局锁.
• 本地事务提交：业务数据的更新和前面步骤中生成的 UNDO LOG 一并提交。
• 将本地事务提交的结果上报给 TC。

二阶段回滚

1. 收到 TC 的分支回滚请求，开启一个本地事务，执行如下操作。
2. 通过 XID 和 Branch ID 查找到相应的 UNDO LOG 记录。
3. 数据校验：拿 UNDO LOG 中的后镜与当前数据进行比较，如果有不同，说明数据被当前全局事务之外的动作做了修改。这种情况，需要根据配置策略来做处理，详细的说明在另外的文档中介绍。------为什么会不一样,因为本地事务提交了,同时另外又有一个事务对该记录进行了修改.但是这2个事务的全局锁只有一个,且都没提交.cuiyaonan2000@163.com
4. 根据 UNDO LOG 中的前镜像和业务 SQL 的相关信息生成并执行回滚的语句：

update product set name = 'TXC' where id = 1;

1. 提交本地事务。并把本地事务的执行结果（即分支事务回滚的结果）上报给 TC。

二阶段提交

1. 收到 TC 的分支提交请求，把请求放入一个异步任务的队列中，马上返回提交成功的结果给 TC。------这里为什么能马上返回成功结果,因为本地事务都已经提交了.只是不需要进行事务补偿了cuiyaonan2000@163.com
2. 异步任务阶段的分支提交请求将异步和批量地删除相应 UNDO LOG 记录。

TCC模式

根据两阶段行为模式的不同，我们将分支事务划分为 Automatic (Branch) Transaction Mode 和 Manual (Branch) Transaction Mode.

AT 模式（参考链接 TBD）基于 支持本地 ACID 事务 的 关系型数据库：

• 一阶段 prepare 行为：在本地事务中，一并提交业务数据更新和相应回滚日志记录。
• 二阶段 commit 行为：马上成功结束，自动 异步批量清理回滚日志。
• 二阶段 rollback 行为：通过回滚日志，自动 生成补偿操作，完成数据回滚。

相应的，TCC 模式，不依赖于底层数据资源的事务支持：

• 一阶段 prepare 行为：调用 自定义 的 prepare 逻辑。
• 二阶段 commit 行为：调用 自定义 的 commit 逻辑。
• 二阶段 rollback 行为：调用 自定义 的 rollback 逻辑。

所谓 TCC 模式，是指支持把 自定义 的分支事务纳入到全局事务的管理中。

Saga 模式---长事务的解决模式

搭建工程

参考官方的文档:https://github.com/seata/seata-samples

这里只是简单的搭建SpringCloud工程流程如下:

1. Seata工程的SeataService向数据库Test的表A中插入一条记录
2. SeataService再调用Feign工程的feign接口,feign接口向数据库Test2的表B插入一条记录
3. SeataService 在收到Feign的返回内容后 使用大杀器 int i=1/0让整个请求连接回滚.(这里可以注意在执行到int i = 1/0 这里时查看数据库Test和Test2记录已经存在了,当整个方法运行完Test和Test2中的记录会被TC删除cuiyaonan2000@163.com)

SeataService

package cui.yao.nan.seata.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cui.yao.nan.seata.dao.ReadDao;
import cui.yao.nan.seata.feignClient.CallTestService;
import io.seata.spring.annotation.GlobalTransactional;

/**
 * @author cuiyaonan2000@163.com
 * @des: TODO
 * @date 2021年7月20日 上午11:15:44
 * @package cui.yao.nan.seata.service
 */
@Service
public class SeataService {
    
    @Autowired
    private ReadDao readDao;
    
    @Autowired
    CallFeignService callFeignService;
    
    @GlobalTransactional
    public void dodo(){
	readDao.doInsert();
	
	callFeignService.callFeign("j");
	int i = 1/0;
    }

}

FeignService

package cui.yao.nan.feign.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import cui.yao.nan.feign.dao.ReadDao;

/**
 * 
 * @author 这里的疑问就是能不能直接用service呢~通过feign的工作原理来说是不可以的.
 *
 */
@RestController
public class FeignService {

    @Autowired
    private ReadDao readDao;

    @Transactional
    public void doSomeThing() {
	readDao.doInsert();
    }

}