首页
/ TCC-Transaction 项目教程：构建高可靠的分布式事务解决方案

TCC-Transaction 项目教程：构建高可靠的分布式事务解决方案

2026-01-16 09:32:43作者：明树来
tcc-transaction
tcc-transaction是TCC型事务java实现
项目地址：https://gitcode.com/gh_mirrors/tc/tcc-transaction

引言：微服务架构下的分布式事务挑战

在微服务架构日益普及的今天，分布式事务已成为开发者面临的核心挑战之一。传统的单体应用事务管理在微服务环境下不再适用，跨服务的业务操作需要新的解决方案来保证数据一致性。TCC（Try-Confirm-Cancel）模式作为一种成熟的分布式事务解决方案，通过业务层面的补偿机制来确保最终一致性。

TCC-Transaction 是一个开源的 Java 实现，专门为微服务架构设计，提供了高性能、易用的分布式事务服务。本文将深入探讨 TCC-Transaction 的核心概念、工作原理、使用方法和最佳实践。

TCC 事务模式核心概念

TCC 三阶段模型

TCC 事务模式将分布式事务分为三个阶段：

flowchart TD
    A[开始事务] --> B[Try阶段<br>业务检查与资源预留]
    B --> C{Try成功?}
    C -->|是| D[Confirm阶段<br>确认执行业务]
    C -->|否| E[Cancel阶段<br>取消业务操作]
    D --> F[事务提交完成]
    E --> F

Try 阶段：尝试执行业务，完成所有业务检查（一致性），预留必须的业务资源（准隔离性）。

Confirm 阶段：确认执行业务，不作任何业务检查，只使用 Try 阶段预留的业务资源，必须满足幂等性。

Cancel 阶段：取消执行业务，释放 Try 阶段预留的业务资源，必须满足幂等性。

TCC-Transaction 架构设计

classDiagram
    class TCCFramework {
        +TransactionManager
        +TransactionRepository
        +RecoveryManager
    }
    
    class BusinessService {
        +@Compensable tryMethod()
        +confirmMethod()
        +cancelMethod()
    }
    
    class Transaction {
        +TransactionStatus
        +TransactionType
        +ParticipantList
    }
    
    TCCFramework --> Transaction
    BusinessService --> TCCFramework

快速开始：构建你的第一个 TCC 事务

环境准备

首先确保你的开发环境满足以下要求：

  • JDK 1.8 或更高版本
  • Maven 3.0 或更高版本
  • Spring Boot 2.x
  • 数据库（MySQL/PostgreSQL/Oracle）

项目依赖配置

在 pom.xml 中添加 TCC-Transaction 依赖：

<dependency>
    <groupId>org.mengyun</groupId>
    <artifactId>tcc-transaction-spring-boot-starter</artifactId>
    <version>2.x.x</version>
</dependency>

核心注解说明

TCC-Transaction 提供了两个核心注解：

  1. @Compensable：标记需要 TCC 事务管理的方法
  2. @EnableTcc：在接口上声明 TCC 服务

示例：资金转账业务实现

让我们通过一个资金转账的示例来理解 TCC-Transaction 的使用：

@Service("capitalTradeOrderService")
public class CapitalTradeOrderServiceImpl implements CapitalTradeOrderService {

    @Autowired
    private CapitalAccountRepository capitalAccountRepository;

    @Autowired
    private TradeOrderRepository tradeOrderRepository;

    @Override
    @Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord")
    @Transactional
    public String record(CapitalTradeOrderDto tradeOrderDto) {
        // Try 阶段：业务检查和资源预留
        System.out.println("capital try record called");

        TradeOrder foundTradeOrder = tradeOrderRepository
            .findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());

        if (foundTradeOrder == null) {
            TradeOrder tradeOrder = new TradeOrder(
                tradeOrderDto.getSelfUserId(),
                tradeOrderDto.getOppositeUserId(),
                tradeOrderDto.getMerchantOrderNo(),
                tradeOrderDto.getAmount()
            );

            tradeOrderRepository.insert(tradeOrder);

            CapitalAccount transferFromAccount = capitalAccountRepository
                .findByUserId(tradeOrderDto.getSelfUserId());
            transferFromAccount.transferFrom(tradeOrderDto.getAmount());
            capitalAccountRepository.save(transferFromAccount);
        }

        return "success";
    }

    @Transactional
    public void confirmRecord(CapitalTradeOrderDto tradeOrderDto) {
        // Confirm 阶段：确认执行业务
        System.out.println("capital confirm record called");

        TradeOrder tradeOrder = tradeOrderRepository
            .findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());

        if (tradeOrder != null && tradeOrder.getStatus().equals("DRAFT")) {
            tradeOrder.confirm();
            tradeOrderRepository.update(tradeOrder);

            CapitalAccount transferToAccount = capitalAccountRepository
                .findByUserId(tradeOrderDto.getOppositeUserId());
            transferToAccount.transferTo(tradeOrderDto.getAmount());
            capitalAccountRepository.save(transferToAccount);
        }
    }

    @Transactional
    public void cancelRecord(CapitalTradeOrderDto tradeOrderDto) {
        // Cancel 阶段：取消业务操作
        System.out.println("capital cancel record called");

        TradeOrder tradeOrder = tradeOrderRepository
            .findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());

        if (tradeOrder != null && "DRAFT".equals(tradeOrder.getStatus())) {
            tradeOrder.cancel();
            tradeOrderRepository.update(tradeOrder);

            CapitalAccount capitalAccount = capitalAccountRepository
                .findByUserId(tradeOrderDto.getSelfUserId());
            capitalAccount.cancelTransfer(tradeOrderDto.getAmount());
            capitalAccountRepository.save(capitalAccount);
        }
    }
}

事务调用流程

sequenceDiagram
    participant Client
    participant TCC_Coordinator
    participant ServiceA
    participant ServiceB

    Client->>TCC_Coordinator: 开始分布式事务
    TCC_Coordinator->>ServiceA: 调用Try方法
    ServiceA-->>TCC_Coordinator: Try结果
    TCC_Coordinator->>ServiceB: 调用Try方法
    ServiceB-->>TCC_Coordinator: Try结果
    
    alt 所有Try成功
        TCC_Coordinator->>ServiceA: 调用Confirm方法
        TCC_Coordinator->>ServiceB: 调用Confirm方法
    else 任一Try失败
        TCC_Coordinator->>ServiceA: 调用Cancel方法
        TCC_Coordinator->>ServiceB: 调用Cancel方法
    end

配置与管理

数据库配置

TCC-Transaction 需要数据库来存储事务状态信息。配置示例：

# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/tcc_db
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# TCC 事务存储配置
tcc.transaction.repository.driver-class-name=com.mysql.cj.jdbc.Driver
tcc.transaction.repository.url=jdbc:mysql://localhost:3306/tcc_db
tcc.transaction.repository.username=root
tcc.transaction.repository.password=password

事务恢复配置

TCC-Transaction 提供了自动恢复机制来处理异常情况：

# 恢复配置
tcc.transaction.recovery.max-retry-count=30
tcc.transaction.recovery.recovery-duration=120
tcc.transaction.recovery.cron-expression=0/30 * * * * ?

高级特性与最佳实践

1. 幂等性设计

TCC 事务的 Confirm 和 Cancel 阶段必须保证幂等性：

@Transactional
public void confirmRecord(CapitalTradeOrderDto tradeOrderDto) {
    TradeOrder tradeOrder = tradeOrderRepository
        .findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());
    
    // 通过状态检查确保幂等性
    if (tradeOrder != null && tradeOrder.getStatus().equals("DRAFT")) {
        tradeOrder.confirm();
        tradeOrderRepository.update(tradeOrder);
        // ... 其他业务逻辑
    }
}

2. 超时与重试机制

@Compensable(
    confirmMethod = "confirmRecord",
    cancelMethod = "cancelRecord",
    asyncConfirm = false,
    delayCancelExceptions = {SocketTimeoutException.class}
)
public String record(CapitalTradeOrderDto tradeOrderDto) {
    // 业务逻辑
}

3. 多协议支持

TCC-Transaction 支持多种 RPC 协议：

协议类型 适用场景 特点
Dubbo 高性能微服务 阿里开源，性能优异
gRPC 跨语言微服务 Google 开发，支持多语言
HTTP/REST 通用Web服务 标准协议，兼容性好

4. 监控与管理面板

TCC-Transaction 提供了管理面板来监控事务状态：

# 管理面板配置
tcc.transaction.dashboard.enabled=true
tcc.transaction.dashboard.port=8888
tcc.transaction.dashboard.username=admin
tcc.transaction.dashboard.password=123456

常见问题与解决方案

问题1：网络超时处理

场景：Try 阶段成功，但 Confirm/Cancel 阶段因网络问题失败。

解决方案：

  • 配置合理的超时时间
  • 启用异步 Confirm 模式
  • 利用重试机制自动恢复
@Compensable(
    confirmMethod = "confirmRecord",
    cancelMethod = "cancelRecord",
    asyncConfirm = true,  // 启用异步Confirm
    delayCancelExceptions = {SocketTimeoutException.class}
)

问题2：幂等性保证

场景：Confirm/Cancel 方法被重复调用。

解决方案：

  • 通过业务状态检查实现幂等
  • 使用唯一事务ID避免重复处理
public void confirmRecord(CapitalTradeOrderDto tradeOrderDto) {
    TradeOrder tradeOrder = tradeOrderRepository
        .findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());
    
    // 状态检查确保幂等性
    if (tradeOrder != null && "DRAFT".equals(tradeOrder.getStatus())) {
        // 执行业务逻辑
        tradeOrder.confirm();
        tradeOrderRepository.update(tradeOrder);
    }
}

问题3：性能优化

建议：

  • 合理设置事务超时时间
  • 使用异步 Confirm 减少阻塞
  • 优化数据库访问性能
  • 合理设计事务边界

实战案例：电商支付场景

让我们通过一个电商支付场景来展示 TCC-Transaction 的实际应用：

flowchart LR
    A[用户下单] --> B[订单服务<br>创建订单]
    B --> C[支付服务<br>扣减余额]
    C --> D[库存服务<br>扣减库存]
    D --> E[积分服务<br>增加积分]
    E --> F[支付成功]

在这个场景中，我们需要保证：

  1. 订单创建、支付扣款、库存扣减、积分增加要么全部成功
  2. 任一环节失败，所有已执行的操作都需要回滚

TCC 实现方案：

@Service
public class PaymentServiceImpl {

    @Autowired
    private OrderService orderService;
    
    @Autowired
    private CapitalService capitalService;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PointService pointService;

    @Compensable(
        confirmMethod = "confirmMakePayment",
        cancelMethod = "cancelMakePayment"
    )
    @Transactional
    public void makePayment(String orderNo) {
        // Try 阶段
        orderService.tryCreateOrder(orderNo);
        capitalService.tryDeductBalance(orderNo);
        inventoryService.tryReduceInventory(orderNo);
        pointService.tryAddPoints(orderNo);
    }

    public void confirmMakePayment(String orderNo) {
        // Confirm 阶段
        orderService.confirmCreateOrder(orderNo);
        capitalService.confirmDeductBalance(orderNo);
        inventoryService.confirmReduceInventory(orderNo);
        pointService.confirmAddPoints(orderNo);
    }

    public void cancelMakePayment(String orderNo) {
        // Cancel 阶段
        orderService.cancelCreateOrder(orderNo);
        capitalService.cancelDeductBalance(orderNo);
        inventoryService.cancelReduceInventory(orderNo);
        pointService.cancelAddPoints(orderNo);
    }
}

性能调优与监控

性能指标监控

指标名称 说明 建议值
事务成功率 成功完成的事务比例 > 99.9%
平均响应时间 事务平均处理时间 < 100ms
最大并发数 系统支持的最大并发事务数 根据业务需求
恢复成功率 异常事务自动恢复比例 > 99%

监控配置

# Prometheus 监控配置
management.endpoints.web.exposure.include=health,info,prometheus
management.metrics.export.prometheus.enabled=true

# 日志配置
logging.level.org.mengyun.tcctransaction=DEBUG

总结

TCC-Transaction 作为一个成熟的分布式事务解决方案，为微服务架构下的数据一致性提供了可靠的保障。通过本文的学习，你应该能够：

  1. ✅ 理解 TCC 事务模式的核心概念和工作原理
  2. ✅ 掌握 TCC-Transaction 的基本使用方法
  3. ✅ 配置和管理 TCC 事务环境
  4. ✅ 处理常见的分布式事务问题
  5. ✅ 在实际项目中应用 TCC 模式

关键要点回顾

  • TCC 三阶段：Try（尝试）、Confirm（确认）、Cancel（取消）
  • 幂等性：Confirm 和 Cancel 操作必须保证幂等
  • 异常处理：合理配置超时和重试机制
  • 监控管理：利用管理面板监控事务状态

下一步学习建议

  1. 深入阅读官方文档了解高级特性
  2. 在实际项目中实践 TCC 模式
  3. 学习其他分布式事务解决方案（如 Saga、XA）
  4. 关注性能优化和监控告警

分布式事务是微服务架构中的重要课题，掌握 TCC-Transaction 将帮助你在复杂的业务场景中构建高可用的系统。开始你的 TCC 之旅，构建更加可靠的分布式应用吧！

tcc-transaction
tcc-transaction是TCC型事务java实现
项目地址：https://gitcode.com/gh_mirrors/tc/tcc-transaction
登录后查看全文

相关内容推荐

1 TCC-Transaction 开源项目教程2 【亲测免费】 推荐开源项目：TCC-TRANSACTION — 分布式事务的强大力量3 【亲测免费】 Hmily 分布式事务解决方案常见问题及解决方案4 transaction 项目亮点解析5 3种分布式事务模式深度测评：AT/TCC/Saga如何破解数据一致性难题6 推荐开源项目：Seata-Golang - 分布式事务解决方案7 ByteTCC 分布式事务管理器快速入门指南8 Seata：分布式事务解决方案的最佳实践9 AI应用数据安全新范式：Coze Studio事务管理架构与实践指南10 Seata项目中TCC模式下的死锁问题分析与解决方案
热门项目推荐
相关项目推荐

热门内容推荐

1 build-your-own-x 探索指南：从零构建编程技能体系2 技术实践新范式：build-your-own-x项目的系统构建与能力跃迁指南3 build-your-own-x 开源学习项目一站式指南4 【亲测免费】 开源项目 `build-your-own-x` 使用指南5 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解6 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用7 从零打造智能家居系统：用build-your-own-x实现家庭自动化

最新内容推荐

aliyunpan命令行工具全场景技术指南防撤回功能失效？开源工具3个技巧解决版本适配难题V-JEPA自监督视频表征学习：技术突破与行业实践指南OpenArm开源机械臂：重新定义协作机器人开发的开源硬件平台Zotero插件Ethereal Style：重塑学术研究的文献管理体验告别模组混乱：Wrye Bash让Bethesda游戏体验升级革新性AI开发辅助平台：Every-Marketplace效率倍增指南XposedRimetHelper：基于Hook技术的位置模拟实现与应用解析如何让Mac鼠标侧键重获新生？3步解锁高效导航体验知识网络：思维工具的新范式——开源笔记系统的知识组织深度指南

项目优选

收起
kernelkernel
deepin linux kernel
C
27
13
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
626
4.14 K
RuoYi-Vue3RuoYi-Vue3
🎉 (RuoYi)官方仓库 基于SpringBoot，Spring Security，JWT，Vue3 & Vite、Element Plus 的前后端分离权限管理系统
Vue
1.5 K
852
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
931
809
flutter_flutterflutter_flutter
暂无简介
Dart
873
207
openHiTLSopenHiTLS
旨在打造算法先进、性能卓越、高效敏捷、安全可靠的密码套件，通过轻量级、可剪裁的软件技术架构满足各行业不同场景的多样化要求，让密码技术应用更简单，同时探索后量子等先进算法创新实践，构建密码前沿技术底座！
C
1.06 K
548
pytorchpytorch
Ascend Extension for PyTorch
Python
467
559
OpenBOATOpenBOAT
全称：Open Base Operator for Ascend Toolkit，哈尔滨工业大学AISS团队基于Ascend C打造的高性能昇腾算子库。
C++
45
47
cherry-studiocherry-studio
🍒 Cherry Studio 是一款支持多个 LLM 提供商的桌面客户端
TypeScript
1.25 K
100
MindSpeed-LLMMindSpeed-LLM
昇腾LLM分布式训练框架
Python
138
161