<!-- pom.xml -->
<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
        <version>2.2.5.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        <version>2.2.5.RELEASE</version>
    </dependency>
</dependencies>

# 下载Seata Server
wget https://github.com/seata/seata/releases/download/v1.4.2/seata-server-1.4.2.tar.gz

# 解压并配置
 tar -zxvf seata-server-1.4.2.tar.gz
 cd seata/bin

# 修改配置文件 conf/registry.conf
registry {
  type = "nacos"
  nacos {
    application = "seata-server"
    serverAddr = "127.0.0.1:8848"
    namespace = ""
    cluster = "default"
  }
}

# 启动Seata Server
./seata-server.sh -p 8091 -h 127.0.0.1

-- 订单表
CREATE TABLE `order` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` bigint(20) NOT NULL,
  `product_id` bigint(20) NOT NULL,
  `count` int(11) NOT NULL,
  `money` decimal(10,2) NOT NULL,
  `status` int(1) NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- 库存表
CREATE TABLE `storage` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `product_id` bigint(20) NOT NULL,
  `total` int(11) NOT NULL,
  `used` int(11) NOT NULL,
  `residue` int(11) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- Seata AT模式需要的undo_log表
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,
  PRIMARY KEY (`id`),
  UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

// OrderService.java
@Service
public class OrderService {

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private StorageService storageService;

    @Autowired
    private AccountService accountService;

    /**

     * 创建订单 - 全局事务入口
     * @GlobalTransactional 注解开启全局事务
     */
    @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
    public void createOrder(Order order) {
        // 1. 创建订单
        orderMapper.create(order);

        // 2. 扣减库存
        storageService.decrease(order.getProductId(), order.getCount());

        // 3. 扣减账户余额
        accountService.decrease(order.getUserId(), order.getMoney());

        // 4. 更新订单状态
        orderMapper.update(order.getId(), 1);
    }
}

// StorageService.java - 库存服务
@Service
public class StorageService {

    @Autowired
    private StorageMapper storageMapper;

    /**

     * 扣减库存
     */
    public void decrease(Long productId, Integer count) {
        // 查询当前库存
        Storage storage = storageMapper.selectByProductId(productId);

        if (storage.getResidue() < count) {
            throw new RuntimeException("库存不足");
        }

        // 更新库存
        storageMapper.decrease(productId, count);
    }
}

spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    alibaba:
      seata:
        tx-service-group: my_test_tx_group

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/seata_order?useUnicode=true&characterEncoding=utf-8
    username: root
    password: 123456

# Seata配置
seata:
  enabled: true
  application-id: ${spring.application.name}
  tx-service-group: my_test_tx_group
  enable-auto-data-source-proxy: true
  config:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: ""
      group: SEATA_GROUP
  registry:
    type: nacos
    nacos:
      application: seata-server
      server-addr: 127.0.0.1:8848
      namespace: ""
      group: SEATA_GROUP

// 本地消息表实现
@Service
@Transactional
public class BlogService {

    public void publishArticle(Article article, List<Tag> tags) {
        // 1. 保存文章
        articleMapper.insert(article);

        // 2. 保存标签
        tagMapper.batchInsert(tags);

        // 3. 插入消息记录
        MessageLog messageLog = new MessageLog();
        messageLog.setBusinessKey(article.getId().toString());
        messageLog.setStatus(0); // 初始状态
        messageLogMapper.insert(messageLog);

        // 4. 发送MQ消息（异步更新统计）
        rocketMQTemplate.sendAsync(...);
    }
}

// 消息消费者
@Component
@RocketMQMessageListener(topic = "blog-statistic", consumerGroup = "blog-group")
public class StatisticConsumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        // 更新文章统计
        statisticService.updateViewCount(message);

        // 更新消息状态为已处理
        messageLogMapper.updateStatus(message, 1);
    }
}

// TCC模式实现
@Service
public class PaymentService {

    @Autowired
    private AccountTccService accountTccService;

    @Autowired
    private TransactionTccService transactionTccService;

    /**

     * TCC支付流程
     */
    @GlobalTransactional
    public void processPayment(PaymentRequest request) {
        // Try阶段
        boolean accountTry = accountTccService.prepareDebit(request);
        boolean transactionTry = transactionTccService.prepareRecord(request);

        if (!accountTry || !transactionTry) {
            throw new RuntimeException("TCC Try阶段失败");
        }

        // 模拟业务校验
        if (!riskControlService.check(request)) {
            throw new RuntimeException("风控校验失败");
        }

        // Confirm阶段 - 异步执行提高性能
        tccConfirmExecutor.execute(() -> {
            accountTccService.confirmDebit(request);
            transactionTccService.confirmRecord(request);
        });
    }
}

// TCC账户服务
@Service
public class AccountTccService {

    /**

     * Try阶段：预扣款
     */
    @Transactional
    public boolean prepareDebit(PaymentRequest request) {
        // 检查账户余额
        Account account = accountMapper.selectForUpdate(request.getAccountId());
        if (account.getBalance().compareTo(request.getAmount()) < 0) {
            return false;
        }

        // 冻结金额
        accountMapper.freezeAmount(request.getAccountId(), request.getAmount());

        // 记录TCC日志
        tccLogMapper.insert(TccLog.buildTryLog(...));
        return true;
    }

    /**

     * Confirm阶段：实际扣款
     */
    @Transactional
    public void confirmDebit(PaymentRequest request) {
        // 实际扣减余额
        accountMapper.debit(request.getAccountId(), request.getAmount());

        // 解冻金额
        accountMapper.unfreezeAmount(request.getAccountId(), request.getAmount());

        // 更新TCC日志状态
        tccLogMapper.updateStatus(request.getTccId(), "CONFIRMED");
    }

    /**

     * Cancel阶段：取消操作
     */
    @Transactional
    public void cancelDebit(PaymentRequest request) {
        // 解冻金额
        accountMapper.unfreezeAmount(request.getAccountId(), request.getAmount());

        // 更新TCC日志状态
        tccLogMapper.updateStatus(request.getTccId(), "CANCELLED");
    }
}

# application.yml 监控配置
management:
  endpoints:
    web:
      exposure:
        include: "health,info,metrics,seata"
  endpoint:
    health:
      show-details: always

# Seata监控指标
seata:
  metrics:
    enabled: true
    registry-type: compact
    exporter-list: prometheus

// 数据源代理核心逻辑
public class DataSourceProxy extends AbstractDataSourceProxy implements Resource {

    @Override
    public ConnectionProxy getConnection() throws SQLException {
        Connection targetConnection = targetDataSource.getConnection();
        return new ConnectionProxy(this, targetConnection);
    }
}

// SQL解析与undo log生成
public class BaseTransactionalExecutor implements Executor {

    protected TableRecords beforeImage() throws SQLException {
        // 生成前置镜像
        return executor.buildTableRecords(getTableMeta(), selectSQL);
    }

    protected TableRecords afterImage(TableRecords beforeImage) throws SQLException {
        // 生成后置镜像
        return executor.buildTableRecords(getTableMeta(), selectSQL);
    }
}