SpringCloud --分布式事务 -- Seata
分布式事务
本地事务
本地事务特征
本地事务，也就是传统的单机事务。在传统数据库事务中，必须要满足四个原则：ACID
事务的隔离级别
1.读未提交（Read uncommitted）
这种事务隔离级别下，select语句不加锁。
此时，可能读取到不一致的数据，即“读脏 ”。这是并发最高，一致性最差的隔离级别。
2.读已提交（Read committed）
可避免 脏读 的发生。
在互联网大数据量，高并发量的场景下，几乎 不会使用 上述两种隔离级别。
3.可重复读（Repeatable read）
MySql默认隔离级别。
可避免 脏读 、不可重复读 的发生。
4.串行化（Serializable ）
可避免 脏读、不可重复读、幻读 的发生。
不可重复读和幻读是初学者不易分清的概念，总的来说，解决不可重复读的方法是 锁行，解决幻读的方式是 锁表。
分布式事务
分布式事务，就是指不是在单个服务或单个数据库架构下，产生的事务，例如：
- 跨数据源的分布式事务 同一台mysql数据库中有多个database
- 跨服务的分布式事务 你和你同桌
- 综合情况
在数据库水平拆分、服务垂直拆分之后，一个业务操作通常要跨多个数据库、服务才能完成。例如电商行业中比较常见的下单付款案例，包括下面几个行为：
- 创建新订单
- 扣减商品库存
- 从用户账户余额扣除金额
完成上面的操作需要访问三个不同的微服务和三个不同的数据库。
订单的创建、库存的扣减、账户扣款在每一个服务和数据库内是一个本地事务，可以保证ACID原则。
但是当我们把三件事情看做一个"业务"，要满足保证“业务”的原子性，要么所有操作全部成功，要么全部失败，不允许出现部分成功部分失败的现象，这就是分布式系统下的事务了。
此时ACID难以满足，这是分布式事务要解决的问题
理论基础
解决分布式事务问题，需要一些分布式系统的基础知识作为理论指导。
CAP定理
1998年，加州大学的计算机科学家 Eric Brewer 提出，分布式系统有三个指标。
Consistency（一致性） 数据的强一致性
Availability（可用性） 集群中一个服务出问题后另外的服务依然能对外提供服务
Partition tolerance （分区容错性） 集群有可能出现网络原因导致 服务和服务之间有短暂的中断
CP AP
它们的第一个字母分别是 C、A、P。
Eric Brewer 说，这三个指标不可能同时做到。这个结论就叫做 CAP 定理。
一致性
Consistency（一致性）：用户访问分布式系统中的任意节点，得到的数据必须一致。
比如现在包含两个节点，其中的初始数据是一致的：
当我们修改其中一个节点的数据时，两者的数据产生了差异：
要想保住一致性，就必须实现node01 到 node02的数据 同步：
可用性
Availability （可用性）：用户访问集群中的任意健康节点，必须能得到响应，而不是超时或拒绝。
如图，有三个节点的集群，访问任何一个都可以及时得到响应：
分区容错
Partition（分区）：因为网络故障或其它原因导致分布式系统中的部分节点与其它节点失去连接，形成独立分区。
Tolerance（容错）：在集群出现分区时，整个系统也要持续对外提供服务
矛盾
在分布式系统中，系统间的网络不能100%保证健康，一定会有故障的时候，而服务有必须对外保证服务。因此Partition Tolerance不可避免。
当节点接收到新的数据变更时，就会出现问题了：
如果此时要保证一致性，就必须等待网络恢复，完成数据同步后，整个集群才对外提供服务，服务处于阻塞状态，不可用。
如果此时要保证可用性，就不能等待网络恢复，那node01、node02与node03之间就会出现数据不一致。
也就是说，在P一定会出现的情况下，A和C之间只能实现一个。
BASE理论
BASE理论是对CAP的一种解决思路，包含三个思想：
- Basically Available （基本可用）：分布式系统在出现故障时，允许损失部分可用性，即保证核心可用。
- **Soft State（软状态）：**在一定时间内，允许出现中间状态，比如临时的不一致状态。
- Eventually Consistent（最终一致性）：虽然无法保证强一致性，但是在软状态结束后，最终达到数据一致。
解决分布式事务的思路
分布式事务最大的问题是各个子事务的一致性问题，因此可以借鉴CAP定理和BASE理论，有两种解决思路：
- AP模式：各子事务分别执行和提交，允许出现结果不一致，然后采用弥补措施恢复数据即可，实现最终一致。
- CP模式：各个子事务执行后互相等待，同时提交，同时回滚，达成强一致。但事务等待过程中，处于弱可用状态。
但不管是哪一种模式，都需要在子系统事务之间互相通讯，协调事务状态，也就是需要一个事务协调者(TC)：
这里的子系统事务，称为分支事务；有关联的各个分支事务在一起称为全局事务。
初识Seata
Seata是 2019 年 1 月份蚂蚁金服和阿里巴巴共同开源的分布式事务解决方案。致力于提供高性能和简单易用的分布式事务服务，为用户打造一站式的分布式解决方案。
官网地址：http://seata.io/，其中的文档、博客中提供了大量的使用说明、源码分析。
Seata的架构
Seata事务管理中有三个重要的角色：
- TC (Transaction Coordinator) - **事务协调者：**维护全局和分支事务的状态，协调全局事务提交或回滚。
- TM (Transaction Manager) - **事务管理器：**定义全局事务的范围、开始全局事务、提交或回滚全局事务。
- RM (Resource Manager) - **资源管理器：**管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。
整体的架构如图：
Seata基于上述架构提供了四种不同的分布式事务解决方案：
- XA模式：强一致性分阶段事务模式，牺牲了一定的可用性，无业务侵入
- AT模式：最终一致的分阶段事务模式，无业务侵入，也是Seata的默认模式
- TCC模式：最终一致的分阶段事务模式，有业务侵入
- SAGA模式：长事务模式，有业务侵入
无论哪种方案，都离不开TC，也就是事务的协调者。
seata的部署和集
下载
首先我们要下载seata-server包，地址在http/seata.io/zh-cn/blog/download.html
解压
在非中文目录解压缩这个zip包.
修改配置
修改conf目录下的registry.conf文件：
内容如下：
registry {
# tc服务的注册中心类，这里选择nacos，也可以是eureka、zookeeper等
type = "nacos"
nacos {
# seata tc 服务注册到 nacos的服务名称，可以自定义
application = "seata-server"
serverAddr = "127.0.0.1:8848"
group = "DEFAULT_GROUP"
namespace = ""
cluster = "default"
username = "nacos"
password = "nacos"
}
}
启动TC服务
运行之前确保nacos服务已经启动.
进入bin目录，运行其中的seata-server.bat即可：
大部分同学应该是启动不了的，因为，默认的内存有点大了，所以需要修改一下内存
修改保存后再双击启动
启动成功后，seata-server应该已经注册到nacos注册中心了。
打开浏览器，访问nacos地址：http://localhost:8848，然后进入服务列表页面，可以看到seata-server的信息：
微服务集成seata
引入依赖
首先，我们需要在微服务中引入seata依赖：
<dependency>
<groupId>com.alibaba.cloudgroupId>
<artifactId>spring-cloud-starter-alibaba-seataartifactId>
<exclusions>
<exclusion>
<artifactId>seata-spring-boot-starterartifactId>
<groupId>io.seatagroupId>
exclusion>
exclusions>
dependency>
<dependency>
<groupId>io.seatagroupId>
<artifactId>seata-spring-boot-starterartifactId>
<version>1.4.2version>
dependency>
修改配置文件
需要修改application.yml文件，添加一些配置：
seata:
registry:
type: nacos # 使用nacos作为注册中心
nacos:
server-addr: localhost:8848 # nacos服务地址
group: DEFAULT_GROUP # 默认服务分组
namespace: "" # 默认命名空间
cluster: default # 默认TC集群名称
tx-service-group: ${spring.application.name}-group # 事务组名称
service:
vgroup-mapping:
order-service-group: default # 事务组对应的TC集群名
微服务如何根据这些配置寻找TC的地址呢？
我们知道注册到Nacos中的微服务，确定一个具体实例需要四个信息：
- namespace：命名空间
- group：分组
- application：服务名
- cluster：集群名
以上四个信息，在刚才的yaml文件中都能找到：
namespace为空，就是默认的public
结合起来，TC服务的信息就是：public@DEFAULT_GROUP@seata-server@dafault，这样就能确定TC服务集群了。然后就可以去Nacos拉取对应的实例信息了。
TC服务的高可用
计划启动两台seata的tc服务节点：
| 节点名称 | ip地址 | 端口号 | 集群名称 |
|---|---|---|---|
| seata | 127.0.0.1 | 8091 | default |
| seata2 | 127.0.0.1 | 8092 | default |
之前我们已经启动了一台seata服务，端口是8091。
现在，将seata目录复制一份，起名为seata2
进入seata2/bin目录，然后运行命令：
seata-server.bat -p 8092
打开nacos控制台，查看服务列表：
XA模式
XA 规范 是 X/Open 组织定义的分布式事务处理（DTP，Distributed Transaction Processing）标准，XA 规范 描述了全局的TM与局部的RM之间的接口，几乎所有主流的数据库都对 XA 规范 提供了支持。
两阶段提交
XA是规范，目前主流数据库都实现了这种规范，实现的原理都是基于两阶段提交。
正常情况：
异常情况：
一阶段：
- 事务协调者通知每个事物参与者执行本地事务
- 本地事务执行完成后报告事务执行状态给事务协调者，此时事务不提交，继续持有数据库锁
二阶段：
- 事务协调者基于一阶段的报告来判断下一步操作
- 如果一阶段都成功，则通知所有事务参与者，提交事务
- 如果一阶段任意一个参与者失败，则通知所有事务参与者回滚事务
Seata的XA模型
Seata对原始的XA模式做了简单的封装和改造，以适应自己的事务模型，基本架构如图：
RM一阶段的工作：
① 注册分支事务到TC
② 执行分支业务sql但不提交
③ 报告执行状态到TC
TC二阶段的工作：
-
TC检测各分支事务执行状态
a.如果都成功，通知所有RM提交事务
b.如果有失败，通知所有RM回滚事务
RM二阶段的工作：
- 接收TC指令，提交或回滚事务
优缺点
XA模式的优点是什么？
- 事务的强一致性，满足ACID原则。
- 常用数据库都支持，实现简单，并且没有代码侵入
XA模式的缺点是什么？
- 因为一阶段需要锁定数据库资源，等待二阶段结束才释放，性能较差
- 依赖关系型数据库实现事务
实现XA模式
Seata的starter已经完成了XA模式的自动装配，实现非常简单，步骤如下：
1）修改application.yml文件（每个参与事务的微服务），开启XA模式：
seata:
data-source-proxy-mode: XA
2）给发起全局事务的入口方法添加@GlobalTransactional注解:
3）重启服务并测试
重启order-service，再次测试，发现无论怎样，三个微服务都能成功回滚。
AT模式
AT模式同样是分阶段提交的事务模型，不过缺弥补了XA模型中资源锁定周期过长的缺陷。
Seata的AT模型
基本流程图：
阶段一RM的工作：
- 注册分支事务
- 记录undo-log（数据快照）
- 执行业务sql并提交
- 报告事务状态
阶段二提交时RM的工作：
- 删除undo-log即可
阶段二回滚时RM的工作：
- 根据undo-log恢复数据到更新前
流程梳理
我们用一个真实的业务来梳理下AT模式的原理。
比如，现在又一个数据库表，记录用户余额：
| id | money |
|---|---|
| 1 | 100 |
其中一个分支业务要执行的SQL为：
update tb_account set money = money - 10 where id = 1
AT模式下，当前分支事务执行流程如下：
一阶段：
1）TM发起并注册全局事务到TC
2）TM调用分支事务
3）分支事务准备执行业务SQL
4）RM拦截业务SQL，根据where条件查询原始数据，形成快照。
{
"id": 1, "money": 100
}
5）RM执行业务SQL，提交本地事务，释放数据库锁。此时 money = 90
6）RM报告本地事务状态给TC
二阶段：
1）TM通知TC事务结束
2）TC检查分支事务状态
a）如果都成功，则立即删除快照
b）如果有分支事务失败，需要回滚。读取快照数据（{"id": 1, "money": 100}），将快照恢复到数据库。此时数据库再次恢复为100
流程图：
AT与XA的区别
简述AT模式与XA模式最大的区别是什么？
- XA模式一阶段不提交事务，锁定资源；AT模式一阶段直接提交，不锁定资源。
- XA模式依赖数据库机制实现回滚；AT模式利用数据快照实现数据回滚。
- XA模式强一致；AT模式最终一致
seata默认的是AT,使用的频率较高
脏写问题
在多线程并发访问AT模式的分布式事务时，有可能出现脏写问题，如图：
解决思路就是引入了全局锁的概念。在释放DB锁之前，先拿到全局锁。避免同一时刻有另外一个事务来操作当前数据。
优缺点
AT模式的优点：
- 一阶段完成直接提交事务，释放数据库资源，性能比较好
- 利用全局锁实现读写隔离
- 没有代码侵入，框架自动完成回滚和提交
AT模式的缺点：
- 两阶段之间属于软状态，属于最终一致
- 框架的快照功能会影响性能，但比XA模式要好很多
实现AT模式
AT模式中的快照生成、回滚等动作都是由框架自动完成，没有任何代码侵入，因此实现非常简单。
只不过，AT模式需要一个表来记录全局锁、另一张表来记录数据快照undo_log。
1）导入数据库表，记录全局锁
导入课前资料提供的Sql文件：seata-at.sql，其中lock_table导入到TC服务关联的数据库，undo_log表导入到微服务关联的数据库：
2）修改application.yml文件，将事务模式修改为AT模式即可：
seata:
data-source-proxy-mode: AT # 默认就是AT
3）重启服务并测试
TCC模式
TCC模式与AT模式非常相似，每阶段都是独立事务，不同的是TCC通过人工编码来实现数据恢复。需要实现三个方法：
- Try：资源的检测并预留；
- Confirm：完成资源操作业务；要求 Try 成功 Confirm 一定要能成功。
- Cancel：预留资源释放，可以理解为try的反向操作。
流程分析
举例，一个扣减用户余额的业务。假设账户A原来余额是100，需要余额扣减30元。
- 阶段一（ Try ）：检查余额是否充足，如果充足则冻结金额增加30元，可用余额扣除30
- 阶段二（Confirm)：假如要提交（Confirm），则冻结金额扣减30
- 阶段二(Canncel)：如果要回滚（Cancel），则冻结金额扣减30，可用余额增加30
Seata的TCC模型
Seata中的TCC模型依然延续之前的事务架构，如图：
优缺点
TCC模式的每个阶段是做什么的？
- Try：资源检查和预留
- Confirm：业务执行和提交
- Cancel：预留资源的释放
TCC的优点是什么？
- 一阶段完成直接提交事务，释放数据库资源，性能好
- 相比AT模型，无需生成快照，无需使用全局锁，性能最强
- 不依赖数据库事务，而是依赖补偿操作，可以用于非事务型数据库
TCC的缺点是什么？
- 有代码侵入，需要人为编写try、Confirm和Cancel接口，太麻烦
- 软状态，事务是最终一致
- 需要考虑Confirm和Cancel的失败情况，做好幂等处理
事务悬挂和空回滚
空回滚
当某分支事务的try阶段阻塞时，可能导致全局事务超时而触发二阶段的cancel操作。在未执行try操作时先执行了cancel操作，这时cancel不能做回滚，就是空回滚。
如图：
执行cancel操作时，应当判断try是否已经执行，如果尚未执行，则应该空回滚。
业务悬挂
对于已经空回滚的业务，之前被阻塞的try操作恢复，继续执行try，就永远不可能confirm或cancel ，事务一直处于中间状态，这就是业务悬挂。
执行try操作时，应当判断cancel是否已经执行过了，如果已经执行，应当阻止空回滚后的try操作，避免悬挂
实现TCC模式
思路分析
这里我们定义一张表：
CREATE TABLE `tb_account_freeze` (
`xid` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`user_id` int(11) NOT NULL,
`freeze_money` int(11) UNSIGNED NULL DEFAULT 0,
PRIMARY KEY (`xid`) USING BTREE
)
其中：
- xid：是全局事务id
- freeze_money：用来记录用户冻结金额
那此时，我们的业务开怎么做呢？
- Try业务：
- 记录冻结金额和事务状态到account_freeze表
- 扣减account表可用金额
- Confirm业务
- 根据xid删除account_freeze表的冻结记录
- Cancel业务
- 修改account表，恢复可用金额
- 删除冻结记录
- 如何判断是否空回滚？
- cancel业务中，根据xid查询account_freeze，如果为null则说明try还没做，需要空回滚
- 如何避免业务悬挂？
- try业务中，根据xid查询account_freeze ，如果已经存在则证明Cancel已经执行，拒绝执行try业务
接下来，我们改造account-service，利用TCC实现余额扣减功能。
实体类
package com.heima.account.entity;
import com.baomidou.mybatisplus.annotation.TableName;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableField;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
/**
*
*
*
*
* @author syl
* @since 2021-09-24
*/
@Data
@EqualsAndHashCode(callSuper = false)
@TableName("tb_account_freeze")
public class AccountFreeze implements Serializable {
private static final long serialVersionUID = 1L;
@TableId(value = "xid", type = IdType.INPUT)
private String xid;
@TableField("user_id")
private Integer userId;
@TableField("freeze_money")
private Integer freezeMoney;
}
接口
package com.heima.account.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.heima.account.entity.AccountFreeze;
public interface AccountFreezeMapper extends BaseMapper<AccountFreeze> {
}
package com.heima.account.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.heima.account.entity.AccountFreeze;
public interface IAccountFreezeService extends IService<AccountFreeze> {
}
实现
package com.heima.account.service.impl;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.heima.account.entity.AccountFreeze;
import com.heima.account.mapper.AccountFreezeMapper;
import com.heima.account.service.IAccountFreezeService;
import org.springframework.stereotype.Service;
@Service
public class AccountFreezeServiceImpl extends ServiceImpl<AccountFreezeMapper, AccountFreeze> implements IAccountFreezeService {
}
声明TCC接口
根据上述语法我们在account-service项目中的cn.itcast.account.action包中新建一个接口，声明TCC三个接口：
package com.heima.account.action;
import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
@LocalTCC
public interface AccountAction {
@TwoPhaseBusinessAction(name = "deduct", commitMethod = "confirm", rollbackMethod = "cancel")
void deduct(@BusinessActionContextParameter(paramName = "userId") Integer userId,
@BusinessActionContextParameter(paramName = "money") Integer money);
boolean confirm(BusinessActionContext context);
boolean cancel(BusinessActionContext context);
}
编写实现类
package com.heima.account.action.impl;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.heima.account.action.AccountAction;
import com.heima.account.entity.Account;
import com.heima.account.entity.AccountFreeze;
import com.heima.account.service.IAccountFreezeService;
import com.heima.account.service.IAccountService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountActionImpl implements AccountAction {
@Autowired
private IAccountFreezeService freezeService;
@Autowired
private IAccountService accountService;
@Override
public void deduct(Integer userId, Integer money) {
// 记录冻结金额到冻结表中
AccountFreeze freeze = new AccountFreeze();
String xid = RootContext.getXID();
freeze.setXid(xid);
freeze.setUserId(userId);
freeze.setFreezeMoney(money);
// 保存数据库
freezeService.save(freeze);
// 扣减当前账户表的金额
LambdaUpdateWrapper<Account> update = new LambdaUpdateWrapper<>();
update.eq(Account::getUserId, userId);
update.setSql("money = money -" + money);
accountService.update(update);
}
@Override
public boolean confirm(BusinessActionContext context) {
String xid = context.getXid();
// 根据xid删除冻结记录
LambdaQueryWrapper<AccountFreeze> query = new LambdaQueryWrapper<>();
query.eq(AccountFreeze::getXid, xid);
freezeService.remove(query);
return true;
}
@Override
public boolean cancel(BusinessActionContext context) {
// - 修改account表，恢复可用金额 update tb_account set money=money+? where user_id=？
LambdaUpdateWrapper<Account> updateWrapper = new LambdaUpdateWrapper<>();
Integer userId = (Integer) context.getActionContext("userId");
Integer money = (Integer) context.getActionContext("money");
updateWrapper.setSql("money=money+"+money);
updateWrapper.eq(Account::getUserId,userId);
accountService.update(updateWrapper);
// - 删除冻结记录
// - 根据xid删除account_freeze表的冻结记录 delete from account_freeze where xid=??
LambdaQueryWrapper<AccountFreeze> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(AccountFreeze::getXid,context.getXid());
accountFreezeService.remove(queryWrapper);
return true;
}
}
接口调用
修改AccountServiceImpl
@Service
@Slf4j
public class AccountServiceImpl extends ServiceImpl<AccountMapper, Account> implements IAccountService {
@Autowired
private AccountAction accountAction;
@Override
@Transactional
@GlobalTransactional
public void deduct(Integer userId, Integer money) {
accountAction.deduct(userId, money);
}
}
SAGA模式（了解）
Saga 模式是 Seata 即将开源的长事务解决方案，将由蚂蚁金服主要贡献。
其理论基础是Hector & Kenneth 在1987年发表的论文Sagas。
Seata官网对于Saga的指南：https://seata.io/zh-cn/docs/user/saga.html
原理
在 Saga 模式下，分布式事务内有多个参与者，每一个参与者都是一个冲正补偿服务，需要用户根据业务场景实现其正向操作和逆向回滚操作。
分布式事务执行过程中，依次执行各参与者的正向操作，如果所有正向操作均执行成功，那么分布式事务提交。如果任何一个正向操作执行失败，那么分布式事务会去退回去执行前面各参与者的逆向回滚操作，回滚已提交的参与者，使分布式事务回到初始状态。
Saga也分为两个阶段：
- 一阶段：直接提交本地事务
- 二阶段：成功则什么都不做；失败则通过编写补偿业务来回滚
优缺点
优点：
- 事务参与者可以基于事件驱动实现异步调用，吞吐高
- 一阶段直接提交事务，无锁，性能好
- 不用编写TCC中的三个阶段，实现简单
缺点：
- 软状态持续时间不确定，时效性差
- 没有锁，没有事务隔离，会有脏写
四种模式对比
我们从以下几个方面来对比四种实现：
- 一致性：能否保证事务的一致性？强一致还是最终一致？
- 隔离性：事务之间的隔离性如何？
- 代码侵入：是否需要对业务代码改造？
- 性能：有无性能损耗？
- 场景：常见的业务场景
如图：
