分布式事务控制方案seata理论与实践

理论：

1、本地事务与分布式事务

1.1、什么是事务？

        事务（Transaction）是指一组被视为单个逻辑单元的操作，这些操作要么全部成功完成，要么全部失败回滚，以确保数据的一致性和完整性。

        事务具有以下四个基本属性，通常被称为 ACID 特性：

1. 原子性（Atomicity）：事务是一个不可分割的操作序列，要么全部执行成功，要么全部失败回滚。在事务中的所有操作要么全部完成，要么全部取消。

2. 一致性（Consistency）：事务在执行前后，数据库的状态应该保持一致。即事务执行的结果必须使数据库从一个一致性状态转变到另一个一致性状态。

3. 隔离性（Isolation）：事务的执行应该是独立的，即事务的执行不应该受到其他事务的影响。每个事务应该是在系统中唯一执行的操作。

4. 持久性（Durability）：一旦事务提交，其结果应该是永久性的，即使系统发生故障，也不应该丢失事务的结果。事务提交后的更改应该被永久地保存在数据库中。

1.2、本地事务

        是在单个数据库实例上执行的事务。在本地事务中，所有的数据库操作都是在同一个数据库连接下完成的。

        例如，我现在需要进行更新订单状态和扣减库存的操作，订单表和库存表都在product数据库中，这就是本地事务。可以通过在方法上加@Transcational注解进行控制。

1.3、分布式事务

        分布式事务是指涉及多个数据库实例（或多个资源管理器）的事务。在分布式事务中，事务的操作可能横跨多个不同的系统、服务或数据库，并且每个系统可能具有自己的事务管理机制。

        在微服务分布式架构下，通常会将服务拆分为订单服务和库存服务。这就可能存在两种情况：

        1、订单服务，库存服务各自连接自己的订单数据库，库存数据库。

        2、订单服务，库存服务连接同一数据库。

        以上无论何种情况，都会存在分布式事务的问题：

        在情况1中，违背了所有的数据库操作都是在同一个数据库连接下完成的原则。

        在情况2中，两个微服务处于不同的进程，也无法使用本地事务进行控制。

        微服务分布式架构下，本地事务无法生效的主要原因：

1. 事务边界不一致：每个微服务的数据库连接是独立的，它们之间无法共享事务上下文。因此，无法跨越微服务边界形成统一的事务边界，导致无法实现分布式事务的 ACID 特性。

2. 无法保证隔离性：每个微服务的本地事务只能保证在自己的数据库连接范围内的隔离性，无法保证跨微服务的事务操作的隔离性。这可能导致数据的并发访问问题和事务的不一致。

3. 无法实现一致性：由于缺乏统一的事务管理机制，无法保证多个微服务之间的数据操作的一致性。即使一个微服务的本地事务失败回滚，其他微服务对同一数据的操作可能已经提交，导致数据不一致。

        那么有没有一种方案，可以实现对各个微服务间的事务做统一管理，协调各个微服务统一开启/提交/回滚事务？ 这就引出了seata。

2、seata

2.1、简介

        Seata是一款开源的分布式事务解决方案，致力于在微服务架构下提供高性能和简单易用的分布式事务服务，Seata 为用户提供了 AT、TCC、SAGA 和 XA 事务模式，为用户打造一站式的分布式解决方案。我们将以AT模式作为学习重点 。

2.2、seata的三大角色

事务协调器（Transaction Coordinator）：事务协调器是 Seata 中的核心组件之一，负责协调和管理分布式事务的执行过程。它主要负责以下几个方面的工作：

• 全局事务的创建和提交：事务协调器负责创建全局事务，以及协调全局事务的提交和回滚。

• 分支事务的注册和管理：在全局事务中，事务协调器负责管理分支事务的注册、执行和提交。

• 全局事务的状态管理：事务协调器负责监控和管理全局事务的状态，确保分布式事务能够正确执行。

事务参与者（Transaction Manager）：事务参与者是分布式事务中的执行单元，它负责实际的业务逻辑操作，参与到分布式事务的执行中。主要的工作包括：

• 注册分支事务：事务参与者在执行业务操作之前，需要向事务协调器注册分支事务。

• 执行业务操作：事务参与者执行实际的业务逻辑操作，可能包括数据库操作、消息发送等。

• 提交或回滚事务：根据事务协调器的指令，事务参与者负责提交或回滚自己的分支事务。

资源管理器（Resource Manager）：资源管理器是负责管理本地资源的组件，比如数据库、消息队列等。在 Seata 中，资源管理器与事务参与者紧密相关，主要的职责包括：

• 协调分支事务的执行：资源管理器负责协调事务参与者执行分支事务，保证业务操作的原子性和一致性。

• 实现分支事务的提交和回滚：根据事务协调器的指令，资源管理器负责实现分支事务的提交和回滚。

• 提供分布式事务的驱动：资源管理器提供分布式事务的驱动和集成，与事务协调器协同工作，实现分布式事务的执行。

TC为单独部署的Server服务端，TM和RM为客户端。

2.3、AT模式

AT模式是一种改进后的二阶段提交，相比TCC模式对业务的侵入性低。

在 Seata AT 模式中，事务的执行过程如下：

• 全局事务的创建：客户端发起一个分布式事务请求时，Seata 的事务协调器（TC）负责创建一个全局事务，并为该全局事务生成一个全局事务 ID（Global Transaction ID）。
• 分支事务注册：客户端的每个参与者服务（业务逻辑服务）在执行业务操作之前，通过 Seata 的事务参与者（TM）向事务协调器注册分支事务，并关联到全局事务 ID 上。
• 业务逻辑执行：每个参与者服务执行自己的业务逻辑操作，这些操作通常涉及到数据库的读写操作。
• 本地事务提交：当业务逻辑操作执行成功后，参与者服务使用本地数据库连接提交本地事务。这些本地事务操作依赖于数据库的原子性，保证了业务操作的一致性。
• 全局事务提交/回滚：当所有的分支事务都成功提交时，客户端发送提交请求给 Seata 的事务协调器，事务协调器将提交指令发送给所有的参与者服务，各个参与者服务根据指令提交自己的本地事务。如果任何一个分支事务提交失败或发生异常，事务协调器会发送回滚指令，各个参与者服务根据指令回滚自己的本地事务。

        在上述的流程中分为两个阶段：

        预处理阶段：协调者会通知所有参与者开启事务。参与者接到通知后，执行sql预处理，并记录原数据至undo,更新后的数据至redo，执行业务sql并生成行锁，向协调者注册分支事务，关联全局事务ID。所有的参与者会向协调者返回应答。如果所有参与者都返回成功，那么协调者就可以通知所有参与者提交事务。此时所有参与者处于阻塞状态。

        提交阶段：协调者向所有参与者发送提交请求。参与者在接收到请求后执行事务提交，提交完成后释放资源并返回结果。协调者接收到所有参与者的响应后，完成事务提交。此时将预处理阶段的redo结果正式入库。因为在预处理阶段业务sql已经执行，所以只需要删除预处理阶段的快照和行锁即可。

        提交阶段如果是回滚，则协调者向所有参与者发送rollback请求，参与者接收到请求后，使用预处理阶段的undo日志（原数据）进行事务回滚，还原业务数据，完成后释放资源，删除undo和redo以及行锁，向协调者发送响应。

        在还原前会先对比数据库当前的业务数据和更新后的数据是否一致，如果完全一致说明不存在脏写现象，可以还原。

2.4、AT模式存在的问题

• 数据一致性风险：在分布式环境下，由于各个服务的事务操作分散在不同的节点上，当涉及多个服务的事务操作时，可能无法保证全局数据的一致性。例如，如果某个服务在执行完事务操作后出现了异常，可能会导致其他服务的事务操作已经提交，此时全局数据处于不一致的状态。
• 性能损耗：Seata AT 模式需要进行分布式事务的协调和通信，这可能导致额外的性能损耗。特别是在事务量大、并发量高的情况下，分布式事务的协调和通信可能成为系统的瓶颈，影响系统的性能表现。
• 事务回滚的风险：当一个分支事务执行失败或者需要回滚时，需要协调所有涉及到的服务进行回滚操作。但在实践中，由于网络通信延迟、服务故障等原因，可能会导致事务回滚失败或者部分回滚，进而影响到全局事务的一致性和完整性。
• 单点故障：Seata AT 模式中的事务协调器是一个关键组件，它的故障可能会导致整个分布式事务的失败。如果事务协调器发生故障，可能会导致无法提交或回滚分布式事务，从而影响系统的可用性和稳定性。
• 同步阻塞：参与者在等待协调者的指令时，参与者无法进行其他操作，处于阻塞的状态，如果参与者一直接收不到协调者的消息，会持续处于阻塞状态，影响系统的可用性。

2.5、TCC模式（了解）

        TCC 模式通过将事务操作分解为三个阶段来实现分布式事务的管理，这三个阶段分别是 Try、Confirm 和 Cancel。

        TCC 模式的主要思想是将事务操作分解为三个阶段，并通过手动编码来确保这三个阶段的执行顺序和一致性。

• Try 阶段：在 Try 阶段，业务操作试图执行某些事务性操作，但并不直接将结果提交到数据库或者其他持久化存储系统中。而是将 Try 阶段的操作记录为一种预备操作，以便在后续的 Confirm 或 Cancel 阶段根据需要执行提交或者回滚。
• Confirm 阶段：在 Confirm 阶段，如果在 Try 阶段的操作成功执行后，系统会确认这些操作，并将其提交到数据库或其他持久化存储系统中。Confirm 阶段的操作通常用于提交 Try 阶段的预备操作，将其变为最终的稳定状态。
• Cancel 阶段：在 Cancel 阶段，如果在 Try 阶段的操作失败或者由于某种原因需要撤销，则系统会执行 Cancel 操作，将 Try 阶段的预备操作回滚或者撤销。Cancel 阶段的操作通常用于回滚 Try 阶段的预备操作，将其还原到原始状态。

实战：

下面将以springboot+nacos的方式演示seata的配置和使用：

seata官网：新人文档 | Apache Seata 

github地址：GitHub - apache/incubator-seata: :fire: Seata is an easy-to-use, high-performance, open source distributed transaction solution.

 需要下载

1、seata文件配置

我使用的seata版本为1.4.2

1.1、修改file.conf

## transaction log store, only used in seata-server
store {
  ## store mode: file、db、redis
  mode = "db"
  ## rsa decryption public key
  publicKey = ""
  ## file store property
 

  ## 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.cj.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/换成自己的数据库名?serverTimezone=Asia/Shanghai"
    user = "换成自己的用户名"
    password = "换成自己的密码"
    minConn = 5
    maxConn = 100
    globalTable = "global_table"
    branchTable = "branch_table"
    lockTable = "lock_table"
    queryLimit = 100
    maxWait = 5000
  }

  
}

1.2、修改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 = ""
    cluster = "default"
    username = "换成自己的nacos用户名"
    password = "换成自己的nacos密码"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3
  type = "nacos"

  nacos {
    serverAddr = "127.0.0.1:8848"
    namespace = ""
    group = "SEATA_GROUP"
     username = "换成自己的nacos用户名"
    password = "换成自己的nacos密码"
  }
}

注意：如果你的目录下没有logs文件夹，需要手动创建

如果你的mysql版本是8.0，需要删除lib目录下5.0的jar包

 1.3、修改config.txt

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
service.vgroupMapping.my_test_tx_group=default
service.default.grouplist=127.0.0.1:8091
service.enableDegrade=false
service.disableGlobalTransaction=false
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
client.tm.commitRetryCount=5
client.tm.rollbackRetryCount=5
client.tm.defaultGlobalTransactionTimeout=60000
client.tm.degradeCheck=false
client.tm.degradeCheckAllowTimes=10
client.tm.degradeCheckPeriod=2000
store.mode=db
store.publicKey=
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.cj.jdbc.Driver
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?serverTimezone=Asia/Shanghai
store.db.user=root
store.db.password=123456
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
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
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
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
log.exceptionRate=100
transport.serialization=seata
transport.compressor=none
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

1.4、上传config.txt至nacos

双击sh

 也可右键-git bash here

sh nacos-config.sh -h 192.168.2.169 -p 8848 -g SEATA_GROUP -t 命名空间id -u nacos -w nacos

1.5、执行数据库脚本

create table branch_table
(
    branch_id         bigint        not null
        primary key,
    xid               varchar(128)  not null,
    transaction_id    bigint        null,
    resource_group_id varchar(32)   null,
    resource_id       varchar(256)  null,
    branch_type       varchar(8)    null,
    status            tinyint       null,
    client_id         varchar(64)   null,
    application_data  varchar(2000) null,
    gmt_create        datetime(6)   null,
    gmt_modified      datetime(6)   null
)
    charset = utf8
    row_format = COMPACT;

create index idx_xid
    on branch_table (xid);

create table global_table
(
    xid                       varchar(128)  not null
        primary key,
    transaction_id            bigint        null,
    status                    tinyint       not null,
    application_id            varchar(32)   null,
    transaction_service_group varchar(32)   null,
    transaction_name          varchar(128)  null,
    timeout                   int           null,
    begin_time                bigint        null,
    application_data          varchar(2000) null,
    gmt_create                datetime      null,
    gmt_modified              datetime      null
)
    charset = utf8
    row_format = COMPACT;

create index idx_gmt_modified_status
    on global_table (gmt_modified, status);

create index idx_transaction_id
    on global_table (transaction_id);

create table lock_table
(
    row_key        varchar(128) not null
        primary key,
    xid            varchar(96)  null,
    transaction_id bigint       null,
    branch_id      bigint       not null,
    resource_id    varchar(256) null,
    table_name     varchar(32)  null,
    pk             varchar(36)  null,
    gmt_create     datetime     null,
    gmt_modified   datetime     null
)
    charset = utf8;

create index idx_branch_id
    on lock_table (branch_id);

2、springboot项目配置

2.1、创建项目

案例项目结构：

父工程：seata-demo

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.itbaima</groupId>
    <artifactId>seata-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>seata-demo</name>
    <description>seata-demo</description>
    <packaging>pom</packaging>
    <modules>
        <module>orders</module>
        <module>stock</module>
    </modules>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring-boot.version>2.3.12.RELEASE</spring-boot.version>
        <spring-cloud.version>Hoxton.SR9</spring-cloud.version>
        <spring-cloud-alibaba.version>2.2.6.RELEASE</spring-cloud-alibaba.version>
        <javax.servlet-api.version>4.0.1</javax.servlet-api.version>
        <fastjson.version>1.2.83</fastjson.version>
        <druid-spring-boot-starter.version>1.2.8</druid-spring-boot-starter.version>
        <mysql-connector-java.version>8.0.30</mysql-connector-java.version>
        <commons-lang.version>2.6</commons-lang.version>
        <commons-lang3.version>3.10</commons-lang3.version>
        <spring.version>5.3.20</spring.version>
        <slf4j-api.version>1.7.36</slf4j-api.version>
        <mybatis.spring>2.2.0</mybatis.spring>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>${mybatis.spring}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring-boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-alibaba-dependencies</artifactId>
                <version>${spring-cloud-alibaba.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Servlet 容器管理 -->
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>${javax.servlet-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <!-- fastjson ，json解析工具 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>fastjson</artifactId>
                <version>${fastjson.version}</version>
            </dependency>
            <!-- druid 连接池管理 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>${druid-spring-boot-starter.version}</version>
            </dependency>
            <!-- mySQL数据库驱动包管理 -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql-connector-java.version}</version>
            </dependency>
            <!-- 工具类管理 -->
            <dependency>
                <groupId>commons-lang</groupId>
                <artifactId>commons-lang</artifactId>
                <version>${commons-lang.version}</version>
            </dependency>
            <!--google推荐的一套工具类库-->
            <dependency>
                <groupId>com.google.guava</groupId>
                <artifactId>guava</artifactId>
                <version>25.0-jre</version>
            </dependency>
            <!--Spring boot单元测试-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <version>${spring-boot.version}</version>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>${commons-lang3.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>



</project>

子工程：stock、orders，下面是stock的pom.xml，orders同理。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>stock</artifactId>
    <parent>
        <artifactId>seata-demo</artifactId>
        <groupId>com.itbaima</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!-- MySQL 驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- Spring Boot 的 Spring Web MVC 集成 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- Spring Boot 集成 Junit -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!-- 排除 Spring Boot 依赖的日志包冲突 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- Spring Boot 集成 log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
        <!-- Spring Cloud 微服务远程调用 -->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--        seata依赖-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        </dependency>
    </dependencies>

</project>

2.2、配置文件

orders微服务的配置文件，stock同理。

server:
  port: 8081
spring:
  application:
    name: orders
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource
    password: 123456
    url: jdbc:mysql://127.0.0.1:3306/seata-demo-orders?serverTimezone=UTC&userUnicode=true&useSSL=false&
    username: root
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    alibaba:
      seata:
        tx-service-group: my_test_tx_group  
seata:
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848 #server所在的nacos地址
      username: nacos
      password: nacos
      group: SEATA_GROUP #seata server所在的组
      application: seata-server #seata server的服务名
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      username: nacos
      password: nacos
      group: SEATA_GROUP

其中，tx-service-group指向config.txt中：

application和group与nacos配置中心相对应：

 3、测试

3.1、启动项目，观察nacos注册中心

 3.2、业务代码

orders:

@Service
public class OrderServiceImpl implements IOrderService {

    @Autowired
    private GoodsOrderDao goodsOrderDao;

    @Autowired
    private FeignClient feignClient;

    @Override
    @GlobalTransactional
    public void handleOrderAndStock(Integer id) {
        //。。。。订单支付成功

        //修改订单状态为1
        goodsOrderDao.updateGoodsOrder(id);

        //远程调用减库存
        feignClient.hanldeStock(id);

         //手动制造异常
        int i = 1/0;

    }
}

stock:

@Service
public class StockServiceImpl implements IStockService {

    @Autowired
    private GoodsStockDao goodsStockDao;

    /**
     * 处理库存
     *
     * @param goodsId 商品Id
     */
    @Override
    @GlobalTransactional
    public void handleStock(Integer goodsId) {
        goodsStockDao.updateGoodsStock(goodsId);
    }
}

3.3、测试结论

此时执行到修改订单状态：

 订单状态发生修改，证明了业务数据修改是在AT模式中的预处理阶段进行的

 

订单库的undo表中有一条记录

---

 

此时执行到扣减库存

库存发生修改，证明了业务数据修改是在AT模式中的预处理阶段进行的

 

 库存库的undo表中有一条记录

 此时我们可以观察一下rollback_info的值：

{"@class":"io.seata.rm.datasource.undo.BranchUndoLog","xid":"192.168.101.1:8091:7647607864991203343","branchId":7647607864991203345,"sqlUndoLogs":["java.util.ArrayList",[{"@class":"io.seata.rm.datasource.undo.SQLUndoLog","sqlType":"UPDATE","tableName":"goods_stock","beforeImage":{"@class":"io.seata.rm.datasource.sql.struct.TableRecords","tableName":"goods_stock","rows":["java.util.ArrayList",[{"@class":"io.seata.rm.datasource.sql.struct.Row","fields":["java.util.ArrayList",[{"@class":"io.seata.rm.datasource.sql.struct.Field","name":"id","keyType":"PRIMARY_KEY","type":4,"value":1},{"@class":"io.seata.rm.datasource.sql.struct.Field","name":"stock","keyType":"NULL","type":4,"value":99}]]}]]},"afterImage":{"@class":"io.seata.rm.datasource.sql.struct.TableRecords","tableName":"goods_stock","rows":["java.util.ArrayList",[{"@class":"io.seata.rm.datasource.sql.struct.Row","fields":["java.util.ArrayList",[{"@class":"io.seata.rm.datasource.sql.struct.Field","name":"id","keyType":"PRIMARY_KEY","type":4,"value":1},{"@class":"io.seata.rm.datasource.sql.struct.Field","name":"stock","keyType":"NULL","type":4,"value":98}]]}]]}}]]}

解读：

• @class：这是 Java 对象的类名，标识了该对象的类型。
• xid：表示全局事务 ID，用于唯一标识一个全局事务。
• branchId：表示分支事务 ID，用于唯一标识一个分支事务。
• sqlUndoLogs：表示该分支事务执行的 SQL 操作的回滚日志，是一个数组，包含多个 SQLUndoLog 对象。
• SQLUndoLog：表示一条 SQL 操作的回滚日志，包含了该 SQL 操作的类型、操作的表名、操作前后的数据信息等。
• sqlType：表示 SQL 操作的类型，例如 UPDATE、INSERT、DELETE 等。
• tableName：表示 SQL 操作涉及的表名。
• beforeImage：表示 SQL 操作之前的数据状态，是一个 TableRecords 对象，包含了操作前的表记录信息。
• afterImage：表示 SQL 操作之后的数据状态，是一个 TableRecords 对象，包含了操作后的表记录信息。
• TableRecords：表示一张表的记录信息，包含了多条 Row 记录。

由此证明了：AT模式的预处理阶段在执行sql预处理时，会保存beforeImage和afterImage至各自业务库中的undolog表，并且在需要时根据afterImage进行回滚。完成操作后清理表中资源。

---

出现异常后，订单表和库存表都进行了回滚