Seata分布式事务

1.CAP定理是什么?

C 一致性 用户访问集群中任意节点，获得的数据一致
A 可用性 用户访问集群中任意健康节点，必须能得到响应，不是超时拒绝
P 分区容错性 
    分区：由于网络故障或其他原因导致分布式中部分节点与其他节点失去连接，形成独立的分区。
    容错：在集群出现分区时，整个系统也要持续对外提供服务。
最多仅可同时满足2个条件，无法同时满足三个特性。
ES集群属于CP

2.Base理论是什么?

 是对CAP的一种解决思路，包含三个思想：
基本可用：分布式系统出现故障时，为了保证一致性，允许损失部分可用性
软状态：在一定时间内，允许出现中建状态，比如临时的不一致
最终一致性：在软状态结束后，最终达到数据的一致

3.CP和AP指导思想是什么?

AP（可用性）:各子事务分别提交和执行，允许结果不一致，采用弥补措施恢复数据达到最终数据一致即可。（执行完后直接提交事务，若有问题，再由seata通知回滚事务）
CP（一致性）:各子事务执行后相互等待，同时提交同时回滚，达到强一致性，事务等待过程中处于弱可用状态。（执行后由seata通知提交事务）

4.Seata结构?

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

5.Seata搭建过程?

一、部署Seata的tc-server

下载seata-server包，地址在http://seata.io/zh-cn/blog/download.html

1.在非中文目录解压缩这个zip包

2.修改conf目录下的registry.conf文件

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

3.在nacos添加配置

为了让tc服务的集群可以共享配置，我们选择了nacos作为统一配置中心。因此服务端配置文件seataServer.properties文件需要在nacos中配好。

# 数据存储方式，db代表数据库
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.jdbc.Driver
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true
store.db.user=root 
store.db.password=1234
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000
# 事务、日志等配置
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000

# 客户端与服务端传输方式
transport.serialization=seata
transport.compressor=none
# 关闭metrics功能，提高性能
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

其中的数据库地址、用户名、密码都需要修改成你自己的数据库信息。

4.创建数据库表

tc服务在管理分布式事务时，需要记录事务相关数据到数据库中，你需要提前创建好这些表。

新建一个名为seata的数据库，这些表主要记录全局事务、分支事务、全局锁信息：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- 分支事务表
-- ----------------------------
DROP TABLE IF EXISTS `branch_table`;
CREATE TABLE `branch_table`  (
  `branch_id` bigint(20) NOT NULL,
  `xid` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `transaction_id` bigint(20) NULL DEFAULT NULL,
  `resource_group_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `resource_id` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `branch_type` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `status` tinyint(4) NULL DEFAULT NULL,
  `client_id` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `application_data` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime(6) NULL DEFAULT NULL,
  `gmt_modified` datetime(6) NULL DEFAULT NULL,
  PRIMARY KEY (`branch_id`) USING BTREE,
  INDEX `idx_xid`(`xid`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- 全局事务表
-- ----------------------------
DROP TABLE IF EXISTS `global_table`;
CREATE TABLE `global_table`  (
  `xid` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `transaction_id` bigint(20) NULL DEFAULT NULL,
  `status` tinyint(4) NOT NULL,
  `application_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `transaction_service_group` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `transaction_name` varchar(128) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `timeout` int(11) NULL DEFAULT NULL,
  `begin_time` bigint(20) NULL DEFAULT NULL,
  `application_data` varchar(2000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `gmt_create` datetime NULL DEFAULT NULL,
  `gmt_modified` datetime NULL DEFAULT NULL,
  PRIMARY KEY (`xid`) USING BTREE,
  INDEX `idx_gmt_modified_status`(`gmt_modified`, `status`) USING BTREE,
  INDEX `idx_transaction_id`(`transaction_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

SET FOREIGN_KEY_CHECKS = 1;

5.启动TC服务

进入bin目录，运行其中的seata-server.bat即可

启动成功后，seata-server应该已经注册到nacos注册中心了。

打开浏览器，访问nacos地址：http://localhost:8848，然后进入服务列表页面，可以看到seata-tc-server的信息

二、微服务集成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>${seata.version}</version>
</dependency>

2.修改配置文件

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

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

6.Seata的四种模式?

• XA模式：强一致性分阶段事务模式，牺牲了一定的可用性，无业务侵入

• TCC模式：最终一致的分阶段事务模式，有业务侵入

• AT模式：最终一致的分阶段事务模式，无业务侵入，也是Seata的默认模式

• SAGA模式：长事务模式，有业务侵入

7.四种模式执行原理?

1.XA模式：

一阶段：由TM访问TC开启全局事务，RM注册分支事务到TC，执行分支业务sql后不提交，继续持有数据库锁，报告执行状态到TC。

二阶段：分支执行状态全部提交后，由TM访问TC，TC对各分支事务执行状态检查，如果都成功则通知所有分支RM提交事务，反之通知回滚。

XA模式的优点：

• 事务的强一致性，满足ACID原则。

• 常用数据库都支持，实现简单，并且没有代码侵入

XA模式的缺点：

• 因为一阶段需要锁定数据库资源，等待二阶段结束才释放，性能较差

• 依赖关系型数据库实现事务

2.TCC模式：

TCC模式大体与AT模式相同，每个分支在执行完sql后立即提交事务，区别是在全局事务失败需要回滚时，TCC模式通过人工编码来实现数据恢复，无需人工手动恢复数据。

恢复数据需要实现3个方法：

• Try：资源的检测和预留； （对操作数据进行冻结）

• Confirm：完成资源操作业务；要求 Try 成功 Confirm 一定要能成功。（全局事务成功后删除冻结数据即可）

• Cancel：预留资源释放，可以理解为try的反向操作。（全局事务失败时需要回滚，将冻结数据添加至主数据内即可）

举例：

阶段一（Try）：检查余额是否充足，如果充足则冻结金额增加30元，可用余额扣除30

此时，总金额 = 冻结金额 + 可用金额，数量依然是100不变。事务直接提交无需等待其它事务。

阶段二（Confirm）：如果事务成功，将冻结金额扣除即可。

阶段三（Canncel）：如果事务失败，将冻结金额扣减30，可用余额增加30。

什么是空回滚：

当某分支事务的try阶段阻塞时，可能导致全局事务超时而触发二阶段的cancel操作。在未执行try操作时先执行了cancel操作，这时cancel不能做回滚，就是空回滚。

执行cancel操作时，应当判断try是否已经执行，如果尚未执行，则应该空回滚。

什么是业务悬挂：

对于已经空回滚的业务，之前被阻塞的try操作恢复，继续执行try，就永远不可能confirm或cancel ，事务一直处于中间状态，这就是业务悬挂。

执行try操作时，应当判断cancel是否已经执行过了，如果已经执行，应当阻止空回滚后的try操作，避免悬挂。

TCC的优点：

• 一阶段完成直接提交事务，释放数据库资源，性能好

• 相比AT模型，无需生成快照，无需使用全局锁，性能最强

• 不依赖数据库事务，而是依赖补偿操作，可以用于非事务型数据库

TCC的缺点：

• 有代码侵入，需要人为编写try、Confirm和Cancel接口，太麻烦

• 软状态，事务是最终一致

• 需要考虑Confirm和Cancel的失败情况，做好幂等处理

3.AT模式：

和XA模式最大的区别是就是分支在执行完SQL以后立刻提交事务，最后再由TC通知是否回滚。

一阶段：TM通知TC开启并注册全局事务，调用各分支，RM注册各分支事务，执行完sql后提交并保存执行前后的快照，RM报告事务状态。

二阶段：TM询问TC是提交还是回滚，TC检查各分支的状态后通知所有分支RM进行回滚恢复log数据或者删除log。

脏写问题：

由于分支事务1执行完sql以后直接提交事务，释放DB锁，如果此时有其他事务2再对此条数据进行修改，当分支事务1需要回滚时，会导致数据错误。

此时需要引入一个全局锁的概念，在事务1执行完sql后会获取全局锁（获取到全局锁后才能提交事务），其他事务在操作数据时由于无法获取全局锁，事务无法提交，必须等事务1完全结束释放全局锁后，才可以进行操作。

但如果事务2获取DB锁以后无法获取到全局锁，会导致DB锁无法释放，事务1也无法继续进行，所以这里事务2默认获取全局锁30次，间隔10毫秒，若超市直接事务回滚释放DB锁，交由事务1继续操作。

此时还有一个问题，如果事务2非seata管理的事务，就无需获取全局锁，所以log中必须记录sql执行前后的数据，在出现异常后记录异常，发送警告，由人工介入恢复数据。

AT模式的优点：

• 一阶段完成直接提交事务，释放数据库资源，性能比较好

• 利用全局锁实现读写隔离

• 没有代码侵入，框架自动完成回滚和提交

AT模式的缺点：

• 两阶段之间属于软状态，属于最终一致

• 框架的快照功能会影响性能，但比XA模式要好很多

4.SAGA模式

多家公司开发分布式项目时使用的分布式事务模式。

在 Saga 模式下，分布式事务内有多个参与者，每一个参与者都是一个冲正补偿服务，需要用户根据业务场景实现其正向操作和逆向回滚操作。

分布式事务执行过程中，依次执行各参与者的正向操作，如果所有正向操作均执行成功，那么分布式事务提交。如果任何一个正向操作执行失败，那么分布式事务会去退回去执行前面各参与者的逆向回滚操作，回滚已提交的参与者，使分布式事务回到初始状态。

Saga也分为两个阶段：

• 一阶段：直接提交本地事务

• 二阶段：成功则什么都不做；失败则通过编写补偿业务来回滚

SAGA模式的优点：

• 事务参与者可以基于事件驱动实现异步调用，吞吐高

• 一阶段直接提交事务，无锁，性能好

• 不用编写TCC中的三个阶段，实现简单

SAGA模式的缺点：

• 软状态持续时间不确定，时效性差

• 没有锁，没有事务隔离，会有脏写

8.三种模式实现方式?

1.XA模式

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

seata:
  data-source-proxy-mode: XA

 2）给发起全局事务的入口方法添加@GlobalTransactional注解。

3）重启服务并测试

重启order-service，再次测试，发现无论怎样，三个微服务都能成功回滚。

2.AT模式

1）导入数据库表，记录全局锁

导入Sql文件：seata-at.sql，其中lock_table导入到TC服务关联的数据库，undo_log表导入到微服务关联的数据库：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for 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;

-- ----------------------------
-- Records of undo_log
-- ----------------------------

-- ----------------------------
-- Table structure for 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;

SET FOREIGN_KEY_CHECKS = 1;

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

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

3.TCC模式

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;

其中：

• xid：是全局事务id

• freeze_money：用来记录用户冻结金额

• state：用来记录事务状态

2）声明TCC接口

TCC的Try、Confirm、Cancel方法都需要在接口中基于注解来声明，

我们在account-service项目中的cn.itcast.account.service包中新建一个接口，声明TCC三个接口：

package cn.itcast.account.service;

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 // 设置TCC模式
public interface TCCAccountService {
    /**
     * 从用户账户中扣款
     */
    // 此注解使用在try方法上,方法名称可以自定义
    // 预留冻结
    @TwoPhaseBusinessAction(name = "deduct",commitMethod = "confirm",rollbackMethod = "cancel")
    void deduct(
            @BusinessActionContextParameter(paramName = "userId") String userId,
            @BusinessActionContextParameter(paramName = "money") int money);
    // confirm: 提交
    // BusinessActionContext: 业务上下文对象
    void confirm(BusinessActionContext context);
    // cancel: 事务补偿
    void cancel(BusinessActionContext context);
}

3）编写实现类

在account-service服务中的cn.itcast.account.service.impl包下新建一个类，实现TCC业务：

package cn.itcast.account.service.impl;

import cn.itcast.account.entity.AccountFreeze;
import cn.itcast.account.mapper.AccountFreezeMapper;
import cn.itcast.account.mapper.AccountMapper;
import cn.itcast.account.service.TCCAccountService;
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;
import org.springframework.transaction.annotation.Transactional;

@Service
public class TCCAccountServiceImpl implements TCCAccountService {

    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private AccountFreezeMapper freezeMapper;

    // try阶段
    @Override
    @Transactional
    public void deduct(String userId, int money) {
        // 0.获取全局事务ID
        String xid = RootContext.getXID();
        // 1.查询account_freeze_tbl表,判断cancel是否执行
        AccountFreeze accountFreeze = freezeMapper.selectById(xid);
        if (accountFreeze!=null){
            // cancel执行过了.不再执行try
            if (accountFreeze.getState()==2){
                freezeMapper.deleteById(xid);
            }
            return;
        }
        // 1.冻结金额 -- 向冻结表中添加一条数据
        AccountFreeze freeze = new AccountFreeze();
        freeze.setUserId(userId);
        freeze.setFreezeMoney(money);
        freeze.setState(AccountFreeze.State.TRY);
        freeze.setXid(xid);
        freezeMapper.insert(freeze);
        // 2.从account表中减去冻结金额
        accountMapper.deduct(userId, money);
    }

    @Override
    @Transactional
    public void confirm(BusinessActionContext context) {
        // 删除冻结数据
        freezeMapper.deleteById(context.getXid());
    }

    @Override
    @Transactional
    public void cancel(BusinessActionContext context) {
        // 查看冻结数据状态,并执行补偿
        // 1.通过业务上下文对象获取
        String userId = context.getActionContext("userId").toString();
        Integer money = (Integer) context.getActionContext("money");
        String xid = context.getXid();
        // 2.判断try是否执行,如果未执行,则进行空回滚
        AccountFreeze accountFreeze = freezeMapper.selectById(xid);
        if (accountFreeze==null){
            // 添加一条记录,标准cancel执行过
            AccountFreeze freeze = new AccountFreeze();
            freeze.setUserId(userId);
            freeze.setFreezeMoney(money);
            freeze.setState(AccountFreeze.State.CANCEL);
            freeze.setXid(xid);
            freezeMapper.insert(freeze);
            return;
        }
        // 3.恢复可用金额
        accountMapper.refund(userId, money);
        // 4.移除冻结金额，修改事务状态
        freezeMapper.deleteById(context.getXid());
    }
}

4）编写实现类

在account-service服务中的cn.itcast.account.web.AccountController类中修改TCC类的调用:

package cn.itcast.account.web;

import cn.itcast.account.service.AccountService;
import cn.itcast.account.service.TCCAccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 
 */
@RestController
@RequestMapping("account")
public class AccountController {

    //@Autowired
    //private AccountService accountService;
    @Autowired
    private TCCAccountService accountService;
    @RequestMapping("/{userId}/{money}")
    public ResponseEntity<Void> deduct(@PathVariable("userId") String userId, @PathVariable("money") Integer money){
        accountService.deduct(userId, money);
        return ResponseEntity.noContent().build();
    }
}

9.seata实现高可用和异地容灾：

1.模拟异地容灾的TC集群

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

 

之前我们已经启动了一台seata服务，端口是8091，集群名为SH。

现在，将seata目录复制一份，起名为seata2

修改seata2/conf/registry.conf内容如下：

registry {
  # 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"
  }
}

config {
  # 读取tc服务端的配置文件的方式，这里是从nacos配置中心读取，这样如果tc是集群，可以共享配置
  type = "nacos"
  # 配置nacos地址等信息
  nacos {
    serverAddr = "127.0.0.1:8848"
    namespace = ""
    group = "SEATA_GROUP"
    username = "nacos"
    password = "nacos"
    dataId = "seataServer.properties"
  }
}

 进入seata2/bin目录，然后运行命令：

seata-server.bat -p 8092

 

2.将事务组映射配置到nacos

接下来，我们需要将tx-service-group与cluster的映射关系都配置到nacos配置中心。

新建一个配置 client.properties：

配置组名称: SEATA_GROUP

 配置的内容如下：

# 事务组映射关系
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

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来决定了。

10.seata完整配置文件：

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中的服务名称
  tx-service-group: seata-demo # 事务组，根据这个获取tc服务的cluster名称
  data-source-proxy-mode: AT  # 分布式事务模式
  config:  # 远程读取配置中心内配置
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      username: nacos
      password: nacos
      group: SEATA_GROUP
      data-id: client.properties