《微服务实战》第二十九章分布式事务框架seata AT模式

缺乏、安全感 2023-10-12 13:46 10阅读 0赞

## 系列文章目录 ##

[第三十章 分布式事务框架seata TCC模式][_seata TCC]  
[第二十九章 分布式事务框架seata AT模式][_seata AT]

![在这里插入图片描述][41c2aaf0603d4b15817852adc5ad8732.png]

--------------------

#### 文章目录 ####

*  系列文章目录
 *  前言
 *  1、概念
 *  2、AT模式
 *   *  2.1、应用前提
     *  2.2、两阶段提交概念
     *  2.3、写隔离
     *  2.4、读隔离
     *  2.5、AT模式工作过程的案例
     *   *  2.5.1、一阶段
         *  2.5.2、 二阶段-回滚
         *  2.5.3、二阶段-提交
 *  3、spring cloud 与seata整合
 *   *  3.1、seata配置
     *   *  3.1.1、修改配置文件
         *   *  3.1.1.1、conf/file.conf 修改成db模式
             *  3.1.1.2、conf/registry.conf
             *  3.1.1.3、下载config.tex
             *  3.1.1.4、下载nacos-config.sh到conf
         *  3.1.2、导入数据库
         *  3.1.3、启动seata server
     *  3.2、用例
     *   *  3.2.1、项目配置
         *   *  3.2.1.1、创建四个服务
             *  3.2.1.2、每个业务数据库增加回滚表
             *  3.2.1.3、执行业务表脚本
         *  3.2.2、common-service中添加依赖
         *  3.2.3、加配置
         *  3.2.4、定义数据库代理

--------------------

## 前言 ##

本章节介绍微服务分布式项目中，使用的事务框架seata。  
官网：http://seata.io/zh-cn/  
springcloud-nacos-seata：https://github.com/seata/seata-samples/tree/master/springcloud-nacos-seata

## 1、概念 ##

Seata 是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata 将为用户提供了 AT、TCC、SAGA 和 XA 事务模式，为用户打造一站式的分布式解决方案。  
![在这里插入图片描述][08457c08ce36422da0d9d948ddab0587.png]

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

## 2、AT模式 ##

### 2.1、应用前提 ###

*  基于支持本地 ACID 事务的关系型数据库。
 *  Java 应用，通过 JDBC 访问数据库。
 *  文件操作与关系型数据库操作

### 2.2、两阶段提交概念 ###

*  一阶段：业务数据和回滚日志记录在同一个本地事务中提交，释放本地锁和连接资源。
 *  二阶段：  
    提交异步化，非常快速地完成。  
    回滚通过一阶段的回滚日志进行反向补偿。

### 2.3、写隔离 ###

*  一阶段本地事务提交前，需要确保先拿到 全局锁 。
 *  拿不到 全局锁 ，不能提交本地事务。
 *  拿 全局锁 的尝试被限制在一定范围内，超出范围将放弃，并回滚本地事务，释放本地锁  
    ![在这里插入图片描述][6a8452edb44f44ae851c3b727b3a34d8.png]

两个全局事务 tx1 和 tx2，分别对 a 表的 m 字段进行更新操作，m 的初始值 1000。  
tx1 先开始，开启本地事务，拿到本地锁，更新操作 m = 1000 - 100 = 900。本地事务提交前，先拿到该记录的 全局锁 ，本地提交释放本地锁。 tx2 后开始，开启本地事务，拿到本地锁，更新操作 m = 900 - 100 = 800。本地事务提交前，尝试拿该记录的 全局锁 ，tx1 全局提交前，该记录的全局锁被 tx1 持有，tx2 需要重试等待 全局锁 。

tx1 二阶段全局提交，释放 全局锁 。tx2 拿到 全局锁 提交本地事务。  
![在这里插入图片描述][d729f6111f83475daa20cf65735e1e1a.png]  
如果 tx1 的二阶段全局回滚，则 tx1 需要重新获取该数据的本地锁，进行反向补偿的更新操作，实现分支的回滚。

此时，如果 tx2 仍在等待该数据的 全局锁，同时持有本地锁，则 tx1 的分支回滚会失败。分支的回滚会一直重试，直到 tx2 的 全局锁 等锁超时，放弃 全局锁 并回滚本地事务释放本地锁，tx1 的分支回滚最终成功。  
因为整个过程 全局锁 在 tx1 结束前一直是被 tx1 持有的，所以不会发生 脏写 的问题。

### 2.4、读隔离 ###

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

如果应用在特定场景下，必需要求全局的 读已提交 ，目前 Seata 的方式是通过 SELECT FOR UPDATE 语句的代理。  
![在这里插入图片描述][3f48f19730334e2086f35f6bea5f8203.png]  
SELECT FOR UPDATE 语句的执行会申请 全局锁 ，如果 全局锁 被其他事务持有，则释放本地锁（回滚 SELECT FOR UPDATE 语句的本地执行）并重试。这个过程中，查询是被 block 住的，直到 全局锁 拿到，即读取的相关数据是 已提交 的，才返回。

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

### 2.5、AT模式工作过程的案例 ###

业务表：product

<table> 
 <thead> 
  <tr> 
   <th align="left">Field</th> 
   <th align="left">Type</th> 
   <th align="left">Key</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">id</td> 
   <td align="left">bigint(20)</td> 
   <td align="left">PRI</td> 
  </tr> 
  <tr> 
   <td align="left">name</td> 
   <td align="left">varchar(100)</td> 
   <td align="left"></td> 
  </tr> 
  <tr> 
   <td align="left">since</td> 
   <td align="left">varchar(100)</td> 
   <td align="left"></td> 
  </tr> 
 </tbody> 
</table>

AT 分支事务的业务逻辑：

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

#### 2.5.1、一阶段 ####

过程：

> > 解析 SQL：得到 SQL 的类型（UPDATE），表（product），条件（where name = ‘TXC’）等相关的信息。  
> > 查询前镜像：根据解析得到的条件信息，生成查询语句，定位数据。

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

得到前镜像：

<table> 
 <thead> 
  <tr> 
   <th align="left">id</th> 
   <th align="left">name</th> 
   <th align="left">since</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">TXC</td> 
   <td align="left">2014</td> 
  </tr> 
 </tbody> 
</table>

> > 执行业务 SQL：更新这条记录的 name 为 ‘GTS’。  
> > 查询后镜像：根据前镜像的结果，通过 主键 定位数据。

select id, name, since from product where id = 1;

得到后镜像：

<table> 
 <thead> 
  <tr> 
   <th align="left">id</th> 
   <th align="left">name</th> 
   <th align="left">since</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">1</td> 
   <td align="left">GTS</td> 
   <td align="left">2014</td> 
  </tr> 
 </tbody> 
</table>

> > 插入回滚日志：把前后镜像数据以及业务 SQL 相关的信息组成一条回滚日志记录，插入到  
> > UNDO\_LOG 表中。

{
        
        "branchId": 641789253,
        "undoItems": [{
        
            "afterImage": {
        
                "rows": [{
        
                    "fields": [{
        
                        "name": "id",
                        "type": 4,
                        "value": 1
                    }, {
        
                        "name": "name",
                        "type": 12,
                        "value": "GTS"
                    }, {
        
                        "name": "since",
                        "type": 12,
                        "value": "2014"
                    }]
                }],
                "tableName": "product"
            },
            "beforeImage": {
        
                "rows": [{
        
                    "fields": [{
        
                        "name": "id",
                        "type": 4,
                        "value": 1
                    }, {
        
                        "name": "name",
                        "type": 12,
                        "value": "TXC"
                    }, {
        
                        "name": "since",
                        "type": 12,
                        "value": "2014"
                    }]
                    
                }],
                "tableName": "product"
            },
            "sqlType": "UPDATE"
        }],
        "xid": "xid:xxx"
    }

> > 提交前，向 TC 注册分支：申请  
> > product 表中，主键值等于 1 的记录的 全局锁 。

> > 本地事务提交：业务数据的更新和前面步骤中生成的 UNDO LOG 一并提交。

> > 将本地事务提交的结果上报给 TC。

#### 2.5.2、 二阶段-回滚 ####

> > 收到 TC 的分支回滚请求，开启一个本地事务，执行如下操作。

> > 通过 XID 和 Branch ID 查找到相应的 UNDO LOG 记录。

> > 数据校验：拿 UNDO LOG 中的后镜与当前数据进行比较，如果有不同，说明数据被当前全局事务之外的动作做了修改。这种情况，需要根据配置策略来做处理，详细的说明在另外的文档中介绍。

> > 根据 UNDO LOG 中的前镜像和业务 SQL 的相关信息生成并执行回滚的语句：

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

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

#### 2.5.3、二阶段-提交 ####

> > 收到 TC 的分支提交请求，把请求放入一个异步任务的队列中，马上返回提交成功的结果给 TC。

> > 异步任务阶段的分支提交请求将异步和批量地删除相应 UNDO LOG 记录。

## 3、spring cloud 与seata整合 ##

![在这里插入图片描述][265fb21282524800bf7f842fa17fba71.png]

### 3.1、seata配置 ###

下载地址：https://github.com/seata/seata/releases/download/v1.4.2/seata-server-1.4.2.zip  
**解压到D盘**

#### 3.1.1、修改配置文件 ####

##### 3.1.1.1、conf/file.conf 修改成db模式 #####

## transaction log store, only used in seata-server
    store {
        
      ## store mode: file、db、redis
      mode = "db"
      ## rsa decryption public key
      publicKey = ""
      ## file store property
      file {
        
        ## store location dir
        dir = "sessionStore"
        # branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
        maxBranchSessionSize = 16384
        # globe session size , if exceeded throws exceptions
        maxGlobalSessionSize = 512
        # file buffer size , if exceeded allocate new buffer
        fileWriteBufferCacheSize = 16384
        # when recover batch read size
        sessionReloadReadSize = 100
        # async, sync
        flushDiskMode = async
      }
    
      ## database store property
      db {
        
        ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp)/HikariDataSource(hikari) etc.
        datasource = "druid"
        ## mysql/oracle/postgresql/h2/oceanbase etc.
        dbType = "mysql"
        driverClassName = "com.mysql.jdbc.Driver"
        ## if using mysql to store the data, recommend add rewriteBatchedStatements=true in jdbc connection param
        url = "jdbc:mysql://127.0.0.1:3306/seata?rewriteBatchedStatements=true"
        user = "root"
        password = "root"
        minConn = 5
        maxConn = 100
        globalTable = "global_table"
        branchTable = "branch_table"
        lockTable = "lock_table"
        queryLimit = 100
        maxWait = 5000
      }
    
      ## redis store property
      redis {
        
        ## redis mode: single、sentinel
        mode = "single"
        ## single mode property
        single {
        
          host = "127.0.0.1"
          port = "6379"
        }
        ## sentinel mode property
        sentinel {
        
          masterName = ""
          ## such as "10.28.235.65:26379,10.28.235.65:26380,10.28.235.65:26381"
          sentinelHosts = ""
        }
        password = ""
        database = "0"
        minConn = 1
        maxConn = 10
        maxTotal = 100
        queryLimit = 100
      }
    }

##### 3.1.1.2、conf/registry.conf #####

registry {
        
      # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
      type = "nacos"
    
      nacos {
        
        application = "seata-server"
        serverAddr = "127.0.0.1:8848"
        group = "SEATA_GROUP"
        namespace = "1ff3782d-b62d-402f-8bc4-ebcf40254d0a"
        cluster = "default"
        username = "nacos"
        password = "nacos"
      }
      eureka {
        
        serviceUrl = "http://localhost:8761/eureka"
        application = "default"
        weight = "1"
      }
      redis {
        
        serverAddr = "localhost:6379"
        db = 0
        password = ""
        cluster = "default"
        timeout = 0
      }
      zk {
        
        cluster = "default"
        serverAddr = "127.0.0.1:2181"
        sessionTimeout = 6000
        connectTimeout = 2000
        username = ""
        password = ""
      }
      consul {
        
        cluster = "default"
        serverAddr = "127.0.0.1:8500"
        aclToken = ""
      }
      etcd3 {
        
        cluster = "default"
        serverAddr = "http://localhost:2379"
      }
      sofa {
        
        serverAddr = "127.0.0.1:9603"
        application = "default"
        region = "DEFAULT_ZONE"
        datacenter = "DefaultDataCenter"
        cluster = "default"
        group = "SEATA_GROUP"
        addressWaitTime = "3000"
      }
      file {
        
        name = "file.conf"
      }
    }
    
    config {
        
      # file、nacos 、apollo、zk、consul、etcd3
      type = "file"
    
      nacos {
        
        serverAddr = "127.0.0.1:8848"
        namespace = ""
        group = "SEATA_GROUP"
        username = "nacos"
        password = "nacos"
        dataId = "seataServer.properties"
      }
      consul {
        
        serverAddr = "127.0.0.1:8500"
        aclToken = ""
      }
      apollo {
        
        appId = "seata-server"
        ## apolloConfigService will cover apolloMeta
        apolloMeta = "http://192.168.1.204:8801"
        apolloConfigService = "http://192.168.1.204:8080"
        namespace = "application"
        apolloAccesskeySecret = ""
        cluster = "seata"
      }
      zk {
        
        serverAddr = "127.0.0.1:2181"
        sessionTimeout = 6000
        connectTimeout = 2000
        username = ""
        password = ""
        nodePath = "/seata/seata.properties"
      }
      etcd3 {
        
        serverAddr = "http://localhost:2379"
      }
      file {
        
        name = "file.conf"
      }
    }

**注意：nacos命名空间namespace定义成自己的。**

##### 3.1.1.3、下载config.tex #####

https://github.com/seata/seata/tree/develop/script/config-center/config.text 保存到seata根目录，文件名config.txt

#For details about configuration items, see https://seata.io/zh-cn/docs/user/configurations.html
    #Transport configuration, for client and server
    transport.type=TCP
    transport.server=NIO
    transport.heartbeat=true
    transport.enableTmClientBatchSendRequest=false
    transport.enableRmClientBatchSendRequest=true
    transport.enableTcServerBatchSendResponse=false
    transport.rpcRmRequestTimeout=30000
    transport.rpcTmRequestTimeout=30000
    transport.rpcTcRequestTimeout=30000
    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
    transport.serialization=seata
    transport.compressor=none
    #Transaction routing rules configuration, only for the client
    service.vgroupMapping.default_tx_group=default
    #If you use a registry, you can ignore it
    service.default.grouplist=127.0.0.1:8091
    service.enableDegrade=false
    service.disableGlobalTransaction=false
    #Transaction rule configuration, only for the client
    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=true
    client.rm.tableMetaCheckerInterval=60000
    client.rm.sqlParserType=druid
    client.rm.reportSuccessEnable=false
    client.rm.sagaBranchRegisterEnable=false
    client.rm.sagaJsonParser=fastjson
    client.rm.tccActionInterceptorOrder=-2147482648
    client.tm.commitRetryCount=5
    client.tm.rollbackRetryCount=5
    client.tm.defaultGlobalTransactionTimeout=60000
    client.tm.degradeCheck=false
    client.tm.degradeCheckAllowTimes=10
    client.tm.degradeCheckPeriod=2000
    client.tm.interceptorOrder=-2147482648
    client.undo.dataValidation=true
    client.undo.logSerialization=jackson
    client.undo.onlyCareUpdateColumns=true
    server.undo.logSaveDays=7
    server.undo.logDeletePeriod=86400000
    client.undo.logTable=undo_log
    client.undo.compress.enable=true
    client.undo.compress.type=zip
    client.undo.compress.threshold=64k
    #For TCC transaction mode
    tcc.fence.logTableName=tcc_fence_log
    tcc.fence.cleanPeriod=1h
    #Log rule configuration, for client and server
    log.exceptionRate=100
    #Transaction storage configuration, only for the server. The file, db, and redis configuration values are optional.
    store.mode=db
    store.lock.mode=db
    store.session.mode=db
    #Used for password encryption
    store.publicKey=
    #If store.mode,store.lock.mode,store.session.mode are not equal to file, you can remove the configuration block.
    store.file.dir=file_store/data
    store.file.maxBranchSessionSize=16384
    store.file.maxGlobalSessionSize=512
    store.file.fileWriteBufferCacheSize=16384
    store.file.flushDiskMode=async
    store.file.sessionReloadReadSize=100
    #These configurations are required if the store mode is db. If store.mode,store.lock.mode,store.session.mode are not equal to db, you can remove the configuration block.
    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=root
    store.db.minConn=5
    store.db.maxConn=30
    store.db.globalTable=global_table
    store.db.branchTable=branch_table
    store.db.distributedLockTable=distributed_lock
    store.db.queryLimit=100
    store.db.lockTable=lock_table
    store.db.maxWait=5000
    #These configurations are required if the store mode is redis. If store.mode,store.lock.mode,store.session.mode are not equal to redis, you can remove the configuration block.
    store.redis.mode=single
    store.redis.single.host=127.0.0.1
    store.redis.single.port=6379
    store.redis.sentinel.masterName=
    store.redis.sentinel.sentinelHosts=
    store.redis.maxConn=10
    store.redis.minConn=1
    store.redis.maxTotal=100
    store.redis.database=0
    store.redis.password=
    store.redis.queryLimit=100
    #Transaction rule configuration, only for the server
    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.distributedLockExpireTime=10000
    server.xaerNotaRetryTimeout=60000
    server.session.branchAsyncQueueSize=5000
    server.session.enableBranchAsyncRemove=false
    server.enableParallelRequestHandle=false
    #Metrics configuration, only for the server
    metrics.enabled=false
    metrics.registryType=compact
    metrics.exporterList=prometheus
    metrics.exporterPrometheusPort=9898

##### 3.1.1.4、下载nacos-config.sh到conf #####

然后执行命令：sh nacos-config.sh -h localhost -p 8848 -g SEATA\_GROUP -t 1ff3782d-b62d-402f-8bc4-ebcf40254d0a -u nacos -w nacos  
把seata配置同步到nacos  
![在这里插入图片描述][125ddf92ed6f44f584370bd041d64f2b.png]

#### 3.1.2、导入数据库 ####

创建数据库：create database seata;  
然后执行以下的脚本。  
https://github.com/seata/seata/blob/2.x/script/server/db/mysql.sql  
global\_table： 全局事务表，每当有一个全局事务发起后，就会在该表中记录全局事务的ID  
branch\_table： 分支事务表，记录每一个分支事务的 ID，分支事务操作的哪个数据库等信息  
lock\_table： 全局锁

#### 3.1.3、启动seata server ####

D:\\seata\\seata-server-1.4.2\\bin\\seata-server.bat

### 3.2、用例 ###

用户购买商品的业务逻辑。整个业务逻辑由3个微服务提供支持：

*  仓储服务：对给定的商品扣除仓储数量。
 *  订单服务：根据采购需求创建订单。
 *  帐户服务：从用户帐户中扣除余额。  
    ![在这里插入图片描述][126a6ef02df3445c86d52f4a1b85a914.png]  
    解决方案：  
    ![在这里插入图片描述][5d5212a8d2bb46908dc25e939a7bc779.png]

#### 3.2.1、项目配置 ####

##### 3.2.1.1、创建四个服务 #####

order-service（对应order数据库）  
account-service（对应account数据库）  
storage-service（对应storage数据库）  
business-service

##### 3.2.1.2、每个业务数据库增加回滚表 #####

CREATE TABLE `undo_log` (
      `id` bigint(20) NOT NULL AUTO_INCREMENT,
      `branch_id` bigint(20) NOT NULL,
      `xid` varchar(100) NOT NULL,
      `context` varchar(128) NOT NULL,
      `rollback_info` longblob NOT NULL,
      `log_status` int(11) NOT NULL,
      `log_created` datetime NOT NULL,
      `log_modified` datetime NOT NULL,
      `ext` varchar(100) DEFAULT NULL,
      PRIMARY KEY (`id`),
      UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

##### 3.2.1.3、执行业务表脚本 #####

USE storage;
    DROP TABLE IF EXISTS `storage_tbl`;
    CREATE TABLE `storage_tbl` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `commodity_code` varchar(255) DEFAULT NULL,
      `count` int(11) DEFAULT 0,
      PRIMARY KEY (`id`),
      UNIQUE KEY (`commodity_code`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    USE order;
    DROP TABLE IF EXISTS `order_tbl`;
    CREATE TABLE `order_tbl` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `user_id` varchar(255) DEFAULT NULL,
      `commodity_code` varchar(255) DEFAULT NULL,
      `count` int(11) DEFAULT 0,
      `money` int(11) DEFAULT 0,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
    
    USE account;
    DROP TABLE IF EXISTS `account_tbl`;
    CREATE TABLE `account_tbl` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `user_id` varchar(255) DEFAULT NULL,
      `money` int(11) DEFAULT 0,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

#### 3.2.2、common-service中添加依赖 ####

<dependency>
        <groupId>io.seata</groupId>
        <artifactId>seata-spring-boot-starter</artifactId>
        <version>1.4.2</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        <version>2021.0.4.0</version>
    </dependency>

#### 3.2.3、加配置 ####

seata:
      enabled: true
      enable-auto-data-source-proxy: false
      application-id: vforumc-user
      tx-service-group: default_tx_group
      service:
        vgroup-mapping:
          default_tx_group: default
        disable-global-transaction: false
      registry:
        type: nacos
        nacos:
          application: seata-server
          server-addr: 127.0.0.1:8848
          namespace: 1ff3782d-b62d-402f-8bc4-ebcf40254d0a
          group: SEATA_GROUP
          username: nacos
          password: nacos
      config:
        nacos:
          server-addr: 127.0.0.1:8848
          namespace: 1ff3782d-b62d-402f-8bc4-ebcf40254d0a
          group: SEATA_GROUP
          username: nacos
          password: nacos

#### 3.2.4、定义数据库代理 ####

package com.xxxx.store.account.config;
    
    import lombok.Data;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Configuration;
    
    @Data
    @Configuration
    public class DataSourceConfig {
        
        @Value("${spring.datasource.url}")
        private String url;
    
        @Value("${spring.datasource.username}")
        private String username;
    
        @Value("${spring.datasource.password}")
        private String password;
    
        @Value("${spring.datasource.driver-class-name}")
        private String driveClassName;
    }

package com.xxxx.store.account.config;
    
    import com.zaxxer.hikari.HikariDataSource;
    import io.seata.rm.datasource.DataSourceProxy;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Primary;
    
    import javax.annotation.Resource;
    import javax.sql.DataSource;
    
    /**
     * 数据源代理
     */
    @Configuration
    public class DataSourceProxyConfig {
        
        @Resource
        private DataSourceConfig dataSourceConfig;
    
        @Bean("dataSource")
        public DataSource druidDataSource() {
        
            HikariDataSource hikariDataSource = new HikariDataSource();
            hikariDataSource.setUsername(dataSourceConfig.getUsername());
            hikariDataSource.setPassword(dataSourceConfig.getPassword());
            hikariDataSource.setJdbcUrl(dataSourceConfig.getUrl());
            hikariDataSource.setDriverClassName(dataSourceConfig.getDriveClassName());
            return hikariDataSource;
        }
    
        @Bean
        @Primary
        public DataSourceProxy dataSourceProxy(DataSource dataSource) {
        
            return new DataSourceProxy(dataSource);
        }
    }

每个业务服务启动类加上注解，把自动配置的数据源剔除掉，让以上代理的数据源生效

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)

[_seata TCC]: https://blog.csdn.net/s445320/article/details/131150756
[_seata AT]: https://blog.csdn.net/s445320/article/details/131147965
[41c2aaf0603d4b15817852adc5ad8732.png]: https://img-blog.csdnimg.cn/41c2aaf0603d4b15817852adc5ad8732.png
[08457c08ce36422da0d9d948ddab0587.png]: https://img-blog.csdnimg.cn/08457c08ce36422da0d9d948ddab0587.png
[6a8452edb44f44ae851c3b727b3a34d8.png]: https://img-blog.csdnimg.cn/6a8452edb44f44ae851c3b727b3a34d8.png
[d729f6111f83475daa20cf65735e1e1a.png]: https://img-blog.csdnimg.cn/d729f6111f83475daa20cf65735e1e1a.png
[3f48f19730334e2086f35f6bea5f8203.png]: https://img-blog.csdnimg.cn/3f48f19730334e2086f35f6bea5f8203.png
[265fb21282524800bf7f842fa17fba71.png]: https://img-blog.csdnimg.cn/265fb21282524800bf7f842fa17fba71.png
[125ddf92ed6f44f584370bd041d64f2b.png]: https://img-blog.csdnimg.cn/125ddf92ed6f44f584370bd041d64f2b.png
[126a6ef02df3445c86d52f4a1b85a914.png]: https://img-blog.csdnimg.cn/126a6ef02df3445c86d52f4a1b85a914.png
[5d5212a8d2bb46908dc25e939a7bc779.png]: https://img-blog.csdnimg.cn/5d5212a8d2bb46908dc25e939a7bc779.png