分布式事务中间件 TCC-Transaction 源码分析 —— 项目实战

最新推荐文章于 2024-08-18 20:35:09 发布
最新推荐文章于 2024-08-18 20:35:09 发布
阅读量2.8k 收藏 7
点赞数
分类专栏： 分布式事务

摘要: 原创出处 http://www.iocoder.cn/TCC-Transaction/http-sample/ 「芋道源码」欢迎转载，保留摘要，谢谢！

本文主要基于 TCC-Transaction 1.2.3.3 正式版

������关注**微信公众号：【芋道源码】**有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

1. 概述

本文分享 TCC 项目实战。以官方 Maven项目 tcc-transaction-http-sample 为例子( tcc-transaction-dubbo-sample 类似 )。

建议你已经成功启动了该项目。如果不知道如何启动，可以先查看《TCC-Transaction 源码分析 —— 调试环境搭建》。如果再碰到问题，欢迎加微信公众号( 芋道源码 )，我会一一仔细回复。

OK，首先我们简单了解下这个项目。

  • 首页 => 商品列表 => 确认支付页 => 支付结果页
  • 使用账户余额 + 红包余额联合支付购买商品，并账户之间转账。

项目拆分三个子 Maven 项目：

  • tcc-transaction-http-order ：商城服务，提供商品和商品订单逻辑。
  • tcc-transaction-http-capital ：资金服务，提供账户余额逻辑。
  • tcc-transaction-http-redpacket ：红包服务，提供红包余额逻辑。

你行好事会因为得到赞赏而愉悦同理，开源项目贡献者会因为 Star 而更加有动力为 TCC-Transaction 点赞！传送门

2. 实体结构

2.1 商城服务

  • Shop，商店表。实体代码如下：
    public class Shop {
    /**
    * 商店编号
    */
    private long id;
    /**
    * 所有者用户编号
    */
    private long ownerUserId;
    }

  • Product，商品表。实体代码如下：
    public class Product implements Serializable {
    /**
    * 商品编号
    */
    private long productId;
    /**
    * 商店编号
    */
    private long shopId;
    /**
    * 商品名
    */
    private String productName;
    /**
    * 单价
    */
    private BigDecimal price;
    }

  • Order，订单表。实现代码如下：
    public class Order implements Serializable {
    private static final long serialVersionUID = - 5908730245224893590L;
    /**
    * 订单编号
    */
    private long id;
    /**
    * 支付( 下单 )用户编号
    */
    private long payerUserId;
    /**
    * 收款( 商店拥有者 )用户编号
    */
    private long payeeUserId;
    /**
    * 红包支付金额
    */
    private BigDecimal redPacketPayAmount;
    /**
    * 账户余额支付金额
    */
    private BigDecimal capitalPayAmount;
    /**
    * 订单状态
    * - DRAFT ：草稿
    * - PAYING ：支付中
    * - CONFIRMED ：支付成功
    * - PAY_FAILED ：支付失败
    */
    private String status = "DRAFT";
    /**
    * 商户订单号，使用 UUID 生成
    */
    private String merchantOrderNo;
    /**
    * 订单明细数组
    * 非存储字段
    */
    private List<OrderLine> orderLines = new ArrayList<OrderLine>();
    }

  • OrderLine，订单明细。实体代码如下：
    public class OrderLine implements Serializable {
    private static final long serialVersionUID = 2300754647209250837L;
    /**
    * 订单编号
    */
    private long id;
    /**
    * 商品编号
    */
    private long productId;
    /**
    * 数量
    */
    private int quantity;
    /**
    * 单价
    */
    private BigDecimal unitPrice;
    }

业务逻辑：

下单时，插入订单状态为 "DRAFT" 的订单( Order )记录，并插入购买的商品订单明细( OrderLine )记录。支付时，更新订单状态为 "PAYING"。

  • 订单支付成功，更新订单状态为 "CONFIRMED"。
  • 订单支付失败，更新订单状体为 "PAY_FAILED"。

2.2 资金服务

关系较为简单，有两个实体：

  • CapitalAccount，资金账户余额。实体代码如下：
    public class CapitalAccount {
    /**
    * 账户编号
    */
    private long id;
    /**
    * 用户编号
    */
    private long userId;
    /**
    * 余额
    */
    private BigDecimal balanceAmount;
    }

  • TradeOrder，交易订单表。实体代码如下：
    public class TradeOrder {
    /**
    * 交易订单编号
    */
    private long id;
    /**
    * 转出用户编号
    */
    private long selfUserId;
    /**
    * 转入用户编号
    */
    private long oppositeUserId;
    /**
    * 商户订单号
    */
    private String merchantOrderNo;
    /**
    * 金额
    */
    private BigDecimal amount;
    /**
    * 交易订单状态
    * - DRAFT ：草稿
    * - CONFIRM ：交易成功
    * - CANCEL ：交易取消
    */
    private String status = "DRAFT";
    }

业务逻辑：

订单支付支付中，插入交易订单状态为 "DRAFT" 的订单( TradeOrder )记录，并更新减少下单用户的资金账户余额。

  • 订单支付成功，更新交易订单状态为 "CONFIRM"，并更新增加商店拥有用户的资金账户余额。
  • 订单支付失败，更新交易订单状态为 "CANCEL"，并更新**增加( 恢复 )**下单用户的资金账户余额。

2.3 红包服务

关系较为简单，和资金服务 99.99% 相同，有两个实体：

  • RedPacketAccount，红包账户余额。实体代码如下：
    public class RedPacketAccount {
    /**
    * 账户编号
    */
    private long id;
    /**
    * 用户编号
    */
    private long userId;
    /**
    * 余额
    */
    private BigDecimal balanceAmount;
    }

  • TradeOrder，交易订单表。实体代码如下：
    public class TradeOrder {
    /**
    * 交易订单编号
    */
    private long id;
    /**
    * 转出用户编号
    */
    private long selfUserId;
    /**
    * 转入用户编号
    */
    private long oppositeUserId;
    /**
    * 商户订单号
    */
    private String merchantOrderNo;
    /**
    * 金额
    */
    private BigDecimal amount;
    /**
    * 交易订单状态
    * - DRAFT ：草稿
    * - CONFIRM ：交易成功
    * - CANCEL ：交易取消
    */
    private String status = "DRAFT";
    }

业务逻辑：

订单支付支付中，插入交易订单状态为 "DRAFT" 的订单( TradeOrder )记录，并更新减少下单用户的红包账户余额。

  • 订单支付成功，更新交易订单状态为 "CONFIRM"，并更新增加商店拥有用户的红包账户余额。
  • 订单支付失败，更新交易订单状态为 "CANCEL"，并更新**增加( 恢复 )**下单用户的红包账户余额。

3. 服务调用

服务之间，通过 HTTP 进行调用。

红包服务和资金服务为商城服务提供调用( 以资金服务为例子 )：

  • XML 配置如下 ：
    // appcontext-service-provider.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <bean name="capitalAccountRepository"
    class="org.mengyun.tcctransaction.sample.http.capital.domain.repository.CapitalAccountRepository"/>
    <bean name="tradeOrderRepository"
    class="org.mengyun.tcctransaction.sample.http.capital.domain.repository.TradeOrderRepository"/>
    <bean name="capitalTradeOrderService"
    class="org.mengyun.tcctransaction.sample.http.capital.service.CapitalTradeOrderServiceImpl"/>
    <bean name="capitalAccountService"
    class="org.mengyun.tcctransaction.sample.http.capital.service.CapitalAccountServiceImpl"/>
    <bean name="capitalTradeOrderServiceExporter"
    class="org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter">
    <property name="service" ref="capitalTradeOrderService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.capital.api.CapitalTradeOrderService"/>
    </bean>
    <bean name="capitalAccountServiceExporter"
    class="org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter">
    <property name="service" ref="capitalAccountService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.capital.api.CapitalAccountService"/>
    </bean>
    <bean id="httpServer"
    class="org.springframework.remoting.support.SimpleHttpServerFactoryBean">
    <property name="contexts">
    <util:map>
    <entry key="/remoting/CapitalTradeOrderService" value-ref="capitalTradeOrderServiceExporter"/>
    <entry key="/remoting/CapitalAccountService" value-ref="capitalAccountServiceExporter"/>
    </util:map>
    </property>
    <property name="port" value="8081"/>
    </bean>
    </beans>

  • Java 代码实现如下 ：
    public class CapitalAccountServiceImpl implements CapitalAccountService {
    @Autowired
    CapitalAccountRepository capitalAccountRepository;
    @Override
    public BigDecimal getCapitalAccountByUserId(long userId) {
    return capitalAccountRepository.findByUserId(userId).getBalanceAmount();
    }
    }
    public class CapitalAccountServiceImpl implements CapitalAccountService {
    @Autowired
    CapitalAccountRepository capitalAccountRepository;
    @Override
    public BigDecimal getCapitalAccountByUserId(long userId) {
    return capitalAccountRepository.findByUserId(userId).getBalanceAmount();
    }
    }

商城服务调用

  • XML 配置如下：
    // appcontext-service-consumer.xml
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="httpInvokerRequestExecutor"
    class="org.springframework.remoting.httpinvoker.CommonsHttpInvokerRequestExecutor">
    <property name="httpClient">
    <bean class="org.apache.commons.httpclient.HttpClient">
    <property name="httpConnectionManager">
    <ref bean="multiThreadHttpConnectionManager"/>
    </property>
    </bean>
    </property>
    </bean>
    <bean id="multiThreadHttpConnectionManager"
    class="org.apache.commons.httpclient.MultiThreadedHttpConnectionManager">
    <property name="params">
    <bean class="org.apache.commons.httpclient.params.HttpConnectionManagerParams">
    <property name="connectionTimeout" value="200000"/>
    <property name="maxTotalConnections" value="600"/>
    <property name="defaultMaxConnectionsPerHost" value="512"/>
    <property name="soTimeout" value="5000"/>
    </bean>
    </property>
    </bean>
    <bean id="captialTradeOrderService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
    <property name="serviceUrl" value="http://localhost:8081/remoting/CapitalTradeOrderService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.capital.api.CapitalTradeOrderService"/>
    <property name="httpInvokerRequestExecutor" ref="httpInvokerRequestExecutor"/>
    </bean>
    <bean id="capitalAccountService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
    <property name="serviceUrl" value="http://localhost:8081/remoting/CapitalAccountService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.capital.api.CapitalAccountService"/>
    <property name="httpInvokerRequestExecutor" ref="httpInvokerRequestExecutor"/>
    </bean>
    <bean id="redPacketAccountService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
    <property name="serviceUrl" value="http://localhost:8082/remoting/RedPacketAccountService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.redpacket.api.RedPacketAccountService"/>
    <property name="httpInvokerRequestExecutor" ref="httpInvokerRequestExecutor"/>
    </bean>
    <bean id="redPacketTradeOrderService" class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
    <property name="serviceUrl" value="http://localhost:8082/remoting/RedPacketTradeOrderService"/>
    <property name="serviceInterface"
    value="org.mengyun.tcctransaction.sample.http.redpacket.api.RedPacketTradeOrderService"/>
    <property name="httpInvokerRequestExecutor" ref="httpInvokerRequestExecutor"/>
    </bean>
    </beans>

  • Java 接口接口如下：
    public interface CapitalAccountService {
    BigDecimal getCapitalAccountByUserId(long userId);
    }
    public interface CapitalTradeOrderService {
    String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto);
    }
    public interface RedPacketAccountService {
    BigDecimal getRedPacketAccountByUserId(long userId);
    }
    public interface RedPacketTradeOrderService {
    String record(TransactionContext transactionContext, RedPacketTradeOrderDto tradeOrderDto);
    }

4. 下单支付流程

ps：数据访问的方法，请自己拉取代码，使用 IDE 查看。谢谢。��

下单支付流程，整体流程如下图( 打开大图 )：

点击**【支付】**按钮，下单支付流程。实现代码如下：
@Controller
@RequestMapping( "")
public class OrderController {
@RequestMapping(value = "/placeorder", method = RequestMethod.POST)
public ModelAndView placeOrder(@RequestParam String redPacketPayAmount,
@RequestParam long shopId,
@RequestParam long payerUserId,
@RequestParam long productId) {
PlaceOrderRequest request = buildRequest(redPacketPayAmount, shopId, payerUserId, productId);
// 下单并支付订单
String merchantOrderNo = placeOrderService.placeOrder(request.getPayerUserId(), request.getShopId(),
request.getProductQuantities(), request.getRedPacketPayAmount());
// 返回
ModelAndView mv = new ModelAndView( "pay_success");
// 查询订单状态
String status = orderService.getOrderStatusByMerchantOrderNo(merchantOrderNo);
// 支付结果提示
String payResultTip = null;
if ( "CONFIRMED".equals(status)) {
payResultTip = "支付成功";
} else if ( "PAY_FAILED".equals(status)) {
payResultTip = "支付失败";
}
mv.addObject( "payResult", payResultTip);
// 商品信息
mv.addObject( "product", productRepository.findById(productId));
// 资金账户金额 和 红包账户金额
mv.addObject( "capitalAmount", accountService.getCapitalAccountByUserId(payerUserId));
mv.addObject( "redPacketAmount", accountService.getRedPacketAccountByUserId(payerUserId));
return mv;
}
}

调用 PlaceOrderService#placeOrder(...) 方法，下单并支付订单。实现代码如下：
@Service
public class PlaceOrderServiceImpl {
public String placeOrder(long payerUserId, long shopId, List<Pair<Long, Integer>> productQuantities, BigDecimal redPacketPayAmount) {
// 获取商店
Shop shop = shopRepository.findById(shopId);
// 创建订单
Order order = orderService.createOrder(payerUserId, shop.getOwnerUserId(), productQuantities);
// 发起支付
Boolean result = false;
try {
paymentService.makePayment(order, redPacketPayAmount, order.getTotalAmount().subtract(redPacketPayAmount));
} catch (ConfirmingException confirmingException) {
// exception throws with the tcc transaction status is CONFIRMING,
// when tcc transaction is confirming status,
// the tcc transaction recovery will try to confirm the whole transaction to ensure eventually consistent.
result = true;
} catch (CancellingException cancellingException) {
// exception throws with the tcc transaction status is CANCELLING,
// when tcc transaction is under CANCELLING status,
// the tcc transaction recovery will try to cancel the whole transaction to ensure eventually consistent.
} catch (Throwable e) {
// other exceptions throws at TRYING stage.
// you can retry or cancel the operation.
e.printStackTrace();
}
return order.getMerchantOrderNo();
}
}

  • 调用 ShopRepository#findById(...) 方法，查询商店。

  • 调用 OrderService#createOrder(...) 方法，创建订单状态为 "DRAFT" 的商城订单。实际业务不会这么做，此处仅仅是例子，简化流程。实现代码如下：
    @Service
    public class OrderServiceImpl {
    @Transactional
    public Order createOrder(long payerUserId, long payeeUserId, List<Pair<Long, Integer>> productQuantities) {
    Order order = orderFactory.buildOrder(payerUserId, payeeUserId, productQuantities);
    orderRepository.createOrder(order);
    return order;
    }
    }

  • 调用 PaymentService#makePayment(...) 方法，发起支付，TCC 流程。
  • 生产代码对于异常需要进一步处理。
  • 生产代码对于异常需要进一步处理。
  • 生产代码对于异常需要进一步处理。

4.1 Try 阶段

商城服务

调用 PaymentService#makePayment(...) 方法，发起 Try 流程，实现代码如下：
@Compensable(confirmMethod = "confirmMakePayment", cancelMethod = "cancelMakePayment")
@Transactional
public void makePayment(Order order, BigDecimal redPacketPayAmount, BigDecimal capitalPayAmount) {
System.out.println( "order try make payment called.time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 更新订单状态为支付中
order.pay(redPacketPayAmount, capitalPayAmount);
orderRepository.updateOrder(order);
// 资金账户余额支付订单
String result = tradeOrderServiceProxy.record( null, buildCapitalTradeOrderDto(order));
// 红包账户余额支付订单
String result2 = tradeOrderServiceProxy.record( null, buildRedPacketTradeOrderDto(order));
}

  • 设置方法注解 @Compensable

    • 事务传播级别 Propagation.REQUIRED ( 默认值 )
    • 设置 confirmMethod / cancelMethod 方法名
    • 事务上下文编辑类 DefaultTransactionContextEditor ( 默认值 )

  • 设置方法注解 @Transactional，保证方法操作原子性。

  • 调用 OrderRepository#updateOrder(...) 方法，更新订单状态为支付中。实现代码如下：
    // Order.java
    public void pay(BigDecimal redPacketPayAmount, BigDecimal capitalPayAmount) {
    this.redPacketPayAmount = redPacketPayAmount;
    this.capitalPayAmount = capitalPayAmount;
    this.status = "PAYING";
    }

  • 调用 TradeOrderServiceProxy#record(...) 方法，资金账户余额支付订单。实现代码如下：
    // TradeOrderServiceProxy.java
    @Compensable(propagation = Propagation.SUPPORTS, confirmMethod = "record", cancelMethod = "record", transactionContextEditor = Compensable.DefaultTransactionContextEditor.class)
    public String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {
    return capitalTradeOrderService.record(transactionContext, tradeOrderDto);
    }
    // CapitalTradeOrderService.java
    public interface CapitalTradeOrderService {
    String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto);
    }

    • 设置方法注解 @Compensable

      • propagation=Propagation.SUPPORTS ：支持当前事务，如果当前没有事务，就以非事务方式执行。为什么不使用 REQUIRED ？如果使用 REQUIRED 事务传播级别，事务恢复重试时，会发起新的事务。
      • confirmMethod、cancelMethod 使用和 try 方法相同方法名：本地发起远程服务 TCC confirm / cancel 阶段，调用相同方法进行事务的提交或回滚。远程服务的 CompensableTransactionInterceptor 会根据事务的状态是 CONFIRMING / CANCELLING 来调用对应方法。

    • 调用 CapitalTradeOrderService#record(...) 方法，远程调用，发起资金账户余额支付订单。

  • 调用 TradeOrderServiceProxy#record(...) 方法，红包账户余额支付订单。和资金账户余额支付订单 99.99% 类似，不重复“复制粘贴”。

资金服务

调用 CapitalTradeOrderServiceImpl#record(...) 方法，红包账户余额支付订单。实现代码如下：
@Override
@Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord", transactionContextEditor = Compensable.DefaultTransactionContextEditor.class)
@Transactional
public String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {
// 调试用
try {
Thread.sleep( 1000l);
// Thread.sleep(10000000L);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println( "capital try record called. time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 生成交易订单
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";
}

  • 设置方法注解 @Compensable

    • 事务传播级别 Propagation.REQUIRED ( 默认值 )
    • 设置 confirmMethod / cancelMethod 方法名
    • 事务上下文编辑类 DefaultTransactionContextEditor ( 默认值 )

  • 设置方法注解 @Transactional，保证方法操作原子性。

  • 调用 TradeOrderRepository#insert(...) 方法，生成订单状态为 "DRAFT" 的交易订单。

  • 调用 CapitalAccountRepository#save(...) 方法，更新减少下单用户的资金账户余额。Try 阶段锁定资源时，一定要先扣。TCC 是最终事务一致性，如果先添加，可能被使用。

4.2 Confirm / Cancel 阶段

当 Try 操作全部成功时，发起 Confirm 操作。当 Try 操作存在任务失败时，发起 Cancel 操作。

4.2.1 Confirm

商城服务

调用 PaymentServiceImpl#confirmMakePayment(...) 方法，更新订单状态为支付成功。实现代码如下：
public void confirmMakePayment(Order order, BigDecimal redPacketPayAmount, BigDecimal capitalPayAmount) {
// 调试用
try {
Thread.sleep( 1000l);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println( "order confirm make payment called. time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 更新订单状态为支付成功
order.confirm();
orderRepository.updateOrder(order);
}

  • 生产代码该方法需要加下 @Transactional 注解，保证原子性。

  • 调用 OrderRepository#updateOrder(...) 方法，更新订单状态为支付成功。实现代码如下：
    // Order.java
    public void confirm() {
    this.status = "CONFIRMED";
    }

资金服务

调用 CapitalTradeOrderServiceImpl#confirmRecord(...) 方法，更新交易订单状态为交易成功。
@Transactional
public void confirmRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {
// 调试用
try {
Thread.sleep( 1000l);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println( "capital confirm record called. time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 查询交易记录
TradeOrder tradeOrder = tradeOrderRepository.findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());
// 判断交易记录状态。因为 `#record()` 方法，可能事务回滚，记录不存在 / 状态不对
if ( null != tradeOrder && "DRAFT".equals(tradeOrder.getStatus())) {
// 更新订单状态为交易成功
tradeOrder.confirm();
tradeOrderRepository.update(tradeOrder);
// 更新增加商店拥有者用户的资金账户余额
CapitalAccount transferToAccount = capitalAccountRepository.findByUserId(tradeOrderDto.getOppositeUserId());
transferToAccount.transferTo(tradeOrderDto.getAmount());
capitalAccountRepository.save(transferToAccount);
}
}

  • 设置方法注解 @Transactional，保证方法操作原子性。

  • 判断交易记录状态。因为 #record() 方法，可能事务回滚，记录不存在 / 状态不对。

  • 调用 TradeOrderRepository#update(...) 方法，更新交易订单状态为交易成功。

  • 调用 CapitalAccountRepository#save(...) 方法，更新增加商店拥有者用户的资金账户余额。实现代码如下：
    // CapitalAccount.java
    public void transferTo(BigDecimal amount) {
    this.balanceAmount = this.balanceAmount.add(amount);
    }

红包服务

和资源服务 99.99% 相同，不重复“复制粘贴”。

4.2.2 Cancel

商城服务

调用 PaymentServiceImpl#cancelMakePayment(...) 方法，更新订单状态为支付失败。实现代码如下：
public void cancelMakePayment(Order order, BigDecimal redPacketPayAmount, BigDecimal capitalPayAmount) {
// 调试用
try {
Thread.sleep( 1000l);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println( "order cancel make payment called.time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 更新订单状态为支付失败
order.cancelPayment();
orderRepository.updateOrder(order);
}

  • 生产代码该方法需要加下 @Transactional 注解，保证原子性。

  • 调用 OrderRepository#updateOrder(...) 方法，更新订单状态为支付失败。实现代码如下：
    // Order.java
    public void cancelPayment() {
    this.status = "PAY_FAILED";
    }

资金服务

调用 CapitalTradeOrderServiceImpl#cancelRecord(...) 方法，更新交易订单状态为交易失败。
@Transactional
public void cancelRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {
// 调试用
try {
Thread.sleep( 1000l);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println( "capital cancel record called. time seq:" + DateFormatUtils.format(Calendar.getInstance(), "yyyy-MM-dd HH:mm:ss"));
// 查询交易记录
TradeOrder tradeOrder = tradeOrderRepository.findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());
// 判断交易记录状态。因为 `#record()` 方法，可能事务回滚，记录不存在 / 状态不对
if ( null != tradeOrder && "DRAFT".equals(tradeOrder.getStatus())) {
// / 更新订单状态为交易失败
tradeOrder.cancel();
tradeOrderRepository.update(tradeOrder);
// 更新增加( 恢复 )下单用户的资金账户余额
CapitalAccount capitalAccount = capitalAccountRepository.findByUserId(tradeOrderDto.getSelfUserId());
capitalAccount.cancelTransfer(tradeOrderDto.getAmount());
capitalAccountRepository.save(capitalAccount);
}
}

  • 设置方法注解 @Transactional，保证方法操作原子性。

  • 判断交易记录状态。因为 #record() 方法，可能事务回滚，记录不存在 / 状态不对。

  • 调用 TradeOrderRepository#update(...) 方法，更新交易订单状态为交易失败。

  • 调用 CapitalAccountRepository#save(...) 方法，更新增加( 恢复 )下单用户的资金账户余额。实现代码如下：
    // CapitalAccount.java
    public void cancelTransfer(BigDecimal amount) {
    transferTo(amount);
    }

红包服务

和资源服务 99.99% 相同，不重复“复制粘贴”。

666. 彩蛋

知识星球

嘿嘿，代码只是看起来比较多，实际不多。

蚂蚁金融云提供了银行间转账的 TCC 过程例子，有兴趣的同学可以看看：《蚂蚁金融云 —— 分布式事务服务（DTS） —— 场景介绍》。

本系列 EOF ~撒花

胖友，分享个朋友圈，可好？！

lldouble
关注
专栏目录
分布式事务解决方案之TCC Transaction 下篇
vincent
04-02 5371
TCC Transaction  框架解析核心通过拦截器构建事务上下文，经过反射进行confirm/cancel操作。DTOTransactionXid (Xid： 指一个XA事务。不同的数据库要不同的 Xid（每个数据库连接（分支）一个）) : formatId(XID 的格式标识符)、 globalTransactionId(全局事务ID)、branchQualifier(分支限定符)Tran...
TCC-Transaction 分布式事务 —— 项目实战
qq_43253123的博客
10-22 9637
推荐 Spring Boot/Cloud 视频： Java 微服务实践 - Spring Boot Java 微服务实践 - Spring Cloud 本文主要基于 TCC-Transaction 1.2.3.3 正式版 1. 概述 本文分享 TCC 项目实战。以官方 Maven项目 tcc-transaction-http-sample 为例子( tcc-transaction-dubbo-...
tcc-transaction 1.2.x 使用指南
qq_30420359的博客
10-26 2572
1.2.x支持rpc框架支持隐式传参情况下将事务上下文参数TransactionContext以隐式传参方式进行传递，目前支持rpc框架为dubbo时的隐式传参方式传递，具体配置可参考下面“rpc框架为dubbo时隐式传参方式配置”。 配置tcc-transaction 1 引用tcc-transaction 在服务调用方和提供方项目中需要引用tcc-transaction-spring j...
分布式事务方案—— TCC事务
最新发布
祝你身体健康，美满幸福
08-18 372
主要介绍什么是 TCC 事务
分布式事务--TCC的中间件--选型/对比
IT利刃出鞘的博客
02-14 3267
本文介绍分布式事务的TCC的一些中间件。
分布式事务之TCC
大袤宏图
06-15 938
TCC（Try-Confirm-Cancel）模式是一种常见的分布式事务解决方案，它通过将一个事务拆分为三个阶段来实现分布式事务的一致性。tryconfirmcancel这个案例展示了如何使用TCC模式来管理分布式事务。实际应用中，TCC模式可能需要与数据库事务、消息队列等其他技术结合使用，以确保事务的最终一致性。此外，错误处理、日志记录、事务超时等也是实现分布式事务时需要考虑的因素。
分布式事务TCC
调皮的写代码
08-06 379
一、分布式事务 二、分布式事务的存在问题 三、分布式事务使用场景
基于Hyperf的TCC分布式事务-tcc-transaction.zip
11-06
总之，"基于Hyperf的TCC分布式事务-tcc-transaction.zip"项目为开发者提供了一个实践TCC模式的起点，通过这个项目，你可以深入了解如何在Hyperf中实现高效的分布式事务处理，提升微服务架构中的数据一致性。...
TCC-Transaction分布式事务DEMO
05-22
在这个"TCC-Transaction分布式事务DEMO"项目中，开发者已经实现了一个可运行的示例，展示了如何在Maven项目中集成TCC模式，并利用Mysql数据库进行分布式事务的处理。通过分析和学习这个DEMO，我们可以更好地理解TCC...
分布式事务 TCC-Transaction 源码分析 —— TCC 实现
热门推荐
芋道源码
01-31 1万+
本文主要基于 TCC-Transaction 1.2.3.3 正式版1. 概述2. TCC 原理3. TCC-Transaction 原理4. 事务与参与者4.1 事务4.2 参与者5. 事务管理器5.1 发起根事务5.2 传播发起分支事务5.3 传播获取分支事务5.4 提交事务5.5 回滚事务5.6 添加参与者到事务6. 事务拦截器6.1 Compensable6.2 可补偿事务拦截器6.3 资
基于TCC的分布式事务代码示例：使用tcc-transaction框架.zip
03-03
这个压缩包“基于TCC的分布式事务代码示例：使用tcc-transaction框架.zip”提供了一个具体的实现示例，我们可以从中学习到如何在实际应用中使用TCC来处理分布式事务。 TCC模式的核心思想是将每个业务操作拆分为三个...
TCC实现分布式事物，java 源码
05-31
TCC实现分布式事物，实现多数据源，多应用事物统一管理。代码过多，需经验丰富
EasyTransaction：一种分布式事务解决方案（分布式事务），统一使用了TCC，SAGA，FMT（seatafescar自动补偿），可靠消息，补偿等功能；
02-28
简体中文 零，SEO 柔性事务，分布式事务，TCC，SAGA，可靠消息，最大努力交付消息，事务消息，补偿，分成事务，软交易，分配交易，补偿，自动补偿 本框架可一站式解决分布式SOA（包括微服务等）的事务问题。 一，由来及特性 这个框架是结合公司之前遇到的分布式事务场景以及支付宝程立分享的一个PPT <大规模SOA系统的分布式事务处理>而设计实现的。 本框架意在解决之前公司针对每个分散事务场景中都自行重复设计的中间状态，幂等实现及重试逻辑的状况。 采取本框架后能解决现有已发现的所有分布式事务场景，减少设计开发设计工作量，提高开发效率，并统一保证事务实现的可靠性。 特性： POSTJAR包即用，无需独立部署协调者，无需独立部署ZooKeeper（使用extensionsuite-database-starter时） 一个框架包含多种事务形态，一个框架搞定所有类型的事务 多种事务形态可混合使用
中间件技术课件 包括远程过程调用中间件、分布式对象中间件、事务处理中间件
02-24
中间件是一种处于系统软件（操作系统和网络软件）与应用软件之间的软件，它能使应用软件之间进行跨网络的透明访问和协同工作.ppt介绍了远程过程调用中间件、分布式对象中间件、事务处理中间件 以及消息中间件的基本工作原理和代表，可全面透视各类中间件及应用场景。
分布式事务中间件 Seata学习系列之一：初识Seata
08-31 685
引言 微服务已经不是什么新鲜话题了，越来越多的公司在进行微服务改造以及相关的框架也比较多，例如Spring Cloud、Dubbo等都是非常优秀的分布式框架。分布式服务在飞速发展，在给我们带来减少业务耦合、独立部署等诸多优点的同时，也带来了维护成本高、系统复杂度上升等问题，其中有位突出的就是分布式事务问题。 什么是 Seata 总结 https://yq.aliyun.com/articles/...
tcc-transaction 分布式事务-完整代码实现
小菜鸟的博客
12-20 9541
1、说明         这里给出完整实现代码，关于使用方法具体介绍请参考上一篇博文：        分布式事务之-tcc-transaction（Dubbo版）:https://blog.csdn.net/u013278314/article/details/85112314 2、系统介绍         实现一个订单、红包的分布式系统，在生成订单的时候，调用红包服务，同时保持数据到红包...
@transaction 提交事务_分布式事务 TCC-Transaction 源码分析——TCC 实现
weixin_42515120的博客
01-14 200
1. 概述本文分享 TCC 实现。主要涉及如下三个 Maven 项目：tcc-transaction-core ：tcc-transaction 底层实现。tcc-transaction-api ：tcc-transaction 使用 API。tcc-transaction-spring ：tcc-transaction Spring 支持。你行好事会因为得到赞赏而愉悦同理，开源项目贡献者会因为 ...
分布式事务中间件 TCC-Transaction 源码分析 —— Dubbo 支持
weixin_33873846的博客
11-28 167
1. 概述 本文分享 Dubbo 支持。 TCC-Transaction 通过 Dubbo 隐式传参的功能，避免自己对业务代码的入侵。可能有同学不太理解为什么说 TCC-Transaction 对业务代码有一定的入侵性，一起来看个代码例子： 代码来自 tcc-transaction-http-sample 。声明远程调用时，增加了参数 TransactionContext。当然你也可以通过自己...
Spring Boot 中的 TCC 事务
程序猿徐师兄的博客
07-04 948
TCC 事务是一种基于补偿事务的分布式事务解决方案，可以帮助我们解决分布式事务的问题。在 Spring Boot 中，我们可以使用 Seata 来实现 TCC 事务，并利用其强大的功能来管理和控制分布式事务。本文介绍了 TCC 事务的概念和原理，并给出了一个基本的 Spring Boot + Seata TCC 事务示例。通过学习本。
分布式事务管理组件seata 和 TCC-Transaction
04-25
两者有什么区别和优缺点？ Seata和TCC-Transaction都是分布式事务管理组件，都可以用来解决分布式事务问题，但是它们的实现方式有所不同。 Seata通过基于行级锁的分布式事务协调器来实现分布式事务管理，具有高可用性和高性能的特点。Seata可以使用XA或TCC等事务模型，可以精确控制每个分支事务的生命周期。 TCC-Transaction则是通过尝试、确认、取消三个阶段来实现分布式事务管理，具有技术栈无关性，并且能够灵活地处理嵌套事务和异常情况。 相较而言，Seata更加成熟和稳定，支持多种事务模型，在容错性和性能方面都有所优化。而TCC-Transaction则更加灵活，可以适应各种场景和技术栈。 总的来说，选择哪一种分布式事务管理组件需要根据具体的业务需求和场景进行综合评估和选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值