1
2
3
4
5
6
7
8

[业务服务 A]                 [Seata Server]              [业务服务 B]
  TM ──Begin Global Tx──>     TC                        RM(B)
  RM(A) ──Register Branch──>  │ <──Register Branch───   TM(B)
       <──Branch ID───────────│                          
  ... 业务执行 + 本地事务 ...  
  RM(A) ──Branch Report────>  │ <──Branch Report────   RM(B)
  TM ──Commit/Rollback────>   │                          
       <──Branch Commit───────│ <──Branch Commit──────>  RM(B)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

CREATE TABLE `undo_log` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `branch_id` bigint NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int 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 DEFAULT CHARSET=utf8mb4;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

1. 业务执行 UPDATE t_account SET balance = balance - 100 WHERE id = 1
2. Seata DataSourceProxy 拦截 SQL，解析出：
   - 表名: t_account
   - WHERE 条件: id = 1
   - 修改字段: balance
3. Seata 先执行 SELECT * FROM t_account WHERE id = 1（拿 beforeImage）
4. Seata 执行原 UPDATE（业务 SQL 正常跑）
5. Seata 再执行 SELECT * FROM t_account WHERE id = 1（拿 afterImage）
6. Seata 把 (beforeImage, afterImage, sqlType, tableName) 序列化成 JSON
7. Seata 写入 undo_log 表（跟业务 SQL 在同一个本地事务里）
8. 本地事务 commit（业务数据 + undo_log 一起 commit）
9. RM 向 TC 上报分支状态

1
2
3
4
5
6
7

1. TC 通知 RM 全局回滚
2. RM 从 undo_log 读 beforeImage
3. Seata 根据 beforeImage 生成反向 SQL：
   - 原 SQL: UPDATE t_account SET balance = balance - 100 WHERE id = 1
   - 反向 SQL: UPDATE t_account SET balance = balance + 100 WHERE id = 1
4. 执行反向 SQL，把数据改回 beforeImage
5. 删除 undo_log 记录

1
2
3
4
5
6

# 下载 Seata Server
wget https://github.com/apache/incubator-seata/releases/download/v1.8.0/seata-server-1.8.0.tar.gz
tar -xzf seata-server-1.8.0.tar.gz
cd seata-server-1.8.0
# 启动（默认 8091 端口）
sh bin/seata-server.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# Seata Server 的 application.yml
server:
  port: 8091
spring:
  application:
    name: seata-server
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.100:8848
seata:
  config:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      group: SEATA_GROUP
      data-id: seataServer.properties
  registry:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      application: seata-server
      group: SEATA_GROUP

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# values.yaml 关键配置
replicaCount: 3
image:
  repository: apache/seata-server
  tag: 1.8.0
service:
  type: ClusterIP
  port: 8091
nacos:
  serverAddr: nacos-server:8848

1
2
3
4
5
6
7
8

// 单体应用伪代码
@Transactional
public void createOrder(OrderDTO order) {
    orderDao.insert(order);              // 订单
    accountDao.deduct(order.userId, ...); // 账户
    stockDao.deduct(order.skuId, ...);   // 库存
    notifyService.send(...);              // 通知
}

1
2
3
4
5
6
7
8

// 订单服务
@Transactional
public void createOrder(OrderDTO order) {
    orderDao.insert(order);  // 订单服务本地事务
    // 远程调用
    accountClient.deduct(order.userId, order.amount);  // 账户服务本地事务（独立）
    stockClient.deduct(order.skuId, order.quantity);   // 库存服务本地事务（独立）
}

1
2
3
4
5
6
7
8
9

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

seata:
  application-id: ${spring.application.name}
  tx-service-group: my_tx_group  # 事务组名
  registry:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      namespace: seata-ns
      group: SEATA_GROUP
      application: seata-server
  config:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      namespace: seata-ns
      group: SEATA_GROUP
      data-id: seataServer.properties
  data-source-proxy-mode: AT  # 选 AT / TCC / SAGA / XA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 订单服务 - 业务方法加 @GlobalTransactional
@Service
public class OrderService {
    @Autowired
    private AccountClient accountClient;
    @Autowired
    private StockClient stockClient;

    @GlobalTransactional(name = "create-order-tx", rollbackFor = Exception.class)
    public Order createOrder(OrderDTO dto) {
        // 1. 创建订单（本地事务）
        orderDao.insert(dto);
        // 2. 远程扣库存（分布式事务分支）
        stockClient.deduct(dto.getSkuId(), dto.getQuantity());
        // 3. 远程扣账户（分布式事务分支）
        accountClient.deduct(dto.getUserId(), dto.getAmount());
        return order;
    }
}

1
2
3

order-service（订单）
    ├─ 调 stock-service.deduct()  # 扣库存
    └─ 调 account-service.deduct() # 扣账户

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

server:
  port: 8081
spring:
  application:
    name: order-service
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://192.168.1.101:3306/seata_order?useUnicode=true&characterEncoding=utf8
    username: root
    password: 123456
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.1.100:8848
seata:
  tx-service-group: my_tx_group
  registry:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      application: seata-server
  config:
    type: nacos
    nacos:
      server-addr: 192.168.1.100:8848
      data-id: seataServer.properties

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@FeignClient(name = "stock-service", path = "/stock")
public interface StockClient {
    @PostMapping("/deduct")
    Result deduct(@RequestParam Long skuId, @RequestParam Integer quantity);
}

@FeignClient(name = "account-service", path = "/account")
public interface AccountClient {
    @PostMapping("/deduct")
    Result deduct(@RequestParam Long userId, @RequestParam BigDecimal amount);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

@Service
@Slf4j
public class OrderService {
    @Autowired
    private OrderDao orderDao;
    @Autowired
    private StockClient stockClient;
    @Autowired
    private AccountClient accountClient;

    @GlobalTransactional(name = "create-order-tx", rollbackFor = Exception.class)
    public Order createOrder(OrderDTO dto) {
        log.info("开始创建订单, XID = {}", RootContext.getXID());

        // 1. 创建订单（本地事务 + Seata 自动生成 undo_log）
        Order order = new Order();
        order.setUserId(dto.getUserId());
        order.setSkuId(dto.getSkuId());
        order.setQuantity(dto.getQuantity());
        order.setAmount(dto.getAmount());
        order.setStatus("CREATED");
        orderDao.insert(order);

        // 2. 远程扣库存
        Result stockResult = stockClient.deduct(dto.getSkuId(), dto.getQuantity());
        if (!stockResult.isSuccess()) {
            throw new RuntimeException("扣库存失败: " + stockResult.getMsg());
        }

        // 3. 远程扣账户
        Result accountResult = accountClient.deduct(dto.getUserId(), dto.getAmount());
        if (!accountResult.isSuccess()) {
            throw new RuntimeException("扣账户失败: " + accountResult.getMsg());
        }

        log.info("订单创建成功, orderId = {}", order.getId());
        return order;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Service
public class StockService {
    @Autowired
    private StockDao stockDao;

    @Transactional  // 本地事务（Seata 拦截 SQL 自动注册分支）
    public void deduct(Long skuId, Integer quantity) {
        Stock stock = stockDao.selectById(skuId);
        if (stock.getQuantity() < quantity) {
            throw new RuntimeException("库存不足");
        }
        stock.setQuantity(stock.getQuantity() - quantity);
        stockDao.updateById(stock);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

@Service
public class AccountService {
    @Autowired
    private AccountDao accountDao;

    @Transactional
    public void deduct(Long userId, BigDecimal amount) {
        Account account = accountDao.selectById(userId);
        if (account.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("余额不足");
        }
        account.setBalance(account.getBalance().subtract(amount));
        accountDao.updateById(account);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

-- 在 seata_order、seata_stock、seata_account 三个库都执行
CREATE TABLE `undo_log` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `branch_id` bigint NOT NULL,
  `xid` varchar(100) NOT NULL,
  `context` varchar(128) NOT NULL,
  `rollback_info` longblob NOT NULL,
  `log_status` int 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 DEFAULT CHARSET=utf8mb4;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# 事务日志存储模式
store.mode=db
store.db.datasource=druid
store.db.dbType=mysql
store.db.url=jdbc:mysql://192.168.1.101:3306/seata?useUnicode=true&characterEncoding=utf8
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.lockTable=lock_table

# 客户端连接池
transport.threads.factory=shade
transport.threads.min=10
transport.threads.max=50
transport.threads.keepAliveTime=5

# 全局事务超时（毫秒，默认 60000 = 60 秒）
service.defaultGlobalTransactionTimeout=60000

# 分支事务超时
service.defaultBranchTransactionTimeout=30000

# 事务分组（与服务端 application-id 对应）
service.vgroupMapping.my_tx_group=default

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

seata:
  # 事务分组（与服务端 vgroupMapping 对应）
  tx-service-group: my_tx_group
  # 数据源代理模式
  data-source-proxy-mode: AT
  # 关闭 Spring Boot 自动配置（避免循环依赖）
  enable-auto-data-source-proxy: true
  # 客户端连接配置
  transport:
    type: TCP
    server-nio: true
    serialization: seata
    compressor: none
    enable-client-batch-send-request: true
  # 负载均衡策略
  load-balance:
    type: RandomLoadBalance
    virtual-nodes: 10

1
2
3
4
5
6
7

# 增加全局事务超时（根据业务调整）
seata:
  client:
    rm:
      report-success-enable: false  # 上报成功后不需要 TC 立即确认
service:
  default-global-transaction-timeout: 120000  # 改为 120 秒

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// TCC 模式的 Cancel 方法必须做空回滚检查
@TwoPhaseBusinessAction(name = "deductTcc")
public class DeductTccAction implements TccAction {
    @Override
    public boolean cancel(BusinessActionContext ctx) {
        // 检查是否已经 Try 过（如果 Try 记录不存在，说明是空回滚）
        if (!isTried(ctx.getXid(), ctx.getBranchId())) {
            log.warn("空回滚, xid={}, branchId={}", ctx.getXid(), ctx.getBranchId());
            return true;  // 直接返回成功
        }
        // 正常回滚逻辑
        return doCancel(ctx);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// TCC 模式的 Try 方法必须做悬挂检查
@TwoPhaseBusinessAction(name = "deductTcc")
public class DeductTccAction implements TccAction {
    @Override
    public boolean prepare(BusinessActionContext ctx) {
        // 检查是否已经 Cancel 过（如果是，Try 不再执行）
        if (isCancelled(ctx.getXid(), ctx.getBranchId())) {
            log.warn("悬挂, Try 晚于 Cancel, xid={}", ctx.getXid());
            return false;  // 拒绝执行
        }
        // 正常 Try 逻辑
        return doPrepare(ctx);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

-- 用存储过程批量创建（每个业务库都执行）
DELIMITER $$
CREATE PROCEDURE create_undo_log()
BEGIN
    IF NOT EXISTS (SELECT * FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = 'undo_log') THEN
        CREATE TABLE `undo_log` (
          `id` bigint NOT NULL AUTO_INCREMENT,
          `branch_id` bigint NOT NULL,
          `xid` varchar(100) NOT NULL,
          `context` varchar(128) NOT NULL,
          `rollback_info` longblob NOT NULL,
          `log_status` int 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 DEFAULT CHARSET=utf8mb4;
    END IF;
END$$
DELIMITER ;

CALL create_undo_log();

1
2
3
4
5
6
7
8
9

# 这种配置只会代理第一个数据源，第二个数据源不走 Seata
spring:
  datasource:
    url: jdbc:mysql://192.168.1.101:3306/seata_order_01
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: 123456
seata:
  enable-auto-data-source-proxy: true  # 只代理上面那个

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

@Configuration
public class DataSourceConfig {
    @Primary
    @Bean
    @ConfigurationProperties("spring.datasource.order01")
    public DataSource order01DataSource() {
        return new DruidDataSource();
    }

    @Bean
    @ConfigurationProperties("spring.datasource.order02")
    public DataSource order02DataSource() {
        return new DruidDataSource();
    }

    // 关键：让 Seata 代理两个数据源
    @Bean
    public DataSourceProxy order01DataSourceProxy(@Qualifier("order01DataSource") DataSource ds) {
        return new DataSourceProxy(ds);
    }

    @Bean
    public DataSourceProxy order02DataSourceProxy(@Qualifier("order02DataSource") DataSource ds) {
        return new DataSourceProxy(ds);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

spring:
  datasource:
    order01:
      url: jdbc:mysql://192.168.1.101:3306/seata_order_01
      username: root
      password: 123456
    order02:
      url: jdbc:mysql://192.168.1.102:3306/seata_order_02
      username: root
      password: 123456
seata:
  enable-auto-data-source-proxy: false  # 关闭自动代理（用上面的手动配置）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Seata Server 的 application.yml
seata:
  server:
    recovery:
      committing-retry-delay: 5      # commit 重试间隔（秒）
      async-committing-retry-delay: 5 # 异步 commit 重试间隔
      rollbacking-retry-delay: 5      # rollback 重试间隔
      rollbacking-deadline: 130000    # rollback 截止时间（130 秒）
  transport:
    server:
      max-connection-limit: 20000     # 单节点最大连接数（默认 5000）
      max-active: 5000                # 单节点最大活跃连接
    thread-factory:
      boss-thread-prefix: NettyBoss
      worker-thread-prefix: NettyServerNIOWorker
      boss-thread-size: 4
      worker-thread-size: 200         # Netty worker 线程数（默认 50）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

seata:
  store:
    mode: db
    db:
      # 连接池
      min-conn: 20
      max-conn: 200                   # 调大到 200（默认 30）
      max-wait: 5000                  # 5 秒超时
      # 表名
      global-table: global_table
      branch-table: branch_table
      lock-table: lock_table
      # 查询 limit
      query-limit: 500                # 单次最多查 500 条

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

-- global_table 加索引（生产环境必加）
ALTER TABLE global_table ADD INDEX idx_status_gmt_modified (status, gmt_modified);
ALTER TABLE global_table ADD INDEX idx_xid (xid);

-- branch_table 加索引
ALTER TABLE branch_table ADD INDEX idx_xid (xid);
ALTER TABLE branch_table ADD INDEX idx_status (status);

-- 定期清理已结束的全局事务（建议每天凌晨跑）
DELETE FROM global_table WHERE status IN ('Committed', 'Rollbacked') AND gmt_modified < DATE_SUB(NOW(), INTERVAL 7 DAY);
DELETE FROM branch_table WHERE status IN ('PhaseOne_Done', 'PhaseTwo_Committed', 'PhaseTwo_Rollbacked') AND gmt_modified < DATE_SUB(NOW(), INTERVAL 7 DAY);

1
2
3
4
5

# 生产环境降低日志级别（默认 INFO 改成 WARN）
logging:
  level:
    io.seata: WARN
    org.apache.seata: WARN

1
2

# Seata Server 启动脚本 bin/seata-server.sh
JAVA_OPTS="-Xms4g -Xmx4g -Xmn2g -XX:+UseG1GC -XX:MaxGCPauseMillis=200 -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/seata"

1
2
3
4
5
6
7
8

@GlobalTransactional(name = "order-tx")
public void createOrder(OrderDTO dto) {
    // 业务代码完全不变
    orderDao.insert(order);
    // 远程调用自动注册分支
    stockClient.deduct(dto.getSkuId(), dto.getQuantity());
    accountClient.deduct(dto.getUserId(), dto.getAmount());
}

1
2
3
4
5
6
7
8

阶段 1 - Try：预留资源（不真正扣减，只锁定）
    例：账户余额从 1000 冻结 100，变为「可用 900 + 冻结 100」

阶段 2 - Confirm：真正扣减（Try 成功后调用）
    例：把「冻结 100」扣掉，「可用 900」保持不变

阶段 3 - Cancel：释放预留（Try 失败或全局回滚时调用）
    例：把「冻结 100」释放回「可用 1000」

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

@LocalTCC  // 本地 TCC（同一个 JVM 内）
public interface AccountTccAction {
    @TwoPhaseBusinessAction(name = "deductTcc", commitMethod = "confirm", rollbackMethod = "cancel")
    boolean prepare(BusinessActionContext ctx, @BusinessActionContextParameter("userId") Long userId,
                    @BusinessActionContextParameter("amount") BigDecimal amount);

    boolean confirm(BusinessActionContext ctx);

    boolean cancel(BusinessActionContext ctx);
}

@Component
@Slf4j
public class AccountTccActionImpl implements AccountTccAction {
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private FreezeDao freezeDao;

    @Override
    public boolean prepare(BusinessActionContext ctx, Long userId, BigDecimal amount) {
        // Try：冻结金额（不真正扣）
        Account account = accountDao.selectById(userId);
        if (account.getBalance().compareTo(amount) < 0) {
            return false;  // 余额不足
        }
        account.setBalance(account.getBalance().subtract(amount));
        accountDao.updateById(account);

        Freeze freeze = new Freeze();
        freeze.setUserId(userId);
        freeze.setAmount(amount);
        freeze.setXid(ctx.getXid());
        freezeDao.insert(freeze);
        return true;
    }

    @Override
    public boolean confirm(BusinessActionContext ctx) {
        // Confirm：把冻结金额真正扣掉
        Freeze freeze = freezeDao.selectByXid(ctx.getXid());
        if (freeze == null) {
            return true;  // 幂等
        }
        freezeDao.deleteById(freeze.getId());
        return true;
    }

    @Override
    public boolean cancel(BusinessActionContext ctx) {
        // Cancel：释放冻结金额
        Freeze freeze = freezeDao.selectByXid(ctx.getXid());
        if (freeze == null) {
            return true;  // 幂等（空回滚）
        }
        // 把金额加回账户
        Account account = accountDao.selectById(freeze.getUserId());
        account.setBalance(account.getBalance().add(freeze.getAmount()));
        accountDao.updateById(account);
        freezeDao.deleteById(freeze.getId());
        return true;
    }
}

1
2
3

T1 → T2 → T3 → T4 → T5 （正向子事务）
                ↓ 失败
T5.Cancel → T4.Cancel → T3.Cancel → T2.Cancel → T1.Cancel （反向补偿）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// Seata SAGA 状态机定义（JSON）
{
  "Name": "OrderSaga",
  "Comment": "订单创建长事务",
  "StartState": "CreateOrder",
  "States": {
    "CreateOrder": {
      "Type": "ServiceTask",
      "ServiceName": "orderService",
      "ServiceMethod": "create",
      "CompensateState": "CompensateOrder",
      "Next": "DeductStock"
    },
    "DeductStock": {
      "Type": "ServiceTask",
      "ServiceName": "stockService",
      "ServiceMethod": "deduct",
      "CompensateState": "CompensateStock",
      "Next": "DeductAccount"
    },
    "DeductAccount": {
      "Type": "ServiceTask",
      "ServiceName": "accountService",
      "ServiceMethod": "deduct",
      "CompensateState": "CompensateAccount",
      "Next": "Succeed"
    },
    "Succeed": { "Type": "Succeed" },
    "CompensateOrder": {
      "Type": "ServiceTask",
      "ServiceName": "orderService",
      "ServiceMethod": "cancel"
    },
    "CompensateStock": {
      "Type": "ServiceTask",
      "ServiceName": "stockService",
      "ServiceMethod": "add"
    },
    "CompensateAccount": {
      "Type": "ServiceTask",
      "ServiceName": "accountService",
      "ServiceMethod": "add"
    }
  }
}

1
2
3
4
5
6
7

阶段 1 - Prepare：TM 通知所有 RM「准备提交」
    DB 执行事务但不 commit（数据加锁，但不释放）
    等待所有 RM 都返回 OK

阶段 2 - Commit：TM 通知所有 RM「真正提交」
    DB 释放锁 + 真正 commit 数据
    如果任何一个 RM 在阶段 1 返回 NO，TM 通知所有 RM rollback

1
2

seata:
  data-source-proxy-mode: XA  # 改为 XA

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Q1: 业务能接受"业务无侵入"被破坏吗？
    ├─ 不能（不能改业务代码）→ AT 模式（首选）/ XA 模式（DB 支持时）
    └─ 能（可以写业务代码）
        Q2: 业务要求强一致吗？
            ├─ 是（金融、证券、账务）→ XA 模式 / TCC 模式
            └─ 否（电商、物流、社交）
                Q3: 业务有"冻结 / 解冻"接口吗？
                    ├─ 有（账户余额冻结、库存预占）→ TCC 模式（性能优先）
                    └─ 无（普通业务）→ AT 模式
                        Q4: 业务是跨域 / 跨周期吗？
                            ├─ 是（长事务、跨公司）→ SAGA 模式
                            └─ 否（短事务、同域）→ AT 模式

1
2
3
4

Seata TC 集群（10 节点）
├─ 国内电商集群（5 节点，独立 Seata Server）
├─ 金融业务集群（3 节点，独立 Seata Server）
└─ 跨境业务集群（2 节点，独立 Seata Server）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

业务服务（200+ 微服务）
├─ AT 模式服务（150+）
│   └─ 共享 国内电商集群（5 节点 Seata Server）
├─ TCC 模式服务（30+）
│   ├─ 红包/秒杀 → 共享 金融业务集群
│   └─ 库存预占 → 共享 国内电商集群
├─ SAGA 模式服务（10+）
│   └─ 跨境业务 → 共享 跨境业务集群
└─ XA 模式服务（5+）
    └─ 银行/财务 → 共享 金融业务集群

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

开始
 │
 ├─ 业务能接受业务无侵入被破坏吗？─否→ AT 模式（默认） ────────────────────┐
 │                                                                            │
 ├─ 是 → 业务要求强一致吗？─是→ XA 模式（DB 支持时） ───────────────────────┤
 │                                                                            │
 ├─ 否 → 业务有「冻结/解冻」接口吗？─是→ TCC 模式（性能优先） ───────────────┤
 │                                                                            │
 └─ 否 → 业务是跨域/长事务吗？─是→ SAGA 模式（异步补偿） ──────────────────┤
                                                                              │
                                              都不满足 ─────────────────────┘