云栈社区»论坛 › 技术文档「 Note & Doc 」 › Spring Boot 3 集成 ByteTCC 实战指南：掌握轻量级TCC分布式事务 ...

发回帖发新帖

2586 积分	0 好友	342 主题

发消息

Spring Boot 3 集成 ByteTCC 实战指南：掌握轻量级TCC分布式事务核心用法

发表于 12 小时前 | 查看: 1| 回复: 0

在微服务架构中，分布式事务一直是 Java 开发者必须面对的核心挑战。虽然 Seata 这类框架知名度很高，但其独立的协调器部署对于追求敏捷的中小团队或轻量级微服务场景而言，部署和维护成本有时显得偏高。有没有一种更轻便、与 Spring Boot 3 生态结合更紧密的方案？答案是肯定的——ByteTCC。它无需独立部署协调器，通过注解加极简编码即可实现分布式事务一致性。本文将带你快速上手其核心集成逻辑与实践要点。

一、ByteTCC 核心认知：是什么？优势在哪？

ByteTCC 是一款基于 TCC（Try-Confirm-Cancel）机制的分布式事务管理器，兼容 JTA 规范，专为 Java 生态设计，能无缝集成 Spring、Spring Boot 3、Spring Cloud 等主流框架。其核心定位是“轻量、易用、高适配”，与 Seata 相比，其差异化优势相当明显：

无独立协调器：无需像 Seata 那样部署 TC 服务端，直接依赖业务数据库存储事务日志，部署成本几乎为零，特别适合中小团队和轻量微服务集群。
Spring Boot 3 原生适配：完美支持 Spring 声明式事务，通过 @Compensable 等注解即可将普通服务转为 TCC 服务，无需大规模重构业务代码，非常契合 Java 开发者的编码习惯。
多事务模式支持：除了核心的 TCC 模式，还兼容普通事务、Saga 事务，能够覆盖电商下单、金融转账等多样化的复杂交易场景。
强容错能力：内置了事务自动恢复机制。当系统发生网络波动或服务宕机等故障后，框架可以基于存储在数据库中的事务日志自动修复事务状态，有效避免数据不一致。

当然，选择 ByteTCC 也需明确其局限：作为 TCC 框架，它需要开发者手动实现 Try、Confirm、Cancel 三个阶段的方法，对业务代码有一定侵入性，并且必须保证 Confirm 和 Cancel 方法的幂等性。不过，对于轻量级场景而言，这些编码成本通常远低于部署和维护 Seata TC 服务的运维开销，整体性价比很高。

二、核心原理：TCC 三阶段模型拆解

ByteTCC 的核心是 TCC 模式。它将一个完整的分布式事务拆分为三个阶段，通过手动编码来控制各阶段的业务逻辑，最终实现跨服务的数据一致性。每个阶段的核心职责与执行逻辑如下：

Try 阶段（资源检查与预留）：这是“试探性操作”阶段。核心任务是检查业务资源是否充足，并预留资源（但不实际提交业务数据）。以经典的订单-库存场景为例，Try 阶段会检查商品库存是否满足下单数量，同时锁定对应的库存（不是直接扣减，而是标记为“冻结”状态），为后续的确认或回滚做好准备。
Confirm 阶段（确认提交）：当所有参与分布式事务的微服务，其 Try 阶段均执行成功，整个事务就会进入确认阶段。该阶段会提交 Try 阶段预留的资源，执行最终的业务逻辑（例如，将冻结的库存正式扣减）。这里有个关键点：Confirm 方法必须保证幂等性，以防因网络重试等原因导致业务被重复提交。
Cancel 阶段（回滚补偿）：如果任意一个服务的 Try 阶段执行失败（比如库存不足、服务调用超时），事务就会进入取消阶段。该阶段会释放 Try 阶段预留的所有资源（例如，解锁被冻结的库存），将业务数据恢复到初始状态。Cancel 方法同样需要保证幂等性，防止因重复回滚引发数据异常。

ByteTCC 底层通过 AOP 机制拦截事务方法，自动协调各微服务三阶段的执行顺序，同时将事务状态和执行日志存储到业务数据库中，为故障后的自动恢复提供支撑。整个过程无需开发者手动去协调各个服务的执行节奏。

三、核心实战：Spring Boot 3 + ByteTCC 集成核心步骤

本文将以经典的“订单创建-库存扣减”分布式场景为例，聚焦 ByteTCC 的核心集成流程，省略冗余的项目结构代码，仅保留关键步骤与核心代码，帮助你快速掌握集成逻辑。

环境说明：Spring Boot 3.2.2 + JDK 17 + MySQL 8.0 + ByteTCC 0.5.12。

3.1 环境准备：核心表结构创建

ByteTCC 依赖业务数据库存储事务日志，无需额外部署存储组件。你只需要在每个参与分布式事务的业务数据库（例如订单库 order_db、库存库 stock_db）中创建两张事务日志表，用于记录事务状态与执行日志，支撑故障恢复机制。

-- 事务主表：存储全局事务与分支事务核心信息
CREATE TABLE `bytejta` (
  `xid` varchar(64) NOT NULL COMMENT '事务ID',
  `gxid` varchar(64) DEFAULT NULL COMMENT '全局事务ID',
  `bxid` varchar(64) DEFAULT NULL COMMENT '分支事务ID',
  `status` tinyint NOT NULL COMMENT '事务状态：0-活跃，1-提交，2-回滚',
  `transaction_type` tinyint DEFAULT NULL COMMENT '事务类型',
  `retry_count` int DEFAULT '0' COMMENT '重试次数',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `last_modify_time` datetime DEFAULT NULL COMMENT '最后修改时间',
  PRIMARY KEY (`xid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='ByteTCC事务主表';

-- 事务日志表：存储事务执行详情，用于故障恢复
CREATE TABLE `bytejta_log` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `xid` varchar(64) NOT NULL COMMENT '事务ID',
  `content` varchar(1024) DEFAULT NULL COMMENT '日志内容',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  PRIMARY KEY (`id`),
  KEY `idx_xid` (`xid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='ByteTCC事务日志表';

至于业务表（如订单表 t_order、库存表 t_stock），按常规业务设计即可。需要注意的是，库存表通常需要增加一个“冻结库存”字段，用于 Try 阶段的资源预留，这里不再赘述完整表结构。

3.2 核心依赖引入

在 Spring Boot 项目的 pom.xml 中引入 ByteTCC 核心依赖，同时搭配数据库驱动、连接池等基础依赖。重点是确保 ByteTCC 的版本与 Spring Boot 3 适配，避免版本冲突。

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>3.2.2</version>
    <relativePath/>
</parent>

<dependencies>
    <!-- Spring Boot核心依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- ByteTCC核心依赖（适配Spring Boot 3） -->
    <dependency>
        <groupId>org.bytesoft</groupId>
        <artifactId>bytetcc-supports-springboot</artifactId>
        <version>0.5.12</version>
    </dependency>

    <!-- 数据库驱动与连接池 -->
    <dependency>
        <groupId>com.mysql</groupId>
        <artifactId>mysql-connector-j</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-3-starter</artifactId>
        <version>1.2.20</version>
    </dependency>

    <!-- 远程调用（Feign，按需替换为Dubbo） -->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
        <version>4.1.1</version>
    </dependency>

    <!-- Lombok简化代码 -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

3.3 核心配置：极简配置即可运行

ByteTCC 默认提供了自动配置，无需过多自定义。你只需要在 application.yml 中配置数据库连接信息，同时按需调整事务恢复的相关参数即可，配置非常简洁。

server:
  port: 8081 # 服务端口，多服务需区分

spring:
  application:
    name: stock-service # 服务名称
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    url: jdbc:mysql://localhost:3306/stock_db?useSSL=false&serverTimezone=UTC&allowPublicKeyRetrieval=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver

# ByteTCC核心配置（按需调整）
bytetcc:
  recover:
    delay-seconds: 60 # 故障后事务恢复延迟时间（秒）
    period-seconds: 10 # 事务恢复扫描周期（秒）
  serializer: kryo # 序列化方式，kryo性能更优

订单服务的配置与库存服务基本一致，仅需修改数据库连接（指向 order_db）与服务端口，确保多个服务能正常通信即可。

3.4 核心编码：TCC 三阶段实现与事务发起

ByteTCC 的核心编码工作集中在 TCC 服务的三阶段方法实现，以及全局事务的发起。整个过程无需复杂的 API 调用，通过注解即可完成事务协调。

3.4.1 TCC 服务实现（以库存服务为例）

首先，定义 TCC 服务接口，声明 Try、Confirm、Cancel 三个方法，明确各阶段的业务职责。然后，实现该接口，并通过 @Compensable 注解标记 TCC 服务，关联三阶段方法。ByteTCC 会自动拦截该服务并协调执行。

// 库存服务接口
@FeignClient(value = "stock-service") // Spring Cloud 服务名，用于跨服务调用
public interface StockService {
    @Compensable(identifier = "reserveStock", tryMethod = "tryReserveStock",
                 confirmMethod = "confirmDeductStock", cancelMethod = "cancelReleaseStock")
    @Transactional
    void reserveStock(Long productId, Integer quantity, String orderNo);
}

// 库存服务实现类
@Service
public class StockServiceImpl implements StockService {
    @Autowired
    private ProductStockRepository stockRepository;

    // Try阶段：检查库存并锁定（预留资源）
    public void tryReserveStock(Long productId, Integer quantity, String orderNo) {
        // 1. 查库存（加行锁，避免并发问题）
        ProductStock stock = stockRepository.findByProductIdForUpdate(productId)
                .orElseThrow(() -> new BusinessException("商品不存在"));
        // 2. 校验库存是否充足
        if (stock.getStockNum() < quantity) {
            throw new BusinessException("商品库存不足，无法下单");
        }
        // 3. 锁定库存（预留资源，不实际扣减）
        stock.setLockedNum(stock.getLockedNum() + quantity);
        stockRepository.save(stock);
        // 日志记录（便于问题排查）
        log.info("订单{}：库存服务Try阶段完成，锁定商品{}库存{}件", orderNo, productId, quantity);
    }

    // Confirm阶段：确认扣减库存（消耗预留资源）
    public void confirmDeductStock(Long productId, Integer quantity, String orderNo) {
        ProductStock stock = stockRepository.findByProductId(productId)
                .orElseThrow(() -> new BusinessException("商品不存在"));
        // 扣减总库存，清零对应锁定库存
        stock.setStockNum(stock.getStockNum() - quantity);
        stock.setLockedNum(stock.getLockedNum() - quantity);
        stockRepository.save(stock);
        log.info("订单{}：库存服务Confirm阶段完成，实际扣减商品{}库存{}件", orderNo, productId, quantity);
    }

    // Cancel阶段：释放锁定库存（回滚预留资源）
    public void cancelReleaseStock(Long productId, Integer quantity, String orderNo) {
        ProductStock stock = stockRepository.findByProductId(productId);
        if (stock == null) {
            return; // 无库存记录，无需回滚
        }
        // 释放锁定库存
        stock.setLockedNum(stock.getLockedNum() - quantity);
        stockRepository.save(stock);
        log.info("订单{}：库存服务Cancel阶段完成，释放商品{}库存{}件", orderNo, productId, quantity);
    }

    @Override
    public void reserveStock(Long productId, Integer quantity, String orderNo) {
        tryReserveStock(productId, quantity, orderNo);
    }
}

3.4.2 支付服务（独立微服务）：TCC 实现

支付服务负责用户余额的预留（Try）、扣款（Confirm）、释放（Cancel），独立部署，对外提供接口。

// 支付服务接口
@FeignClient(value = "payment-service") // 微服务名
public interface PaymentService {
    @Compensable(identifier = "payOrder", tryMethod = "tryReserveBalance",
                 confirmMethod = "confirmDeductBalance", cancelMethod = "cancelReleaseBalance")
    @Transactional
    void payOrder(Long userId, BigDecimal amount, String orderNo);
}

// 支付服务实现类
@Service
public class PaymentServiceImpl implements PaymentService {
    @Autowired
    private UserBalanceRepository balanceRepository;

    // Try阶段：检查余额并预留
    public void tryReserveBalance(Long userId, BigDecimal amount, String orderNo) {
        UserBalance balance = balanceRepository.findByUserIdForUpdate(userId)
                .orElseThrow(() -> new BusinessException("用户不存在"));
        // 校验余额
        if (balance.getAvailableBalance().compareTo(amount) < 0) {
            throw new BusinessException("用户余额不足，无法支付");
        }
        // 预留金额（冻结对应余额）
        balance.setReservedBalance(balance.getReservedBalance().add(amount));
        balanceRepository.save(balance);
        log.info("订单{}：支付服务Try阶段完成，为用户{}预留金额{}元", orderNo, userId, amount);
    }

    // Confirm阶段：确认扣款
    public void confirmDeductBalance(Long userId, BigDecimal amount, String orderNo) {
        UserBalance balance = balanceRepository.findByUserId(userId)
                .orElseThrow(() -> new BusinessException("用户不存在"));
        // 扣减可用余额，清零预留金额
        balance.setAvailableBalance(balance.getAvailableBalance().subtract(amount));
        balance.setReservedBalance(balance.getReservedBalance().subtract(amount));
        balanceRepository.save(balance);
        log.info("订单{}：支付服务Confirm阶段完成，为用户{}实际扣款{}元", orderNo, userId, amount);
    }

    // Cancel阶段：释放预留金额
    public void cancelReleaseBalance(Long userId, BigDecimal amount, String orderNo) {
        UserBalance balance = balanceRepository.findByUserId(userId);
        if (balance == null) {
            return;
        }
        // 释放预留金额，回归可用余额
        balance.setAvailableBalance(balance.getAvailableBalance().add(amount));
        balance.setReservedBalance(balance.getReservedBalance().subtract(amount));
        balanceRepository.save(balance);
        log.info("订单{}：支付服务Cancel阶段完成，为用户{}释放金额{}元", orderNo, userId, amount);
    }

    @Override
    public void payOrder(Long userId, BigDecimal amount, String orderNo) {
        tryReserveBalance(userId, amount, orderNo);
    }
}

3.4.3 订单服务（核心服务）：串联跨服务调用

全局事务由任意一个服务发起，只需在发起方法上添加 @Transactional 和 @Compensable 注解，ByteTCC 会自动识别并开启全局事务。同时，通过远程调用（如 Feign）触发其他服务的 TCC 方法，框架会自动协调三阶段的执行。

// 订单服务接口
public interface OrderService {
    // 分布式事务入口：同时添加ByteTCC注解和Spring本地事务注解
    @Compensable(identifier = "createOrder", tryMethod = "tryCreateOrder",
                 confirmMethod = "confirmCreateOrder", cancelMethod = "cancelCreateOrder")
    @Transactional
    void createOrder(Order order, Long userId);
}

// 订单服务实现类
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Autowired
    private StockService stockService; // 注入库存服务Feign客户端（跨服务调用）
    @Autowired
    private PaymentService paymentService; // 注入支付服务Feign客户端（跨服务调用）

    @Override
    public void createOrder(Order order, Long userId) {
        tryCreateOrder(order, userId);
    }

    // Try阶段：创建订单 + 跨服务调用库存锁定、余额预留
    public void tryCreateOrder(Order order, Long userId) {
        // 1. 生成唯一订单号（用于幂等性控制和日志追溯）
        String orderNo = UUID.randomUUID().toString().replace("-", "");
        order.setId(Long.valueOf(orderNo.substring(0, 16))); // 简化ID生成
        order.setStatus("PENDING");
        orderRepository.save(order);
        log.info("订单{}：订单服务Try阶段完成，创建待支付订单", orderNo);

        // 2. 跨服务调用：库存服务锁定库存
        stockService.reserveStock(order.getProductId(), order.getQuantity(), orderNo);

        // 3. 跨服务调用：支付服务预留余额
        paymentService.payOrder(userId, order.getTotalAmount(), orderNo);

        // 模拟随机异常（测试Cancel触发）
        // if (new Random().nextInt(10) < 3) {
        //     throw new BusinessException("订单服务Try阶段模拟异常");
        // }
    }

    // Confirm阶段：确认订单状态 + 触发跨服务Confirm
    public void confirmCreateOrder(Order order, Long userId) {
        order.setStatus("PAID");
        orderRepository.save(order);
        String orderNo = order.getId().toString();
        log.info("订单{}：订单服务Confirm阶段完成，更新订单为已支付状态", orderNo);

        // 跨服务调用：触发库存、支付服务的Confirm（ByteTCC也会自动协调，手动调用更清晰）
        stockService.reserveStock(order.getProductId(), order.getQuantity(), orderNo);
        paymentService.payOrder(userId, order.getTotalAmount(), orderNo);
    }

    // Cancel阶段：取消订单 + 触发跨服务Cancel
    public void cancelCreateOrder(Order order, Long userId) {
        order.setStatus("CANCELED");
        orderRepository.save(order);
        String orderNo = order.getId().toString();
        log.info("订单{}：订单服务Cancel阶段完成，更新订单为已取消状态", orderNo);

        // 跨服务调用：触发库存、支付服务的Cancel（释放资源）
        stockService.reserveStock(order.getProductId(), order.getQuantity(), orderNo);
        paymentService.payOrder(userId, order.getTotalAmount(), orderNo);
    }
}

关键机制说明：

双注解协同作用：@Compensable 是 ByteTCC 的核心注解，用于绑定 TCC 三阶段方法、标识分布式事务入口，并协调跨服务事务。@Transactional 是 Spring 本地事务注解，保证单服务内多个数据库操作（如订单创建、状态更新）的原子性。两者必须同时添加在入口方法上，缺一不可。
异常触发 Cancel 的核心逻辑：若 tryCreateOrder 方法（或其调用的远程服务 Try 方法）抛出任何未捕获异常，ByteTCC 的事务拦截器会捕获异常，将分布式事务状态标记为失败，随后通知所有参与服务，逐一调用对应的 cancelMethod，完成全链路资源回滚。
远程服务注解要求：被调用的库存、支付服务，其对应的 Try、Confirm、Cancel 方法入口也需按此规范实现——入口方法添加 @Compensable 和 @Transactional。

ByteTCC 的 @Compensable 注解通过 AOP 机制增强入口方法，自动管理事务上下文传递、参与者注册和三阶段协调，开发者无需手动编写复杂的协调逻辑，只需按规范定义三阶段方法并抛出异常即可触发回滚。

四、本文总结

Spring Boot 3 与 ByteTCC 的集成核心在于“注解驱动 + TCC 三阶段编码”，无需复杂的配置与额外组件部署，就能快速实现分布式事务一致性。其核心优势在于轻量化，完美契合中小团队、轻量微服务的场景需求，避开了 Seata 等框架部署维护的繁琐流程。

掌握 ByteTCC 的关键是理清三阶段职责与幂等性设计：Try 阶段负责资源预留，Confirm 负责确认提交，Cancel 负责回滚补偿。三者配合，再加上 ByteTCC 的自动协调，就能稳定保障跨服务数据一致性。如果你的 Spring Boot 3 项目有分布式事务需求，且追求轻量化部署，ByteTCC 无疑是极具吸引力的选择之一。对于更多关于微服务架构和分布式系统设计的深入探讨，欢迎在云栈社区的后端与架构板块进行交流。

上一篇：Rust 与 C 语言性能对比分析：运行速度差异的关键因素
下一篇：B站安全警示：警惕新号利用夸克网盘传播带毒图吧工具箱

Spring Boot 3, ByteTCC, TCC, 分布式事务, 微服务