TCC细读 - 1 例子流程

时间：2024-01-03 23:55:50

http://www.iocoder.cn/categories/TCC-Transaction/

https://github.com/changmingxie/tcc-transaction

细读tcc，理解事物实现的本质

顾名思义，TCC - Try(完成所有业务检查，预留必须业务资源) ，Confirm(真正执行业务，不做任何业务检查，只使用Try阶段预留的业务资源，Confirm操作满足幂等性)，Cancel(释放Try阶段预留的业务资源，cancel操作满足幂等性)

觉得应该先看下上面代码和文档中描述的那个买卖的例子：一个简单的购物系统，可以下单，可以选择用红包或余额支付等，从文章中摘出来一张图

TCC细读 - 1 例子流程

基本下单流程就是这样

整个下单的起点就是一个web controller

package org.mengyun.tcctransaction.sample.dubbo.order.web.controller;

import org.apache.commons.lang3.tuple.ImmutablePair;

import org.mengyun.tcctransaction.sample.dubbo.order.service.AccountServiceImpl;

import org.mengyun.tcctransaction.sample.order.domain.entity.Order;

import org.mengyun.tcctransaction.sample.order.domain.entity.Product;

import org.mengyun.tcctransaction.sample.order.domain.repository.ProductRepository;

import org.mengyun.tcctransaction.sample.order.domain.service.OrderServiceImpl;

import org.mengyun.tcctransaction.sample.dubbo.order.service.PlaceOrderServiceImpl;

import org.mengyun.tcctransaction.sample.dubbo.order.web.controller.vo.PlaceOrderRequest;

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

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.view.RedirectView;

import java.math.BigDecimal;

import java.security.InvalidParameterException;

import java.util.List;

/**

 * Created by changming.xie on 4/1/16.

 */

@Controller

@RequestMapping("")

public class OrderController {

    @Autowired

    PlaceOrderServiceImpl placeOrderService;

    @Autowired

    ProductRepository productRepository;

    @Autowired

    AccountServiceImpl accountService;

    @Autowired

    OrderServiceImpl orderService;

    @RequestMapping(value = "/", method = RequestMethod.GET)

    public ModelAndView index() {

        ModelAndView mv = new ModelAndView("/index");

        return mv;

    }

    @RequestMapping(value = "/user/{userId}/shop/{shopId}", method = RequestMethod.GET)

    public ModelAndView getProductsInShop(@PathVariable long userId,

                                          @PathVariable long shopId) {

        List<Product> products = productRepository.findByShopId(shopId);

        ModelAndView mv = new ModelAndView("/shop");

        mv.addObject("products", products);

        mv.addObject("userId", userId);

        mv.addObject("shopId", shopId);

        return mv;

    }

    @RequestMapping(value = "/user/{userId}/shop/{shopId}/product/{productId}/confirm", method = RequestMethod.GET)

    public ModelAndView productDetail(@PathVariable long userId,

                                      @PathVariable long shopId,

                                      @PathVariable long productId) {

        ModelAndView mv = new ModelAndView("product_detail");

        mv.addObject("capitalAmount", accountService.getCapitalAccountByUserId(userId));

        mv.addObject("redPacketAmount", accountService.getRedPacketAccountByUserId(userId));

        mv.addObject("product", productRepository.findById(productId));

        mv.addObject("userId", userId);

        mv.addObject("shopId", shopId);

        return mv;

    }

    @RequestMapping(value = "/placeorder", method = RequestMethod.POST)

    public RedirectView 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());

        return new RedirectView("/payresult/" + merchantOrderNo);

    }

    @RequestMapping(value = "/payresult/{merchantOrderNo}", method = RequestMethod.GET)

    public ModelAndView getPayResult(@PathVariable String merchantOrderNo) {

        ModelAndView mv = new ModelAndView("pay_success");

        String payResultTip = null;

        Order foundOrder = orderService.findOrderByMerchantOrderNo(merchantOrderNo);

        if ("CONFIRMED".equals(foundOrder.getStatus()))

            payResultTip = "支付成功";

        else if ("PAY_FAILED".equals(foundOrder.getStatus()))

            payResultTip = "支付失败";

        else

            payResultTip = "Unknown";

        mv.addObject("payResult", payResultTip);

        mv.addObject("capitalAmount", accountService.getCapitalAccountByUserId(foundOrder.getPayerUserId()));

        mv.addObject("redPacketAmount", accountService.getRedPacketAccountByUserId(foundOrder.getPayerUserId()));

        return mv;

    }

    private PlaceOrderRequest buildRequest(String redPacketPayAmount, long shopId, long payerUserId, long productId) {

        BigDecimal redPacketPayAmountInBigDecimal = new BigDecimal(redPacketPayAmount);

        if (redPacketPayAmountInBigDecimal.compareTo(BigDecimal.ZERO) < 0)

            throw new InvalidParameterException("invalid red packet amount :" + redPacketPayAmount);

        PlaceOrderRequest request = new PlaceOrderRequest();

        request.setPayerUserId(payerUserId);

        request.setShopId(shopId);

        request.setRedPacketPayAmount(new BigDecimal(redPacketPayAmount));

        request.getProductQuantities().add(new ImmutablePair<Long, Integer>(productId, 1));

        return request;

    }

}

下单

package org.mengyun.tcctransaction.sample.http.order.service;

import org.apache.commons.lang3.tuple.Pair;

import org.mengyun.tcctransaction.CancellingException;

import org.mengyun.tcctransaction.ConfirmingException;

import org.mengyun.tcctransaction.sample.order.domain.entity.Order;

import org.mengyun.tcctransaction.sample.order.domain.entity.Shop;

import org.mengyun.tcctransaction.sample.order.domain.repository.ShopRepository;

import org.mengyun.tcctransaction.sample.order.domain.service.OrderServiceImpl;

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

import org.springframework.stereotype.Service;

import java.math.BigDecimal;

import java.util.List;

/**

 * Created by changming.xie on 4/1/16.

 */

@Service

public class PlaceOrderServiceImpl {

    @Autowired

    ShopRepository shopRepository;

    @Autowired

    OrderServiceImpl orderService;

    @Autowired

    PaymentServiceImpl paymentService;

    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();

    }

}

支付服务，这里开始就用到了TCC

@Compensable(confirmMethod = "confirmMakePayment", cancelMethod = "cancelMakePayment", asyncConfirm = true)
package org.mengyun.tcctransaction.sample.dubbo.order.service;

import org.apache.commons.lang3.time.DateFormatUtils;

import org.mengyun.tcctransaction.api.Compensable;

import org.mengyun.tcctransaction.sample.dubbo.capital.api.CapitalTradeOrderService;

import org.mengyun.tcctransaction.sample.dubbo.capital.api.dto.CapitalTradeOrderDto;

import org.mengyun.tcctransaction.sample.dubbo.redpacket.api.RedPacketTradeOrderService;

import org.mengyun.tcctransaction.sample.dubbo.redpacket.api.dto.RedPacketTradeOrderDto;

import org.mengyun.tcctransaction.sample.order.domain.entity.Order;

import org.mengyun.tcctransaction.sample.order.domain.repository.OrderRepository;

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

import org.springframework.dao.OptimisticLockingFailureException;

import org.springframework.stereotype.Service;

import java.math.BigDecimal;

import java.util.Calendar;

/**

 * Created by changming.xie on 4/1/16.

 */

@Service

public class PaymentServiceImpl {

    @Autowired

    CapitalTradeOrderService capitalTradeOrderService;

    @Autowired

    RedPacketTradeOrderService redPacketTradeOrderService;

    @Autowired

    OrderRepository orderRepository;

    @Compensable(confirmMethod = "confirmMakePayment", cancelMethod = "cancelMakePayment", asyncConfirm = true)
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"));

        //check if the order status is DRAFT, if no, means that another call makePayment for the same order happened, ignore this call makePayment.

        if (order.getStatus().equals("DRAFT")) {

            order.pay(redPacketPayAmount, capitalPayAmount);

            try {

                orderRepository.updateOrder(order);

            } catch (OptimisticLockingFailureException e) {

                //ignore the concurrently update order exception, ensure idempotency.

            }

        }

        String result = capitalTradeOrderService.record(buildCapitalTradeOrderDto(order));

        String result2 = redPacketTradeOrderService.record(buildRedPacketTradeOrderDto(order));

    }

    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 foundOrder = orderRepository.findByMerchantOrderNo(order.getMerchantOrderNo());

        //check if the trade order status is PAYING, if no, means another call confirmMakePayment happened, return directly, ensure idempotency.

        if (foundOrder != null && foundOrder.getStatus().equals("PAYING")) {

            order.confirm();

            orderRepository.updateOrder(order);

        }

    }

    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 foundOrder = orderRepository.findByMerchantOrderNo(order.getMerchantOrderNo());

        //check if the trade order status is PAYING, if no, means another call cancelMakePayment happened, return directly, ensure idempotency.

        if (foundOrder != null && foundOrder.getStatus().equals("PAYING")) {

            order.cancelPayment();

            orderRepository.updateOrder(order);

        }

    }

    private CapitalTradeOrderDto buildCapitalTradeOrderDto(Order order) {

        CapitalTradeOrderDto tradeOrderDto = new CapitalTradeOrderDto();

        tradeOrderDto.setAmount(order.getCapitalPayAmount());

        tradeOrderDto.setMerchantOrderNo(order.getMerchantOrderNo());

        tradeOrderDto.setSelfUserId(order.getPayerUserId());

        tradeOrderDto.setOppositeUserId(order.getPayeeUserId());

        tradeOrderDto.setOrderTitle(String.format("order no:%s", order.getMerchantOrderNo()));

        return tradeOrderDto;

    }

    private RedPacketTradeOrderDto buildRedPacketTradeOrderDto(Order order) {

        RedPacketTradeOrderDto tradeOrderDto = new RedPacketTradeOrderDto();

        tradeOrderDto.setAmount(order.getRedPacketPayAmount());

        tradeOrderDto.setMerchantOrderNo(order.getMerchantOrderNo());

        tradeOrderDto.setSelfUserId(order.getPayerUserId());

        tradeOrderDto.setOppositeUserId(order.getPayeeUserId());

        tradeOrderDto.setOrderTitle(String.format("order no:%s", order.getMerchantOrderNo()));

        return tradeOrderDto;

    }

}

继续往下，这里加了一层代理并增加了传播属性的设置，还定义了事物编辑器

@Compensable(propagation = Propagation.SUPPORTS, confirmMethod = "record", cancelMethod = "record", transactionContextEditor = MethodTransactionContextEditor.class)
package org.mengyun.tcctransaction.sample.http.order.service;

import org.mengyun.tcctransaction.api.Compensable;

import org.mengyun.tcctransaction.api.Propagation;

import org.mengyun.tcctransaction.api.TransactionContext;

import org.mengyun.tcctransaction.context.MethodTransactionContextEditor;

import org.mengyun.tcctransaction.sample.http.capital.api.CapitalTradeOrderService;

import org.mengyun.tcctransaction.sample.http.capital.api.dto.CapitalTradeOrderDto;

import org.mengyun.tcctransaction.sample.http.redpacket.api.RedPacketTradeOrderService;

import org.mengyun.tcctransaction.sample.http.redpacket.api.dto.RedPacketTradeOrderDto;

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

import org.springframework.stereotype.Component;

/**

 * Created by changming.xie on 4/19/17.

 */

@Component

public class TradeOrderServiceProxy {

    @Autowired

    CapitalTradeOrderService capitalTradeOrderService;

    @Autowired

    RedPacketTradeOrderService redPacketTradeOrderService;

    /*the propagation need set Propagation.SUPPORTS,otherwise the recover doesn't work,

      The default value is Propagation.REQUIRED, which means will begin new transaction when recover.

    */

    @Compensable(propagation = Propagation.SUPPORTS, confirmMethod = "record", cancelMethod = "record", transactionContextEditor = MethodTransactionContextEditor.class)
public String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {

        return capitalTradeOrderService.record(transactionContext, tradeOrderDto);

    }

    @Compensable(propagation = Propagation.SUPPORTS, confirmMethod = "record", cancelMethod = "record", transactionContextEditor = MethodTransactionContextEditor.class)

    public String record(TransactionContext transactionContext, RedPacketTradeOrderDto tradeOrderDto) {

        return redPacketTradeOrderService.record(transactionContext, tradeOrderDto);

    }

}

继续

package org.mengyun.tcctransaction.sample.dubbo.capital.service;

import org.apache.commons.lang3.time.DateFormatUtils;

import org.mengyun.tcctransaction.api.Compensable;

import org.mengyun.tcctransaction.dubbo.context.DubboTransactionContextEditor;

import org.mengyun.tcctransaction.sample.capital.domain.entity.CapitalAccount;

import org.mengyun.tcctransaction.sample.capital.domain.entity.TradeOrder;

import org.mengyun.tcctransaction.sample.capital.domain.repository.CapitalAccountRepository;

import org.mengyun.tcctransaction.sample.capital.domain.repository.TradeOrderRepository;

import org.mengyun.tcctransaction.sample.dubbo.capital.api.CapitalTradeOrderService;

import org.mengyun.tcctransaction.sample.dubbo.capital.api.dto.CapitalTradeOrderDto;

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

import org.springframework.dao.DataIntegrityViolationException;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import java.util.Calendar;

/**

 * Created by changming.xie on 4/2/16.

 */

@Service("capitalTradeOrderService")

public class CapitalTradeOrderServiceImpl implements CapitalTradeOrderService {

    @Autowired

    CapitalAccountRepository capitalAccountRepository;

    @Autowired

    TradeOrderRepository tradeOrderRepository;

    @Override

    @Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord", transactionContextEditor = DubboTransactionContextEditor.class)

    @Transactional

    public String record(CapitalTradeOrderDto tradeOrderDto) {

        try {

            Thread.sleep(1000l);

        } 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 foundTradeOrder = tradeOrderRepository.findByMerchantOrderNo(tradeOrderDto.getMerchantOrderNo());

        //check if trade order has been recorded, if yes, return success directly.

        if (foundTradeOrder == null) {

            TradeOrder tradeOrder = new TradeOrder(

                    tradeOrderDto.getSelfUserId(),

                    tradeOrderDto.getOppositeUserId(),

                    tradeOrderDto.getMerchantOrderNo(),

                    tradeOrderDto.getAmount()

            );

            try {

                tradeOrderRepository.insert(tradeOrder);

                CapitalAccount transferFromAccount = capitalAccountRepository.findByUserId(tradeOrderDto.getSelfUserId());

                transferFromAccount.transferFrom(tradeOrderDto.getAmount());

                capitalAccountRepository.save(transferFromAccount);

            } catch (DataIntegrityViolationException e) {

                //this exception may happen when insert trade order concurrently, if happened, ignore this insert operation.

            }

        }

        return "success";

    }

    @Transactional

    public void confirmRecord(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());

        //check if the trade order status is DRAFT, if yes, return directly, ensure idempotency.

        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) {

        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());

        //check if the trade order status is DRAFT, if yes, return directly, ensure idempotency.

        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);

        }

    }

}

示例演示在下完订单后,使用红包帐户和资金帐户来付款，红包帐户服务和资金帐户服务在不同的系统中。示例中，有两个SOA提供方，一个是CapitalTradeOrderService，代表着资金帐户服务,另一个是RedPacketTradeOrderService,代表着红包帐户服务。

下完订单后，订单状态为DRAFT，在TCC事务中TRY阶段，订单支付服务将订单状态变成PAYING，同时远程调用红包帐户服务和资金帐户服务,将付款方的余额减掉（预留业务资源);如果在TRY阶段，任何一个服务失败，tcc-transaction将自动调用这些服务对应的cancel方法，订单支付服务将订单状态变成PAY_FAILED,同时远程调用红包帐户服务和资金帐户服务,将付款方余额减掉的部分增加回去；如果TRY阶段正常完成，则进入CONFIRM阶段，在CONFIRM阶段（tcc-transaction自动调用）,订单支付服务将订单状态变成CONFIRMED,同时远程调用红包帐户服务和资金帐户服务对应的CONFIRM方法，将收款方的余额增加。

相关文章