# docker-compose.yml——加到已有的基础设施中
version: '3.8'
services:

  seata-server:
    image: seataio/seata-server:1.8.0
    container_name: seata-server
    ports:
      - "7091:7091"   # Seata Web 控制台
      - "8091:8091"   # Seata 服务端口——client 连接这个
    environment:
      - SEATA_PORT=8091
      - STORE_MODE=db
      # 注册中心——Nacos
      - SEATA_CONFIG_REGISTRY_TYPE=nacos
      - SEATA_CONFIG_REGISTRY_NACOS_SERVER-ADDR=nacos:8848
      - SEATA_CONFIG_REGISTRY_NACOS_NAMESPACE=
      - SEATA_CONFIG_REGISTRY_NACOS_GROUP=SEATA_GROUP
      # 配置中心——Nacos
      - SEATA_CONFIG_CONFIG_TYPE=nacos
      - SEATA_CONFIG_CONFIG_NACOS_SERVER-ADDR=nacos:8848
      - SEATA_CONFIG_CONFIG_NACOS_NAMESPACE=
      - SEATA_CONFIG_CONFIG_NACOS_GROUP=SEATA_GROUP
      # 存储——MySQL
      - SEATA_STORE_DB_DATASOURCE=druid
      - SEATA_STORE_DB_DB-TYPE=mysql
      - SEATA_STORE_DB_DRIVER-CLASS-NAME=com.mysql.cj.jdbc.Driver
      - SEATA_STORE_DB_URL=jdbc:mysql://mysql:3306/seata?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
      - SEATA_STORE_DB_USER=root
      - SEATA_STORE_DB_PASSWORD=root123
    depends_on:
      - nacos
      - mysql

-- Seata Server 需要的数据库表——在 MySQL 中执行
CREATE DATABASE IF NOT EXISTS seata;
USE seata;

-- 全局事务表
CREATE TABLE global_table (
    xid         VARCHAR(128) NOT NULL,
    transaction_id BIGINT,
    status      TINYINT NOT NULL,
    application_id VARCHAR(32),
    transaction_service_group VARCHAR(32),
    transaction_name VARCHAR(128),
    timeout     INT,
    begin_time  BIGINT,
    application_data VARCHAR(2000),
    gmt_create  DATETIME,
    gmt_modified DATETIME,
    PRIMARY KEY (xid),
    KEY idx_status_gmt_modified (status, gmt_modified),
    KEY idx_transaction_id (transaction_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- 分支事务表
CREATE TABLE branch_table (
    branch_id   BIGINT NOT NULL,
    xid         VARCHAR(128) NOT NULL,
    transaction_id BIGINT,
    resource_group_id VARCHAR(32),
    resource_id VARCHAR(256),
    lock_key    VARCHAR(128),
    branch_type VARCHAR(8),
    status      TINYINT,
    client_id   VARCHAR(64),
    application_data VARCHAR(2000),
    gmt_create  DATETIME,
    gmt_modified DATETIME,
    PRIMARY KEY (branch_id),
    KEY idx_xid (xid)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- 全局锁表
CREATE TABLE lock_table (
    row_key     VARCHAR(128) NOT NULL,
    xid         VARCHAR(128),
    transaction_id BIGINT,
    branch_id   BIGINT,
    resource_id VARCHAR(256),
    table_name  VARCHAR(32),
    pk          VARCHAR(36),
    status      TINYINT NOT NULL DEFAULT 0,
    gmt_create  DATETIME,
    gmt_modified DATETIME,
    PRIMARY KEY (row_key),
    KEY idx_status (status),
    KEY idx_branch_id (branch_id),
    KEY idx_xid_and_branch_id (xid, branch_id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

# 验证 Seata Server 启动成功
curl http://localhost:7091

# 在 Nacos 中查看——服务列表应该出现 serverAddr
# http://localhost:8848/nacos → 服务列表 → 搜索 seata-server

<!-- 每个服务的 pom.xml——加 Seata 依赖 -->
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>
<!-- 排除自带的 Seata 版本——用我们自己指定的 -->
<!-- spring-cloud-alibaba 会自动引入 seata-spring-boot-starter -->

# 每个服务的 application.yml
spring:
  cloud:
    alibaba:
      seata:
        tx-service-group: default_tx_group   # ← 事务分组——和 Seata Server 中的配置对应

seata:
  registry:
    type: nacos
    nacos:
      server-addr: nacos:8848
      group: SEATA_GROUP
      namespace: ""
      application: seata-server
  tx-service-group: default_tx_group
  service:
    vgroup-mapping:
      default_tx_group: default

-- ⚠️ 每个参与分布式事务的数据库都需要创建 undo_log 表
-- 在 order-service 的数据库中：
USE order_db;
CREATE TABLE undo_log ( ... );  -- 同上

-- 在 product-service 的数据库中：
USE product_db;
CREATE TABLE undo_log ( ... );

-- 在 account-service 的数据库中：
USE account_db;
CREATE TABLE undo_log ( ... );

// ===== Application Service——加 @GlobalTransactional =====
@Service
public class OrderApplicationService {

    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private ProductClient productClient;    // Feign——product-service
    @Autowired
    private AccountClient accountClient;    // Feign——account-service

    @GlobalTransactional(                    // ← ← ← 核心注解——定义全局事务边界
        name = "create-order",               // 全局事务名——显示在 Seata 控制台
        timeoutMills = 60000,                // 超时时间——60 秒
        rollbackFor = Exception.class        // 任何异常都回滚
    )
    public Order createOrder(CreateOrderRequest request) {
        // ① 创建订单——本地事务——RM 自动处理
        Order order = Order.create(
            request.getUserId(),
            request.getDeliveryAddress(),
            request.getItems()
        );
        orderRepository.save(order);  // 一阶段：执行 INSERT + 记录 undo_log + 注册分支事务

        // ② 扣库存——远程调用 product-service
        try {
            productClient.deductStock(request.getItems());
            // 一阶段：product-service 执行 UPDATE + 记录 undo_log + 注册分支事务
        } catch (Exception e) {
            // 抛异常——TM 感知——触发全局回滚
            throw new BusinessException("扣库存失败——订单回滚", e);
        }

        // ③ 扣余额——远程调用 account-service
        try {
            accountClient.deductBalance(request.getUserId(), order.getTotalAmount());
            // 一阶段：account-service 执行 UPDATE + 记录 undo_log + 注册分支事务
        } catch (Exception e) {
            // 抛异常——TM 感知——触发全局回滚
            throw new BusinessException("扣余额失败——订单回滚", e);
        }

        // ④ 所有分支事务成功——TM 通知 TC 提交全局事务
        // 二阶段各 RM 删除 undo_log

        return order;
    }
    // 如果方法中任何地方抛异常——Seata 自动回滚所有分支事务
}

// ===== product-service——被调方——不需要 @GlobalTransactional =====
// Seata 自动通过 Feign 传播全局事务上下文（xid）

@Service
public class ProductService {

    @Autowired
    private ProductMapper productMapper;

    // 不需要加 @GlobalTransactional——Seata Agent 自动拦截
    // 通过 Feign 请求头中传播的 xid——自动加入全局事务
    @Transactional  // ← 本地事务——Seata 会拦截并增强
    public void deductStock(List<OrderItemDto> items) {
        for (OrderItemDto item : items) {
            Product product = productMapper.selectById(item.getProductId());
            if (product == null) {
                throw new BusinessException("商品不存在——ID：" + item.getProductId());
            }
            if (product.getStock() < item.getQuantity()) {
                throw new BusinessException("库存不足——商品：" + product.getName());
            }

            // 扣库存
            product.setStock(product.getStock() - item.getQuantity());
            productMapper.updateById(product);

            // Seata 自动拦截这个 UPDATE：
            // ① 执行前：SELECT 得到前置镜像（stock=100）
            // ② 执行 UPDATE——提交
            // ③ 记录 undo_log：前置镜像 stock=100 ——后置镜像 stock=95
            // ④ 向 TC 注册分支事务
        }
    }
}

// ===== Feign 接口——Seata 自动传播 xid =====
@FeignClient(name = "product-service")
public interface ProductClient {

    @PostMapping("/api/products/deduct-stock")
    void deductStock(@RequestBody List<OrderItemDto> items);
    // Seata 拦截 Feign 调用——把 xid 放入请求头——传播到 product-service
}

@Service
public class AccountService {

    @Autowired
    private AccountMapper accountMapper;

    @Transactional
    public void deductBalance(Long userId, BigDecimal amount) {
        Account account = accountMapper.selectByUserId(userId);
        if (account == null) {
            throw new BusinessException("账户不存在——userId：" + userId);
        }
        if (account.getBalance().compareTo(amount) < 0) {
            throw new BusinessException("余额不足");
        }

        account.setBalance(account.getBalance().subtract(amount));
        accountMapper.updateById(account);

        // Seata 自动拦截——记录 undo_log——注册分支事务
    }
}