SpringCloudAlibaba Seata分布式事务TCC模式解决方案

CREATE TABLE IF NOT EXISTS `tcc_fence_log` (
  `xid` VARCHAR(128) NOT NULL COMMENT '全局事务id',
  `branch_id` BIGINT NOT NULL COMMENT '分支事务id',
  `action_name` VARCHAR(64) NOT NULL COMMENT 'TCC 动作名称',
  `status` TINYINT NOT NULL COMMENT '事务状态: 1-tried, 2-committed, 3-rollbacked, 4-suspended（悬挂）',
  `gmt_create` DATETIME(3) NOT NULL COMMENT '创建时间',
  `gmt_modified` DATETIME(3) NOT NULL COMMENT '修改时间',
  PRIMARY KEY (`xid`, `branch_id`),
  KEY `idx_gmt_modified` (`gmt_modified`),
  KEY `idx_status` (`status`)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

@TwoPhaseBusinessAction(
    name = "reduceBalance", 
    commitMethod = "confirm", 
    rollbackMethod = "cancel",
    useTCCFence = true  // 开启防护机制
)
@Transactional
public boolean try(BusinessActionContext context, String userId, int money) {
    // 1. 扣减可用余额
    accountMapper.deductAvailable(userId, money);
    // 2. 插入冻结记录（或直接在可用余额表中增加冻结字段）
    // 这里注意：useTCCFence 会自动记录状态，你不需要自己维护冻结表
    return true;
}

CREATE TABLE `account_freeze_tbl` (
  `xid` varchar(128) NOT NULL,
  `user_id` varchar(255) DEFAULT NULL COMMENT '用户id',
  `freeze_money` int(11) unsigned DEFAULT '0' COMMENT '冻结金额',
  `state` int(1) DEFAULT NULL COMMENT '事务状态，0:try，1:confirm，2:cancel',
  PRIMARY KEY (`xid`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT;

@Transactional
public boolean confirm(BusinessActionContext context) {
    // 不需要再操作余额（Try 阶段已经扣了）
    // 只需要清理冻结记录（如果有的话）
    // 或者什么都不做（空确认）
    log.info("Confirm 成功，xid={}", context.getXid());
    return true;
}

@Transactional
public boolean cancel(BusinessActionContext context) {
    // 从上下文获取 Try 阶段的参数
    String userId = (String) context.getActionContext("userId");
    Integer money = (Integer) context.getActionContext("money");
    // 恢复可用余额
    accountMapper.increaseAvailable(userId, money);
    // 清理冻结记录（如果有）
    return true;
}

CREATE TABLE `account` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `user_id` varchar(64) NOT NULL COMMENT '用户ID',
  `available_amount` decimal(10,2) NOT NULL DEFAULT '0.00' COMMENT '可用余额',
  `frozen_amount` decimal(10,2) NOT NULL DEFAULT '0.00' COMMENT '冻结金额',
  `version` int(11) NOT NULL DEFAULT '0' COMMENT '乐观锁版本号',
  PRIMARY KEY (`id`),
  UNIQUE KEY `uk_user_id` (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

// try阶段
@Transactional
public boolean try(String userId, int money) {
    // 1. 先查当前版本号
    Account account = accountMapper.selectByUserId(userId);
    if (account.getAvailableAmount() < money) {
        throw new RuntimeException("余额不足");
    }
    // 2. 乐观锁更新
    int affected = accountMapper.update(
        "UPDATE account SET " +
        "  available_amount = available_amount - #{money}, " +
        "  frozen_amount = frozen_amount + #{money}, " +
        "  version = version + 1 " +
        "WHERE user_id = #{userId} " +
        "  AND available_amount >= #{money} " +
        "  AND version = #{version}"
    );
    // 3. 冲突处理
    if (affected == 0) {
        throw new RuntimeException("并发冲突，请重试");
    }
    // tcc_fence_log 插入由 Seata 框架自动完成（useTCCFence=true）
    return true;
}
// Confirm 阶段
@Transactional
public boolean confirm(BusinessActionContext ctx) {
    String xid = ctx.getXid();
    String userId = (String) ctx.getActionContext("userId");
    Integer money = (Integer) ctx.getActionContext("money");
    // 1. 先查当前版本号和冻结金额
    Account account = accountMapper.selectByUserId(userId);
    // 2. 幂等：如果冻结金额已经是 0，说明 Confirm 已完成
    if (account.getFrozenAmount() == 0) {
        log.info("Confirm 幂等：冻结金额已为0，xid={}", xid);
        return true;
    }
    // 3. 乐观锁更新：只清冻结金额
    int affected = accountMapper.update(
        "UPDATE account SET " +
        "  frozen_amount = frozen_amount - #{money}, " +
        "  version = version + 1 " +
        "WHERE user_id = #{userId} " +
        "  AND frozen_amount >= #{money} " +
        "  AND version = #{version}"
    );
    if (affected == 0) {
        log.warn("Confirm 被乐观锁拦截，xid={}", xid);
        // 重试或返回 true（让框架重试）
        return false;
    }
    return true;
}
// cancel阶段
@Transactional
public boolean cancel(BusinessActionContext ctx) {
    String xid = ctx.getXid();
    String userId = (String) ctx.getActionContext("userId");
    Integer money = (Integer) ctx.getActionContext("money");
    // 1. 先查当前版本号和冻结金额
    Account account = accountMapper.selectByUserId(userId);
    // 2. 幂等：如果冻结金额已经是 0，说明 Cancel 已完成或已 Confirm
    if (account.getFrozenAmount() == 0) {
        log.info("Cancel 幂等：冻结金额已为0，xid={}", xid);
        return true;
    }
    // 3. 乐观锁更新：恢复可用余额，清冻结金额
    int affected = accountMapper.update(
        "UPDATE account SET " +
        "  available_amount = available_amount + #{money}, " +
        "  frozen_amount = frozen_amount - #{money}, " +
        "  version = version + 1 " +
        "WHERE user_id = #{userId} " +
        "  AND frozen_amount >= #{money} " +
        "  AND version = #{version}"
    );
    if (affected == 0) {
        log.warn("Cancel 被乐观锁拦截，xid={}", xid);
        return false;  // 让框架重试
    }
    log.info("Cancel 成功：xid={}, userId={}, 恢复金额={}", xid, userId, money);
    return true;
}

package cn.itcast.account.service;
import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
@LocalTCC
public interface AccountTCCService {
    @TwoPhaseBusinessAction(name = "deduct", commitMethod = "confirm", rollbackMethod = "cancel")
    void deduct(@BusinessActionContextParameter(paramName = "userId") String userId,
                @BusinessActionContextParameter(paramName = "money")int money);
    boolean confirm(BusinessActionContext ctx);
    boolean cancel(BusinessActionContext ctx);
}

package cn.itcast.account.service.impl;
import cn.itcast.account.entity.AccountFreeze;
import cn.itcast.account.mapper.AccountFreezeMapper;
import cn.itcast.account.mapper.AccountMapper;
import cn.itcast.account.service.AccountTCCService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@Slf4j
public class AccountTCCServiceImpl implements AccountTCCService {
    @Autowired
    private AccountMapper accountMapper;
    @Autowired
    private AccountFreezeMapper freezeMapper;
    @Override
    @Transactional
    public void deduct(String userId, int money) {
        // 0.获取事务id
        String xid = RootContext.getXID();
        // 1.扣减可用余额
        accountMapper.deduct(userId, money);
        // 2.记录冻结金额，事务状态
        AccountFreeze freeze = new AccountFreeze();
        freeze.setUserId(userId);
        freeze.setFreezeMoney(money);
        freeze.setState(AccountFreeze.State.TRY);
        freeze.setXid(xid);
        freezeMapper.insert(freeze);
    }
    @Override
    public boolean confirm(BusinessActionContext ctx) {
        // 1.获取事务id
        String xid = ctx.getXid();
        // 2.根据id删除冻结记录
        int count = freezeMapper.deleteById(xid);
        return count == 1;
    }
    @Override
    public boolean cancel(BusinessActionContext ctx) {
        // 0.查询冻结记录
        String xid = ctx.getXid();
        AccountFreeze freeze = freezeMapper.selectById(xid);
        // 1.恢复可用余额
        accountMapper.refund(freeze.getUserId(), freeze.getFreezeMoney());
        // 2.将冻结金额清零，状态改为CANCEL
        freeze.setFreezeMoney(0);
        freeze.setState(AccountFreeze.State.CANCEL);
        int count = freezeMapper.updateById(freeze);
        return count == 1;
    }
}

package com.bjpowernode.service;
public interface OrderService {
    /**
     * 下订单
     *
     * @param userId 用户id
     * @param productId 产品id
     * @return 订单id
     * @throws Exception 创建订单失败，抛出异常
     */
    Integer createOrder(Integer userId, Integer productId) throws Exception;
}
package com.bjpowernode.service;
import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
import java.math.BigDecimal;
@LocalTCC
public interface AccountService {
    /**
     * 扣除余额
     * 定义两阶段提交
     * name = reduceStock为一阶段try方法
     * commitMethod = commitTcc 为二阶段确认方法
     * rollbackMethod = cancel 为二阶段取消方法
     * BusinessActionContextParameter注解 可传递参数到二阶段方法
     *
     * @param userId 用户ID
     * @param money  扣减金额
     * @throws Exception 失败时抛出异常
     */
    @TwoPhaseBusinessAction(name = "reduceBalance", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    void reduceBalance(@BusinessActionContextParameter(paramName = "userId") Integer userId,
                       @BusinessActionContextParameter(paramName = "money") BigDecimal money);
    /**
     * 确认方法、可以另命名，但要保证与commitMethod一致
     * context可以传递try方法的参数
     *
     * @param context 上下文
     * @return boolean
     */
    boolean commitTcc(BusinessActionContext context);
    /**
     * 二阶段取消方法
     *
     * @param context 上下文
     * @return boolean
     */
    boolean cancelTcc(BusinessActionContext context);
}
package com.bjpowernode.service;
import com.bjpowernode.model.Product;
import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import io.seata.rm.tcc.api.LocalTCC;
import io.seata.rm.tcc.api.TwoPhaseBusinessAction;
@LocalTCC
public interface ProductService {
    /**
     * 减库存
     *
     * 定义两阶段提交
     * name = reduceStock为一阶段try方法
     * commitMethod = commitTcc 为二阶段确认方法
     * rollbackMethod = cancel 为二阶段取消方法
     * BusinessActionContextParameter注解 可传递参数到二阶段方法
     *
     * @param productId 商品ID
     * @param amount    扣减数量
     * @throws Exception 扣减失败时抛出异常
     */
    @TwoPhaseBusinessAction(name = "reduceStock", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    Product reduceStock(@BusinessActionContextParameter(paramName = "productId") Integer productId,
                        @BusinessActionContextParameter(paramName = "amount") Integer amount);
    /**
     * 二阶段提交方法
     *
     * 确认方法、可以另命名，但要保证与commitMethod一致
     * context可以传递try方法的参数
     *
     * @param context 上下文
     * @return boolean
     */
    boolean commitTcc(BusinessActionContext context);
    /**
     * 二阶段回滚方法
     *
     * @param context 上下文
     * @return boolean
     */
    boolean cancelTcc(BusinessActionContext context);
}

package com.bjpowernode.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.bjpowernode.mapper.OrdersMapper;
import com.bjpowernode.model.Orders;
import com.bjpowernode.model.Product;
import com.bjpowernode.service.AccountService;
import com.bjpowernode.service.OrderService;
import com.bjpowernode.service.ProductService;
import io.seata.core.context.RootContext;
import io.seata.spring.annotation.GlobalTransactional;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Slf4j
@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    private OrdersMapper ordersMapper;
    @Autowired
    private AccountService accountService;
    @Autowired
    private ProductService productService;
    @Override
    @DS(value = "order-ds")
    @GlobalTransactional //seata全局事务注解， TM 事务发起方
    public Integer createOrder(Integer userId, Integer productId) throws Exception {
        Integer amount = 1; // 购买数量暂时设置为 1
        log.info("当前 XID: {}", RootContext.getXID());
        // 减库存
        Product product = productService.reduceStock(productId, amount);
        // 减余额
        accountService.reduceBalance(userId, product.getPrice());
        // 下订单
        Orders order = new Orders();
        order.setUserId(userId);
        order.setProductId(productId);
        order.setPayAmount(product.getPrice().multiply(new BigDecimal(amount)));
        ordersMapper.insertSelective(order);
        log.info("下订单: {}", order.getId());
        int a = 10 / 0;
        // 返回订单编号
        return order.getId();
    }
}
package com.bjpowernode.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.bjpowernode.mapper.ProductMapper;
import com.bjpowernode.model.Product;
import com.bjpowernode.service.AccountService;
import com.bjpowernode.service.ProductService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class ProductServiceImpl implements ProductService {
    @Autowired
    private AccountService accountService;
    @Autowired
    private ProductMapper productMapper;
    @DS(value = "product-ds")
    @Override
    public Product reduceStock(Integer productId, Integer amount) {
        log.info("当前 XID: {}", RootContext.getXID());
        // 检查库存
        Product product = productMapper.selectByPrimaryKey(productId);
        if (product.getStock() < amount) {
            throw new RuntimeException("库存不足");
        }
        // 扣减库存
        int updateCount = productMapper.reduceStock(productId, amount);
        // 扣除成功
        if (updateCount == 0) {
            throw new RuntimeException("库存不足");
        }
        // 扣除成功
        log.info("扣除 {} 库存成功", productId);
        return product;
    }
    /**
     * tcc服务（confirm）方法
     * 可以空确认
     *
     * @param context 上下文
     * @return boolean
     */
    @DS(value = "product-ds")
    @Override
    public boolean commitTcc(BusinessActionContext context) {
        log.info("Confirm阶段，ProductServiceImpl, commitTcc --> xid = " + context.getXid() + ", commitTcc提交成功");
        return true;
    }
    /**
     * tcc服务（cancel）方法
     *
     * @param context 上下文
     * @return boolean
     */
    @DS(value = "product-ds")
    @Override
    public boolean cancelTcc(BusinessActionContext context) {
        log.info("Cancel阶段，ProductServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
        //TODO 这里可以实现中间件、非关系型数据库的回滚操作
        log.info("Cancel阶段，ProductServiceImpl, cancelTcc this data: {}, {}", context.getActionContext("productId"), context.getActionContext("amount"));
        //进行数据库回滚处理
        Integer productId = (Integer)context.getActionContext("productId");
        Integer amount = (Integer)context.getActionContext("amount");
        //把库存再加回去 (避免数据出问题，加个锁，分布式环境下就需要分布式锁)
        productMapper.increaseStock(productId, amount);
        return true;
    }
}
package com.bjpowernode.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.bjpowernode.mapper.AccountMapper;
import com.bjpowernode.model.Account;
import com.bjpowernode.service.AccountService;
import io.seata.core.context.RootContext;
import io.seata.rm.tcc.api.BusinessActionContext;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Slf4j
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountMapper accountMapper;
    @DS(value = "account-ds")
    @Override
    public void reduceBalance(Integer userId, BigDecimal money) {
        log.info("当前 XID: {}", RootContext.getXID());
        // 检查余额
        Account account = accountMapper.selectAccountByUserId(userId);
        if (account.getBalance().doubleValue() < money.doubleValue()) {
            throw new RuntimeException("余额不足");
        }
        // 扣除余额
        int updateCount = accountMapper.reduceBalance(userId, money);
        // 扣除成功
        if (updateCount == 0) {
            throw new RuntimeException("余额不足");
        }
        log.info("扣除用户 {} 余额成功", userId);
        //int a = 10 / 0;
    }
    /**
     * tcc服务（confirm）方法
     * 可以空确认
     *
     * @param context 上下文
     * @return boolean
     */
    @DS(value = "account-ds")
    @Override
    public boolean commitTcc(BusinessActionContext context) {
        log.info("Confirm阶段，AccountServiceImpl, commitTcc --> xid = {}", context.getXid() + ", commitTcc提交成功");
        return true;
    }
    /**
     * tcc服务（cancel）方法
     *
     * @param context 上下文
     * @return boolean
     */
    @DS(value = "account-ds")
    @Override
    public boolean cancelTcc(BusinessActionContext context) {
        log.info("Cancel阶段，AccountServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
        //TODO 这里可以实现中间件、非关系型数据库的回滚操作
        log.info("Cancel阶段，AccountServiceImpl, cancelTcc this data: userId= {}, money = {}", context.getActionContext("userId"), context.getActionContext("money"));
        //进行数据库回滚处理
        Integer userId = (Integer)context.getActionContext("userId");
        BigDecimal money = (BigDecimal)context.getActionContext("money");
        //把余额再加回去
        accountMapper.increaseBalance(userId, money);
        return true;
    }
}