微服务高级篇【2】之分布式事务

前言

• 本文学习黑马，结合自己的学习和体验整理而来！！！
• 内容概述
  

一 事务分类及问题

1.1 本地事务

• 本地事务又名单机事务，在传统的数据库事务中，必须满足四个原则：
  
• 单机事务存在的问题：
  • 同时由于需要保证ACID特性，在高并发的场景下，极大影响效率
  • 由于不同的数据库之间可能存在网络延迟或者数据不一致的情况，在多个数据库之间的数据一致性难以保证

1.2 分布式事务

• 分布式事务，就是指不是在单个服务或单个数据库架构下，产生的事务，例如：

  • 跨数据源的分布式事务
  • 跨服务的分布式事务
  • 综合情况

• 在数据库水平拆分、服务垂直拆分之后，一个业务操作通常要跨多个数据库、服务才能完成。例如微服务下单业务，在下单时会调用订单服务，创建订单并写入数据库。然后订单服务调用账户服务和库存服务：

  • 账户服务负责扣减用户余额
  • 库存服务负责扣减商品库存
    

• 订单的创建、库存的扣减、账户扣款在每一个服务和数据库内是一个本地事务，可以保证ACID原则

• 订单服务、账户服务、库存服务可以看做一个"业务"，要满足保证“业务”的原子性，要么所有操作全部成功，要么全部失败，不允许出现部分成功部分失败的现象。此时ACID难以满足，这是分布式事务要解决的问题。

二 理论基础

• 解决分布式事务问题，需要一些分布式系统的基础知识作为理论指导。

2.1 CAP定理

1998年，加州大学的计算机科学家 Eric Brewer 提出，分布式系统有三个指标。

• Consistency（一致性）
• Availability（可用性）
• Partition tolerance （分区容错性）

• CAP定理的最总结论：在分布式系统中，一致性、可用性、分区容错性不可能同时做到

---

• 一致性
  • Consistency（一致性）：用户访问分布式系统中的任意节点，得到的数据必须一致。
    

---

• 可用性
  • Availability （可用性）：用户访问集群中的任意健康节点，必须能得到响应，而不是超时或拒绝。
    

---

• 分区容错
  • Partition（分区）：因为网络故障或其它原因导致分布式系统中的部分节点与其它节点失去连接，形成独立分区
  • Tolerance（容错）：在集群出现分区时，整个系统也要持续对外提供服务
    

2.2 CA的矛盾

• 在分布式系统中，系统间的网络不能100%保证健康，在有故障的时候，而服务有必须对外保证服务。因此Partition Tolerance不可避免。当节点接收到新的数据变更时，就会出现问题。
• 如果此时要保证一致性，就必须等待网络恢复，完成数据同步后，整个集群才对外提供服务，服务处于阻塞状态，不可用。如果此时要保证可用性，就不能等待网络恢复，那node01、node02与node03之间就会出现数据不一致。也就是说，在P一定会出现的情况下，A和C之间只能实现一个。

2.3 BASE理论

• BASE理论是对CAP的一种解决思路，包含三个思想：
  • Basically Available （基本可用）：分布式系统在出现故障时，允许损失部分可用性，即保证核心可用。
  • **Soft State（软状态）：**在一定时间内，允许出现中间状态，比如临时的不一致状态。
  • Eventually Consistent（最终一致性）：虽然无法保证强一致性，但是在软状态结束后，最终达到数据一致。

2.4 解决分布式事务的思路

• 分布式事务最大的问题是各个子事务的一致性问题，因此可以借鉴CAP定理和BASE理论，有两种解决思路：
  • AP模式：各子事务分别执行和提交，允许出现结果不一致，然后采用弥补措施恢复数据即可，实现最终一致。
  • CP模式：各个子事务执行后互相等待，同时提交，同时回滚，达成强一致。但事务等待过程中，处于弱可用状态。
• 两种模式，都需要在子系统事务之间互相通讯，协调事务状态，也就是需要一个事务协调者(TC)。这里的子系统事务，称为分支事务；有关联的各个分支事务在一起称为全局事务。
  

---

解决分布式事务的思想和模型：

• 全局事务：整个分布式事务
• 分支事务：分布式事务中包含的每个子系统的事务
• 最终一致思想：各分支事务分别执行并提交，如果有不一致的情况，再想办法恢复数据
• 强一致思想：各分支事务执行完业务不要提交，等待彼此结果。而后统一提交或回滚

三 初识Seata

• Seata是 2019 年 1 月份蚂蚁金服和阿里巴巴共同开源的分布式事务解决方案。致力于提供高性能和简单易用的分布式事务服务，为用户打造一站式的分布式解决方案。
• 官网地址，其中的文档、博客中提供了大量的使用说明、源码分析。

3.1 Seata的架构

Seata事务管理中有三个重要的角色：

• TC (Transaction Coordinator) - **事务协调者：**维护全局和分支事务的状态，协调全局事务提交或回滚。
• TM (Transaction Manager) - **事务管理器：**定义全局事务的范围、开始全局事务、提交或回滚全局事务。
• RM (Resource Manager) - **资源管理器：**管理分支事务处理的资源，与TC交谈以注册分支事务和报告分支事务的状态，并驱动分支事务提交或回滚。

---

• 整体的架构如图：
  
  Seata基于上述架构提供了四种不同的分布式事务解决方案：
  • XA模式：强一致性分阶段事务模式，牺牲了一定的可用性，无业务侵入
  • TCC模式：最终一致的分阶段事务模式，有业务侵入
  • AT模式：最终一致的分阶段事务模式，无业务侵入，也是Seata的默认模式
  • SAGA模式：长事务模式，有业务侵入

3.2 部署TC服务

• 微服务高级篇【2】之Seata部署

3.3 微服务集成seata

1. 首先，在相应的微服务中引入seata依赖：

   <dependency>
       <groupId>com.alibaba.cloud</groupId>
       <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
       <exclusions>
           <!--版本较低，1.3.0，因此排除-->
           <exclusion>
               <artifactId>seata-spring-boot-starter</artifactId>
               <groupId>io.seata</groupId>
           </exclusion>
       </exclusions>
   </dependency>
   <!--seata starter 采用1.4.2版本-->
   <dependency>
       <groupId>io.seata</groupId>
       <artifactId>seata-spring-boot-starter</artifactId>
       <version>1.4.2</version>
   </dependency>
   

2. 需要修改application.yml文件，添加一些配置：

   seata:
     registry: # TC服务注册中心的配置，微服务根据这些信息去注册中心获取tc服务地址
       # 参考tc服务自己的registry.conf中的配置
       type: nacos
       nacos: # tc
         server-addr: 127.0.0.1:8848
         namespace: ""
         group: DEFAULT_GROUP
         application: seata-tc-server # tc服务在nacos中的服务名称
         cluster: SH
     tx-service-group: seata-demo # 事务组，根据这个获取tc服务的cluster名称
     service:
       vgroup-mapping: # 事务组与TC服务cluster的映射关系
         seata-demo: SH
   

3. 测试
   - 重启微服务后，查看seata控制台
   

---

• 微服务如何根据这些配置寻找TC的地址呢？
  我们知道注册到Nacos中的微服务，确定一个具体实例需要四个信息：
  • namespace：命名空间
  • group：分组
  • application：服务名
  • cluster：集群名

以上四个信息，在刚才的yaml文件中都能找到：

• namespace为空，就是默认的public
• 结合起来，TC服务的信息就是：public@DEFAULT_GROUP@seata-tc-server@SH，这样就能确定TC服务集群,然后就可以去Nacos拉取对应的实例信息。

四 Seata的四种事务模式

4.1 XA模式

• XA 规范 是 X/Open 组织定义的分布式事务处理（DTP，Distributed Transaction Processing）标准，XA 规范 描述了全局的TM与局部的RM之间的接口，几乎所有主流的数据库都对 XA 规范 提供了支持。
• XA是规范，目前主流数据库都实现了这种规范，实现的原理都是基于两阶段提交。
  • 正常情况：
    
  • 异常情况
    

一阶段：

• 事务协调者通知每个事物参与者执行本地事务
• 本地事务执行完成后报告事务执行状态给事务协调者，此时事务不提交，继续持有数据库锁

二阶段：

• 事务协调者基于一阶段的报告来判断下一步操作
  • 如果一阶段都成功，则通知所有事务参与者，提交事务
  • 如果一阶段任意一个参与者失败，则通知所有事务参与者回滚事务

---

Seata对原始的XA模式做了简单的封装和改造，以适应自己的事务模型，基本架构如图：

RM一阶段的工作：
​ ① 注册分支事务到TC
​ ② 执行分支业务sql但不提交
​ ③ 报告执行状态到TC

• TC二阶段的工作：
  • TC检测各分支事务执行状态
    a.如果都成功，通知所有RM提交事务
    b.如果有失败，通知所有RM回滚事务
• RM二阶段的工作：
  • 接收TC指令，提交或回滚事务

---

4.1.1 优缺点

• XA模式的优点
  • 事务的强一致性，满足ACID原则。
  • 常用数据库都支持，实现简单，并且没有代码侵入
• XA模式的缺点
  • 因为一阶段需要锁定数据库资源，等待二阶段结束才释放，性能较差
  • 依赖关系型数据库实现事务

---

4.1.2 实现XA模式

• Seata的starter已经完成了XA模式的自动装配，实现非常简单，步骤如下：

1. 修改application.yml文件（每个参与事务的微服务），开启XA模式：

   seata:
     data-source-proxy-mode: XA
   

2. 给发起全局事务的入口方法添加@GlobalTransactional注解:
3. 重启服务并测试
   
   

4.1.3 出现的问题总结

1. 数据库的连接

       driver-class-name: com.mysql.cj.jdbc.Driver
       url: jdbc:mysql:///seata_demo?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true&useSSL=false&serverTimezone=UTC
   

2. druid的版本问题

   <dependency>
       <groupId>com.alibabagroupId>
       <artifactId>druid-spring-boot-starterartifactId>
       <version>1.2.16version>
   dependency>
   

3. 项目Seata依赖引入问题：注意，每一个微服务都需要引入Seata依赖和配置yml文件

   
   <dependency>
       <groupId>com.alibaba.cloudgroupId>
       <artifactId>spring-cloud-starter-alibaba-seataartifactId>
       <exclusions>
           
           <exclusion>
               <artifactId>seata-spring-boot-starterartifactId>
               <groupId>io.seatagroupId>
           exclusion>
       exclusions>
   dependency>
   

   seata:
     registry: # TC服务注册中心的配置，微服务根据这些信息去注册中心获取tc服务地址
       type: nacos # 注册中心类型 nacos
       nacos:
         server-addr: 127.0.0.1:8848 # nacos地址
         namespace: "" # namespace，默认为空
         group: DEFAULT_GROUP # 分组，默认是DEFAULT_GROUP
         application: seata-tc-server # seata服务名称
         username: nacos
         password: nacos
     tx-service-group: seata-demo # 事务组名称
     service:
       vgroup-mapping: # 事务组与cluster的映射关系
         seata-demo: SH
   

4.2 AT模式

• AT模式同样是分阶段提交的事务模型，不过缺弥补了XA模型中资源锁定周期过长的缺陷。

4.2.1 Seata的AT模型

• 基本流程图：
  
  阶段一RM的工作：
• 注册分支事务
• 记录undo-log（数据快照）
• 执行业务sql并提交
• 报告事务状态
  阶段二提交时RM的工作：
• 删除undo-log即可
  阶段二回滚时RM的工作：
• 根据undo-log恢复数据到更新前

4.2.2 流程梳理

• 用一个真实的业务来梳理下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
• 流程图：
  

4.2.3 AT与XA的区别

AT模式与XA模式最大的区别

• XA模式一阶段不提交事务，锁定资源；AT模式一阶段直接提交，不锁定资源。
• XA模式依赖数据库机制实现回滚；AT模式利用数据快照实现数据回滚。
• XA模式强一致；AT模式最终一致

4.2.4 脏写问题

• 在多线程并发访问AT模式的分布式事务时，有可能出现脏写问题
  
• 解决思路就是引入了全局锁的概念。在释放DB锁之前，先拿到全局锁。避免同一时刻有另外一个事务来操作当前数据。
  

4.2.5 优缺点

• AT模式的优点：
  • 一阶段完成直接提交事务，释放数据库资源，性能比较好
  • 利用全局锁实现读写隔离
  • 没有代码侵入，框架自动完成回滚和提交
• AT模式的缺点：
  • 两阶段之间属于软状态，属于最终一致
  • 框架的快照功能会影响性能，但比XA模式要好很多

4.2.6 AT模式的实现

• AT模式中的快照生成、回滚等动作都是由框架自动完成，没有任何代码侵入，因此实现非常简单。只不过，AT模式需要一个表来记录全局锁、另一张表来记录数据快照undo_log。

1. 导入数据库表，记录全局锁
   • 在seta库创建lock_table

   DROP TABLE IF EXISTS `lock_table`;
   CREATE TABLE `lock_table`  (
     `row_key` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
     `xid` varchar(96) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
     `transaction_id` bigint(20) NULL DEFAULT NULL,
     `branch_id` bigint(20) NOT NULL,
     `resource_id` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
     `table_name` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
     `pk` varchar(36) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
     `gmt_create` datetime NULL DEFAULT NULL,
     `gmt_modified` datetime NULL DEFAULT NULL,
     PRIMARY KEY (`row_key`) USING BTREE,
     INDEX `idx_branch_id`(`branch_id`) USING BTREE
   ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;
   

   • 在seata_demo数据库创建undo_log

   DROP TABLE IF EXISTS `undo_log`;
   CREATE TABLE `undo_log`  (
     `branch_id` bigint(20) NOT NULL COMMENT 'branch transaction id',
     `xid` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'global transaction id',
     `context` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'undo_log context,such as serialization',
     `rollback_info` longblob NOT NULL COMMENT 'rollback info',
     `log_status` int(11) NOT NULL COMMENT '0:normal status,1:defense status',
     `log_created` datetime(6) NOT NULL COMMENT 'create datetime',
     `log_modified` datetime(6) NOT NULL COMMENT 'modify datetime',
     UNIQUE INDEX `ux_undo_log`(`xid`, `branch_id`) USING BTREE
   ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = 'AT transaction mode undo table' ROW_FORMAT = Compact;
   

2. 修改application.yml文件，将事务模式修改为AT模式即可：

seata:
  data-source-proxy-mode: AT # 默认就是AT

3. 重启服务并测试
   • 测试业务成功了，但是出现BIGINT UNSIGNED value is out of range报错，同时没有完整的业务撤销日志信息，数据库中的lock_table表、undo_log表并没有相关的记录!

4.3 TCC模式

TCC模式与AT模式非常相似，每阶段都是独立事务，不同的是TCC通过人工编码来实现数据恢复。需要实现三个方法：

• Try：资源的检测和预留；
• Confirm：完成资源操作业务；要求 Try 成功 Confirm 一定要能成功。
• Cancel：预留资源释放，可以理解为try的反向操作。

4.3.1 流程分析

4.3.2 Seata的TCC模型

4.3.3 优缺点

TCC模式的每个阶段的工作

• Try：资源检查和预留
• Confirm：业务执行和提交
• Cancel：预留资源的释放
  TCC的优点
• 一阶段完成直接提交事务，释放数据库资源，性能好
• 相比AT模型，无需生成快照，无需使用全局锁，性能最强
• 不依赖数据库事务，而是依赖补偿操作，可以用于非事务型数据库
  TCC的缺点
• 有代码侵入，需要人为编写try、Confirm和Cancel接口，太麻烦
• 软状态，事务是最终一致
• 需要考虑Confirm和Cancel的失败情况，做好幂等处理

4.3.4 事务悬挂和空回滚

• 空回滚：当某分支事务的try阶段阻塞时，可能导致全局事务超时而触发二阶段的cancel操作。在未执行try操作时先执行cancel操作，这时cancel不能做回滚，就是空回滚。
• 执行cancel操作时，应当判断try是否已经执行，如果尚未执行，则应该空回滚。
• 业务悬挂：对于已经空回滚的业务，之前被阻塞的try操作恢复，继续执行try，就永远不可能confirm或cancel ，事务一直处于中间状态，这就是业务悬挂。
• 执行try操作时，应当判断cancel是否已经执行过了，如果已经执行，应当阻止空回滚后的try操作，避免悬挂
  

---

• 演示：
  • 实现类的关键实现代码

  @Service
  public class AccountTCCServiceImpl implements AccountTCCService {
      @Autowired
      private AccountMapper accountMapper;
      @Autowired
      private AccountFreezeMapper freezeMapper;
      @Override
      @Transactional
      public void deduct(String userId, int money) {
          // 0.获取事务id
          String xid = RootContext.getXID();
  
          //判断freeze中是否有冻结记录 如果有一定是cancle执行过,拒绝业务
          AccountFreeze oldFreeze = freezeMapper.selectById(xid);
          if(oldFreeze!=null) {
              //cancle执行过，拒绝业务
              return;
          }
  
          // 1.扣减可用余额
          accountMapper.deduct(userId, money);
          // 2.记录冻结金额，事务状态
          AccountFreeze freeze = new AccountFreeze();
          freeze.setUserId(userId);
          freeze.setFreezeMoney(money);
          freeze.setState(AccountFreeze.State.TRY);
          freeze.setXid(xid);
          freezeMapper.insert(freeze);
      }
  
      @Override
      public boolean confirm(BusinessActionContext ctx) {
          // 1.获取事务id
          String xid = ctx.getXid();
          // 2.根据id删除冻结记录
          int count = freezeMapper.deleteById(xid);
          return count == 1;
      }
  
      @Override
      public boolean cancel(BusinessActionContext ctx) {
          // 0.查询冻结记录
          String xid = ctx.getXid();
          String userId = ctx.getActionContext("userId").toString();
          AccountFreeze freeze = freezeMapper.selectById(xid);
          //空回滚的判断 判断freeze是否为null,如果为null说明try没有执行，需要空回滚
          if(freeze==null) {
              //证明Try没执行需要空回滚
              freeze = new AccountFreeze();
              freeze.setUserId(userId);
              freeze.setFreezeMoney(0);
              freeze.setState(AccountFreeze.State.CANCEL);
              freeze.setXid(xid);
              freezeMapper.insert(freeze);
              return true;
          }
  
          // 1.恢复可用余额
          accountMapper.refund(freeze.getUserId(), freeze.getFreezeMoney());
          // 2.将冻结金额清零，状态改为CANCEL
          freeze.setFreezeMoney(0);
          freeze.setState(AccountFreeze.State.CANCEL);
          int count = freezeMapper.updateById(freeze);
          return count == 1;
      }
  }
  

  • 在数据库中新建一张表，记录业务状态

  CREATE TABLE `account_freeze_tbl` (
  	`xid` VARCHAR(128) NOT NULL,
  	`user_id` VARCHAR(255) DEFAULT NULL COMMENT "用户id",
  	`freeze_money` INT(11) UNSIGNED DEFAULT '0' COMMENT "冻结金额",
  	`state` INT(1) DEFAULT NULL COMMENT "事务状态,0:try，1:confirm，2:cancel",
  	PRIMARY KEY(`xid`) USING BTREE
  )ENGINE=INNODB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;
  

• 具体的详细内容，请参看黑马官方的教程，这里只是记录重要的部分

• 测试结果
  
  

4.5 SAGA模式

• Saga 模式是 Seata 即将开源的长事务解决方案，将由蚂蚁金服主要贡献。其理论基础是Hector & Kenneth 在1987年发表的论文Sagas
• Seata官网对于Saga的指南

4.5.1 原理分析

• 在 Saga 模式下，分布式事务内有多个参与者，每一个参与者都是一个冲正补偿服务，需要用户根据业务场景实现其正向操作和逆向回滚操作。
• 分布式事务执行过程中，依次执行各参与者的正向操作，如果所有正向操作均执行成功，那么分布式事务提交。如果任何一个正向操作执行失败，那么分布式事务会去退回去执行前面各参与者的逆向回滚操作，回滚已提交的参与者，使分布式事务回到初始状态。
  
  Saga也分为两个阶段：
• 一阶段：直接提交本地事务
• 二阶段：成功则什么都不做；失败则通过编写补偿业务来回滚

4.5.2 优缺点

优点：

• 事务参与者可以基于事件驱动实现异步调用，吞吐高
• 一阶段直接提交事务，无锁，性能好
• 不用编写TCC中的三个阶段，实现简单
  缺点：
• 软状态持续时间不确定，时效性差
• 没有锁，没有事务隔离，会有脏写

4.6 四种模式的对比总结

五 高可用

• Seata的TC服务作为分布式事务核心，一定要保证集群的高可用性。

5.1 高可用架构模型

• TC服务作为Seata的核心服务，一定要保证高可用和异地容灾。
  
• 微服务基于事务组（tx-service-group)与TC集群的映射关系，来查找当前应该使用哪个TC集群。当SH集群故障时，只需要将vgroup-mapping中的映射关系改成HZ。则所有微服务就会切换到HZ的TC集群

5.2 实现高可用

5.2.1 模拟异地容灾的TC集群

• 计划启动两台seata的tc服务节点：

节点名称	ip地址	端口号	集群名称
seata	127.0.0.1	8091	SH
seata2	127.0.0.1	8092	HZ

• 修改配置文件：设置Seata的服务端口和注册到nacos的配置信息
  
• seata

  server:
    port: 7091
  seata:
    config:
      # support: nacos, consul, apollo, zk, etcd3
      # 读取tc服务端的配置文件的方式，这里是从nacos配置中心读取，这样如果tc是集群，可以共享配置
      type: nacos
      # 配置nacos地址等信息
      nacos:
        serverAddr: 127.0.0.1:8848
        namespace: ""
        group: SEATA_GROUP
        username: nacos
        password: nacos
        dataId: seataServer.properties
    registry:
      # support: nacos, eureka, redis, zk, consul, etcd3, sofa
      # tc服务的注册中心类，这里选择nacos，也可以是eureka、zookeeper等
      type: nacos
      nacos:
        # seata tc 服务注册到 nacos的服务名称，可以自定义
        application: seata-tc-server
        serverAddr: 127.0.0.1:8848
        group: DEFAULT_GROUP
        namespace: ""
        cluster: SH
        username: nacos
        password: nacos 
  

• seata2

  server:
    port: 7092
  seata:
    config:
      # support: nacos, consul, apollo, zk, etcd3
      # 读取tc服务端的配置文件的方式，这里是从nacos配置中心读取，这样如果tc是集群，可以共享配置
      type: nacos
      # 配置nacos地址等信息
      nacos:
        serverAddr: 127.0.0.1:8848
        namespace: ""
        group: SEATA_GROUP
        username: nacos
        password: nacos
        dataId: seataServer.properties
    registry:
      # support: nacos, eureka, redis, zk, consul, etcd3, sofa
      # tc服务的注册中心类，这里选择nacos，也可以是eureka、zookeeper等
      type: nacos
      nacos:
        # seata tc 服务注册到 nacos的服务名称，可以自定义
        application: seata-tc-server
        serverAddr: 127.0.0.1:8848
        group: DEFAULT_GROUP
        namespace: ""
        cluster: HZ
        username: nacos
        password: nacos 
  

• 然后分别运行命令

  seata-server.bat -p 8091
  

  seata-server.bat -p 8092
  

• 打开nacos控制台，查看
  

5.2.2 将事务组映射配置到nacos

• 将tx-service-group与cluster的映射关系都配置到nacos配置中心
  • 新建一个配置：
    
  • 配置的内容如下：

  # 事务组映射关系
  service.vgroupMapping.seata-demo=SH
  
  service.enableDegrade=false
  service.disableGlobalTransaction=false
  # 与TC服务的通信配置
  transport.type=TCP
  transport.server=NIO
  transport.heartbeat=true
  transport.enableClientBatchSendRequest=false
  transport.threadFactory.bossThreadPrefix=NettyBoss
  transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
  transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
  transport.threadFactory.shareBossWorker=false
  transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
  transport.threadFactory.clientSelectorThreadSize=1
  transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
  transport.threadFactory.bossThreadSize=1
  transport.threadFactory.workerThreadSize=default
  transport.shutdown.wait=3
  # RM配置
  client.rm.asyncCommitBufferLimit=10000
  client.rm.lock.retryInterval=10
  client.rm.lock.retryTimes=30
  client.rm.lock.retryPolicyBranchRollbackOnConflict=true
  client.rm.reportRetryCount=5
  client.rm.tableMetaCheckEnable=false
  client.rm.tableMetaCheckerInterval=60000
  client.rm.sqlParserType=druid
  client.rm.reportSuccessEnable=false
  client.rm.sagaBranchRegisterEnable=false
  # TM配置
  client.tm.commitRetryCount=5
  client.tm.rollbackRetryCount=5
  client.tm.defaultGlobalTransactionTimeout=60000
  client.tm.degradeCheck=false
  client.tm.degradeCheckAllowTimes=10
  client.tm.degradeCheckPeriod=2000
  
  # undo日志配置
  client.undo.dataValidation=true
  client.undo.logSerialization=jackson
  client.undo.onlyCareUpdateColumns=true
  client.undo.logTable=undo_log
  client.undo.compress.enable=true
  client.undo.compress.type=zip
  client.undo.compress.threshold=64k
  client.log.exceptionRate=100
  

5.2.3 微服务读取nacos配置

• 需要修改每一个微服务的application.yml文件，让微服务读取nacos中的client.properties文件：

  seata:
    config:
      type: nacos
      nacos:
        server-addr: 127.0.0.1:8848
        username: nacos
        password: nacos
        group: SEATA_GROUP
        data-id: client.properties
  

• 重启微服务，现在微服务到底是连接tc的SH集群，还是tc的HZ集群，都统一由nacos的client.properties来决定