分布式事务：TCC

最新推荐文章于 2025-04-26 16:10:33 发布
最新推荐文章于 2025-04-26 16:10:33 发布
阅读量376 收藏 3
点赞数 3
文章标签： 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangzhanbin/article/details/145845448
版权

下面是一个详细的 TCC（Try-Confirm-Cancel）模式的代码实现示例，采用 Java、Spring Boot 和简单的 REST API。为了演示的完整性，我们将涉及到数据库操作，并使用 Spring Data JPA 进行数据持久化。

1. 项目结构

假设我们的项目结构如下：

src
├── main
│   ├── java
│   │   └── com
│   │       └── example
│   │           ├── transaction
│   │           │   ├── TransactionApplication.java
│   │           │   ├── controller
│   │           │   │   └── TransactionController.java
│   │           │   ├── model
│   │           │   │   ├── Account.java
│   │           │   │   └── Order.java
│   │           │   ├── repository
│   │           │   │   ├── AccountRepository.java
│   │           │   │   └── OrderRepository.java
│   │           │   ├── service
│   │           │   │   ├── AccountService.java
│   │           │   │   ├── OrderService.java
│   │           │   │   └── TCCCoordinator.java
│   │           │   └── exception
│   │           │       └── TransactionException.java
│   │           └── config
│   │               └── DatabaseConfig.java
│   └── resources
│       ├── application.properties
│       └── data.sql

2. 实现代码

2.1. TransactionApplication.java
package com.example.transaction;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class TransactionApplication {
    public static void main(String[] args) {
        SpringApplication.run(TransactionApplication.class, args);
    }
}
2.2. 实体类
2.2.1. Account.java
package com.example.transaction.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Account {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String accountId;
    private double balance;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getAccountId() {
        return accountId;
    }

    public void setAccountId(String accountId) {
        this.accountId = accountId;
    }

    public double getBalance() {
        return balance;
    }

    public void setBalance(double balance) {
        this.balance = balance;
    }
}
2.2.2. Order.java
package com.example.transaction.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String orderId;
    private String accountId;
    private double amount;
    private boolean confirmed;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getAccountId() {
        return accountId;
    }

    public void setAccountId(String accountId) {
        this.accountId = accountId;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public boolean isConfirmed() {
        return confirmed;
    }

    public void setConfirmed(boolean confirmed) {
        this.confirmed = confirmed;
    }
}
2.3. Repository
2.3.1. AccountRepository.java
package com.example.transaction.repository;

import com.example.transaction.model.Account;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AccountRepository extends JpaRepository<Account, Long> {
    Account findByAccountId(String accountId);
}
2.3.2. OrderRepository.java
package com.example.transaction.repository;

import com.example.transaction.model.Order;
import org.springframework.data.jpa.repository.JpaRepository;

public interface OrderRepository extends JpaRepository<Order, Long> {
    Order findByOrderId(String orderId);
}
2.4. Service
2.4.1. AccountService.java
package com.example.transaction.service;

import com.example.transaction.model.Account;
import com.example.transaction.repository.AccountRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountService {
    
    @Autowired
    private AccountRepository accountRepository;

    public boolean tryReserve(String accountId, double amount) {
        Account account = accountRepository.findByAccountId(accountId);
        if (account != null && account.getBalance() >= amount) {
            account.setBalance(account.getBalance() - amount); // Reserve the amount
            accountRepository.save(account);
            return true;
        }
        return false; // Insufficient balance
    }

    public boolean confirmReserve(String accountId, double amount) {
        // Here you can implement the logic to finalize the transaction if needed
        return true; // Assuming confirmation is successful in this example
    }

    public boolean cancelReserve(String accountId, double amount) {
        Account account = accountRepository.findByAccountId(accountId);
        if (account != null) {
            account.setBalance(account.getBalance() + amount); // Release the reserved amount
            accountRepository.save(account);
            return true;
        }
        return false; // Account not found
    }
}
2.4.2. OrderService.java
package com.example.transaction.service;

import com.example.transaction.model.Order;
import com.example.transaction.repository.OrderRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    public boolean tryCreateOrder(String orderId, String accountId, double amount) {
        Order order = new Order();
        order.setOrderId(orderId);
        order.setAccountId(accountId);
        order.setAmount(amount);
        order.setConfirmed(false); // Order is not confirmed yet
        orderRepository.save(order); // Save but do not confirm
        return true; // Assuming order creation is successful
    }

    public boolean confirmOrder(String orderId) {
        Order order = orderRepository.findByOrderId(orderId);
        if (order != null) {
            order.setConfirmed(true); // Confirm the order
            orderRepository.save(order);
            return true;
        }
        return false; // Order not found
    }

    public boolean cancelOrder(String orderId) {
        Order order = orderRepository.findByOrderId(orderId);
        if (order != null) {
            orderRepository.delete(order); // Cancel the order
            return true;
        }
        return false; // Order not found
    }
}
2.4.3. TCCCoordinator.java
package com.example.transaction.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class TCCCoordinator {

    @Autowired
    private AccountService accountService;

    @Autowired
    private OrderService orderService;

    public void executeTCC(String accountId, String orderId, double amount) {
        // Try Phase
        boolean accountReserved = accountService.tryReserve(accountId, amount);
        boolean orderCreated = orderService.tryCreateOrder(orderId, accountId, amount);

        if (accountReserved && orderCreated) {
            // Confirm Phase
            if (!accountService.confirmReserve(accountId, amount)) {
                orderService.cancelOrder(orderId); // If confirmation fails, cancel order
            }
            if (!orderService.confirmOrder(orderId)) {
                accountService.cancelReserve(accountId, amount); // If order confirmation fails, cancel reserve
            }
        } else {
            // If Try phase fails, execute Cancel
            if (!accountReserved) {
                orderService.cancelOrder(orderId); // Cancel the order if account reserve failed
            }
            if (!orderCreated) {
                accountService.cancelReserve(accountId, amount); // Cancel reserve if order creation failed
            }
        }
    }
}
2.5. Controller
2.5.1. TransactionController.java
package com.example.transaction.controller;

import com.example.transaction.service.TCCCoordinator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/transaction")
public class TransactionController {

    @Autowired
    private TCCCoordinator tccCoordinator;

    @PostMapping("/create")
    public ResponseEntity<String> createTransaction(@RequestParam String accountId, @RequestParam String orderId, @RequestParam double amount) {
        tccCoordinator.executeTCC(accountId, orderId, amount);
        return ResponseEntity.ok("Transaction processed successfully");
    }
}
2.6. Exception Handling
2.6.1. TransactionException.java
package com.example.transaction.exception;

public class TransactionException extends RuntimeException {
    public TransactionException(String message) {
        super(message);
    }
}
2.7. 数据库配置
2.7.1. DatabaseConfig.java
package com.example.transaction.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;

@Configuration
@EnableJpaRepositories(basePackages = "com.example.transaction.repository")
public class DatabaseConfig {
    // Configure DataSource bean here if necessary
}
2.8. application.properties
# Database configuration (example for H2 in-memory database)
spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.h2.console.enabled=true
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
2.9. data.sql
INSERT INTO account (account_id, balance) VALUES ('account1', 1000);
INSERT INTO account (account_id, balance) VALUES ('account2', 2000);

3. 启动和测试

  1. 启动应用：运行 TransactionApplication.java，启动 Spring Boot 应用。
  2. 测试 API：使用 Postman 或 CURL 测试创建事务的 API：
    • URL: http://localhost:8080/transaction/create
    • 方法: POST
    • 参数:
      • accountId: account1
      • orderId: order1
      • amount: 500

4. 总结

以上代码实现了一个简单的 TCC 模式，包含账户余额预留和订单创建的逻辑。通过 Try、Confirm 和 Cancel 方法，确保了分布式事务的最终一致性。在真实应用场景中，建议处理异常、记录日志并增加应对并发的措施。可以考虑集成分布式事务管理工具（如 Seata）以简化实现并增强可靠性。

数据库分布式事务：TCC与XA协议
shejizuopin的博客
04-06 515
Try：尝试执行事务，预留必要的业务资源。Confirm：确认执行事务，如果Try阶段成功，则执行Confirm阶段以完成事务。Cancel：取消执行事务，如果Try阶段失败或需要回滚，则执行Cancel阶段以释放预留的资源。// Try阶段：尝试转账，预留金额// Confirm阶段：确认转账，完成转账操作// Cancel阶段：取消转账，释放预留的金额。
分布式事务：从Seata到TCC模式实战
shejizuopin的博客
04-17 1023
Seata（Simple Extensible Autonomous Transaction Architecture）是阿里巴巴中间件团队发起的开源项目，旨在让分布式事务的使用像本地事务一样简单和高效。Seata提供了AT、TCC、SAGA和XA四种事务模式，支持高并发场景下的数据一致性。Seata提供了强大的分布式事务管理能力，通过TCC模式可以实现高性能、强一致性的分布式事务。在实际应用中，开发者应根据具体业务场景选择合适的事务模式，并进行充分的测试和优化，以确保系统的稳定性和性能。
分布式事务-tcc（ 与 2PC 的对比与代码示例）
hl_java的专栏
03-13 831
/ === 订单服务 ===@Service// 幂等检查：防止重复Try// 绑定全局事务ID// 幂等处理// 可能Try未执行// === 库存服务 ===@Service// 幂等检查// 冻结库存（实际库存不变）// 幂等// 实际扣减库存并解冻// 解冻库存// === 支付服务 ===@Service// 预授权资金（冻结金额）// 实际扣款// 释放预授权。
TCC-Transaction分布式事务DEMO
05-22
TCC-Transaction分布式事务DEMO,基于Mysql数据库的事务，包括分布式提交和回滚，例子完成，可以正常跑，基于Maven构建的项目
腾讯二面：TCC分布式事务 ｜ 图解TCC｜用Go语言实现一个TCC
最新发布
面向生活编程
04-26 666
Try：主要是对业务系统做检测及资源预留。Confirm：主要是对业务系统做确认提交，Try 阶段执行成功并开始执行 Confirm 阶段时，默认 Confirm 阶段是不会出错的。Cancel：主要是在业务执行错误，需要回滚的状态下执行的业务取消，释放预留资源。Try阶段完成业务的准备工作，Confirm阶段完成业务的提交，Cancel阶段完成事务的回滚。基本原理如下图所示。事务开始时，上层业务应用会向事务协调器注册启动事务。业务应用会调用所有服务的Try接口，完成一阶段准备。
分布式事务—— TCC 代码示例
yuiezt的专栏
08-01 699
TCC（Try-Confirm-Cancel）是一种分布式事务解决方案，它通常用于在微服务架构中处理跨多个服务的事务。TCC 将长事务拆分成多个短事务，并通过应用层的两阶段提交来确保数据一致性。在 TCC 模型中，每个服务都负责维护自己的事务状态，并在全局事务的协调下执行 Try、Confirm 或 Cancel 操作。
TCC分布式事务案例
lihuayong的专栏
08-06 2008
业务场景介绍 咱们先来看看业务场景，假设你现在有一个电商系统，里面有一个支付订单的场景。 那对一个订单支付之后，我们需要做下面的步骤： 更改订单的状态为“已支付” 扣减商品库存 给会员增加积分 创建销售出库单通知仓库发货 这是一系列比较真实的步骤，无论大家有没有做过电商系统，应该都能理解。 进一步思考 好，业务场景有了，现在我们要更进一步，实现一个 TCC 分布式事务的效果。 什么意思呢？也就是说，[1] 订单服务-修改订单状态，[2] 库存服务-扣减库存，[3] 积分服务-增加积分，
分布式事务实现方案——TCC柔性补充（Hmily）
qq_35599414的博客
11-24 1259
TCC方案（采用Hmily框架） 什么是TCC事务 ？ TCC是Try、Confirm、Cancel三个词语的缩写，TCC要求每个分支事务实现三个操作：预处理Try、确认 Confirm、撤销Cancel。Try操作做业务检查及资源预留，Confirm做业务确认操作，Cancel实现一个与Try相反的 操作即回滚操作。TM首先发起所有的分支事务的try操作，任何一个分支事务的try操作执行失败，TM将会发起所 有分支事务的Cancel操作，若try操作全部成功，TM将会发起所有分支事务的Con..
java tcc事务 例子_java基础之----分布式事务tcc
weixin_28807529的博客
02-16 514
最近研究了一下分布式事务框架，ttc,总体感觉还可以，当然前提条件下是你要会使用这个框架。下面分层次讲，尽量让想学习的同学读了这篇文章能加以操作运用。我不想废话，直接上干货。一.什么是tcc?干什么用的？ttc是分布式事务框架，用于分布式事务的。分布式事务就是针对两个以上的库操作数据事务管理的，比如操作A库B库，当B库失败，也要把A库哪一步操作也要回滚。ttc其实是一个模板框架，是英文字母try,...
分布式事务解决方案：TCC模式
m0_57801749的博客
02-07 448
TCC(Try-Confirm-Cancel)是一种补偿性事务模式,它将一个完整的业务操作分为二步完成Try: 尝试执行业务完成所有业务检查预留必要的业务资源Confirm: 确认执行业务真正执行业务不做任何业务检查只使用 Try 阶段预留的资源Cancel: 取消执行业务释放 Try 阶段预留的资源回滚操作。
分布式事务：XA、TCC、最终一致性方案
牙刷冰冰的博客
03-15 1066
1 分布式事务 1.1 事务的四个特性 ACID Atomicity 原子性 事务中所有的操作要么一起提交，要么一起回滚。 Consistency 一致性 事务一旦提交，数据就会从一个一致性状态，到达另一个一致性状态。 Isolation 隔离性 一个事务中对数据的更改不会影响到另一个事务中的数据。 Durablity 持久性 一旦事务提交，那么对于数据库的更改就是永久的。 1.2 事务场景 假设有这么个场景，用户下单购买商品，则会调用订单中心让其生成订单记录，同时调用库存中心让其扣除商品库存。这两个中
分布式事务处理方案
11-01
多服务器实现分布式事务功能！ 安装DTC组件，设置MSDTC，注意：双方都要启动MSDTC服务，MSDTC服务依赖于RPC（Remote Procedure Call (RPC)）服务，RPC使用135端口，保证RPC服务启动，如果服务器有防火墙，保证135端口不被防火墙挡住；保证链接服务器中语句没有访问发起事务服务器的操作。 采用WEB的TransactionScope（事务块）方式，实例代码如下： public void GotoTransactionScope() { //创建事务块 using (TransactionScope TransScope = new TransactionScope()) { try { int intResult = 0; //服务器1操作 intResult = GoServerOne(); ..........................
分布式事务 Seata TCC 模式深度解析
07-01
本文档的内容主要分为以下四个部分： 1、Seata TCC 模式的原理解析； 2、从 TCC 的业务模型与并发控制分享如何设计一个 TCC 接口，并且适配 TCC 模型； 3、如何控制异常； 4、性能优化，使得 TCC 模式能够满足更高的业务需求。
从银行转账失败到分布式事务：总结与思考
01-27
常见的分布式事务解决方案包括两阶段提交（2PC）、三阶段提交（3PC）、补偿事务（Saga）、分布式事务协调器（如TCC - Try-Confirm-Cancel）、最终一致性模型等。每种方案都有其优缺点，适用于不同的场景和性能需求。...
分布式事务解决方案之TCC
LU58542226的博客
09-15 4523
TCC是Try、Confirm、Cancel三个词语的缩写，TCC要求每个分支事务实现三个操作：预处理Try、确认 Confirm、撤销Cancel。Try操作做业务检查及资源预留，Confirm做业务确认操作，Cancel实现一个与Try相反的 操作即回滚操作。
分布式事务之TCC事务
weixin_33672400的博客
03-17 334
2019独角兽企业重金招聘Python工程师标准>>> ...
如何在Java中实现分布式事务处理
微赚淘客系统开发者博客
07-04 494
分布式事务的目的是确保跨多个服务或数据库的操作可以作为一个单一的逻辑操作来执行，从而保证数据的一致性。分布式事务处理是Java分布式系统开发中的重要技术，合理选择分布式事务处理方案，并结合实际业务场景进行优化，可以有效提高系统的稳定性和一致性。本文介绍了XA协议、TCC模式和Saga模式三种常见的分布式事务处理方法，并提供了相关示例代码，帮助大家更好地理解和实现分布式事务处理。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！
分布式事务算法——TCC 分布式事务全面解析
专注分享技术、实用优质教程、资源
04-06 944
分布式事务算法——TCC 分布式事务全面解析
java 分布式事务的实现方式之TCC方案
yuanchengfu0910的博客
06-14 1880
TCC 是一种补偿性的事务模式，它通过在事务执行之前定义 Try、Confirm 和 Cancel 三个阶段来实现事务的一致性。在 Try 阶段，业务逻辑会尝试预留所需的资源和执行必要的检查，但不会真正进行数据修改。它会预留相关资源，并执行一些预检查，以确保后续的 Confirm 阶段可以成功执行。如果 Try 阶段执行成功，则事务可以进入 Confirm 阶段。如果 Try 阶段失败，则事务进入 Cancel 阶段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你不懂、、、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值