:::tips 这里通过一个案例来进行实现TCC模式 :::

创建数据表

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

:::tips

  • xid：是全局事务id
  • freeze_money：用来记录用户冻结金额
  • state：用来记录事务状态

业务流程

  • Try业务：
    • 记录冻结金额和事务状态到account_freeze表
    • 扣减account表可用金额
  • Confirm业务
    • 根据xid删除account_freeze表的冻结记录
  • Cancel业务
    • 修改account_freeze表，冻结金额为0，state为2
    • 修改account表，恢复可用金额
  • 判断是否空回滚
    • cancel业务中，根据xid查询account_freeze，如果为null则说明try还没做，需要空回滚

  • 避免业务悬挂

    • try业务中，根据xid查询account_freeze ，如果已经存在则证明Cancel已经执行，拒绝执行try业务 :::

      声明TCC接口

      :::tips TCC模式的Try、Confirm、Cancel方法都需要在接口中基于注解来声明，在微服务工程中的service包中新建一个接口，用来声明TCC模式的三个接口 :::

      1. /**
      2. * @version 1.0
      3. * @description 说明
      4. * @package cn.itcast.account.service
      5. */
      6. @LocalTCC
      7. public interface AccountTCCService {
      9. /**
      10. * 用户账户扣款
      11. * 1 扣减account表可用金额
      12. * 2 记录冻结金额和事务状态到account_freeze表
      13. * @param userId
      14. * @param money
      15. *
      16. */
      17. @TwoPhaseBusinessAction(name = "deduct",
      18.    commitMethod = "confirm",rollbackMethod = "cancel")
      19. void deduct(@BusinessActionContextParameter(paramName = "userId") String userId,
      20.            @BusinessActionContextParameter(paramName = "money") int money);
      22. /**
      23. * 确认业务，根据xid删除account_freeze表的冻结记录
      24. * @param ctx
      25. * @return
      26. */
      27. boolean confirm(BusinessActionContext ctx);
      29. /**
      30. * 撤消回滚，需要把冻结金额还原
      31. * 1 修改account_freeze表，冻结金额为0，state为2
      32. * 2 修改account表，恢复可用金额
      33. * @param ctx
      34. * @return
      35. */
      36. boolean cancel(BusinessActionContext ctx);
      37. }

      实现接口

      :::tips 在impl包中新建一个类，实现刚刚编写的接口 :::

      1. /**
      2. * @version 1.0
      3. * @description 说明
      4. * @package cn.itcast.account.service.impl
      5. */
      6. @Service
      7. @Slf4j
      8. public class AccountTCCServiceImpl implements AccountTCCService {
      10. @Autowired
      11. private AccountMapper accountMapper;
      13. @Autowired
      14. private AccountFreezeMapper accountFreezeMapper;
      16. /**
      17. * 用户账户扣款
      18. * 1 扣减account表可用金额
      19. * 2 记录冻结金额和事务状态到account_freeze表
      20. * @param userId
      21. * @param money
      22. *
      23. */
      24. @Override
      25. @Transactional
      26. public void deduct(String userId, int money) {
      27.    String xid = RootContext.getXID();
      28.    //1. 扣减金额
      29.    accountMapper.deduct(userId,money);
      30.    log.debug("扣减金额成功: {},userId={}", xid, userId);
      31.    //2. 添加冻结记录
      32.    AccountFreeze freeze = new AccountFreeze();
      33.    freeze.setFreezeMoney(money);
      34.    freeze.setState(AccountFreeze.State.TRY);
      35.    freeze.setXid(xid);
      36.    freeze.setUserId(userId);
      37.    accountFreezeMapper.insert(freeze);
      38.    log.debug("冻结金额成功! {},userId={}", xid, userId);
      39.    //3. 添加本地事务控制
      40. }
      42. /**
      43. * 确认业务，根据xid删除account_freeze表的冻结记录
      44. * @param ctx
      45. * @return
      46. */
      47. @Override
      48. public boolean confirm(BusinessActionContext ctx) {
      49.    //1. 获取事务Id
      50.    String xid = ctx.getXid();
      51.    log.debug("进入confirm: {}", xid);
      52.    //2. 通过事务Id删除数据
      53.    int count = accountFreezeMapper.deleteById(xid);
      54.    log.debug("删除冻结记录 {},count={}",xid,count);
      55.    return 1==count;
      56. }
      58. /**
      59. * 撤消回滚，需要把冻结金额还原
      60. * 1 修改account_freeze表，冻结金额为0，state为2
      61. * 2 修改account表，恢复可用金额
      62. * @param ctx
      63. * @return
      64. */
      65. @Override
      66. @Transactional
      67. public boolean cancel(BusinessActionContext ctx) {
      68.    //1. 获取事务Id
      69.    String xid = ctx.getXid();
      70.    //2. 查询冻结记录
      71.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      72.    //3. 回滚金额
      73.    String userId = ctx.getActionContext("userId").toString();
      74.    log.debug("开始回滚金额: {},userId={}", xid, userId);
      75.    accountMapper.refund(userId, freeze.getFreezeMoney());
      76.    //4. 更新冻结金额为0，且更新状态为cancel
      77.    freeze = new AccountFreeze();
      78.    freeze.setFreezeMoney(0);
      79.    freeze.setState(AccountFreeze.State.CANCEL);
      80.    freeze.setXid(xid);
      81.    int count = accountFreezeMapper.updateById(freeze);
      82.    log.debug("回滚-更新冻结状态：{}, userId={},count={}", xid, userId,count);
      83.    //5. 本地事务控制
      84.    return count==1;
      85. }
      86. }

      解决空回滚

      :::tips 在Cancel方法中，根据xid查询account_freeze，如果为null则说明Try还没做，需要空回滚 :::

      1. /**
      2. * @version 1.0
      3. * @description 说明
      4. * @package cn.itcast.account.service.impl
      5. */
      6. @Service
      7. @Slf4j
      8. public class AccountTCCServiceImpl implements AccountTCCService {
      10. @Autowired
      11. private AccountMapper accountMapper;
      13. @Autowired
      14. private AccountFreezeMapper accountFreezeMapper;
      16. /**
      17. * 用户账户扣款
      18. * 1 扣减account表可用金额
      19. * 2 记录冻结金额和事务状态到account_freeze表
      20. * @param userId
      21. * @param money
      22. *
      23. */
      24. @Override
      25. @Transactional
      26. public void deduct(String userId, int money) {
      27.    String xid = RootContext.getXID();
      28.    //1. 扣减金额
      29.    accountMapper.deduct(userId,money);
      30.    log.debug("扣减金额成功: {},userId={}", xid, userId);
      31.    //2. 添加冻结记录
      32.    AccountFreeze freeze = new AccountFreeze();
      33.    freeze.setFreezeMoney(money);
      34.    freeze.setState(AccountFreeze.State.TRY);
      35.    freeze.setXid(xid);
      36.    freeze.setUserId(userId);
      37.    accountFreezeMapper.insert(freeze);
      38.    log.debug("冻结金额成功! {},userId={}", xid, userId);
      39.    //3. 添加本地事务控制
      40. }
      42. /**
      43. * 确认业务，根据xid删除account_freeze表的冻结记录
      44. * @param ctx
      45. * @return
      46. */
      47. @Override
      48. public boolean confirm(BusinessActionContext ctx) {
      49.    //1. 获取事务Id
      50.    String xid = ctx.getXid();
      51.    log.debug("进入confirm: {}", xid);
      52.    //2. 通过事务Id删除数据
      53.    int count = accountFreezeMapper.deleteById(xid);
      54.    log.debug("删除冻结记录 {},count={}",xid,count);
      55.    return 1==count;
      56. }
      58. /**
      59. * 撤消回滚，需要把冻结金额还原
      60. * 1 修改account_freeze表，冻结金额为0，state为2
      61. * 2 修改account表，恢复可用金额
      62. * @param ctx
      63. * @return
      64. */
      65. @Override
      66. @Transactional
      67. public boolean cancel(BusinessActionContext ctx) {
      68.    //1. 获取事务Id
      69.    String xid = ctx.getXid();
      70.    //2. 查询冻结记录
      71.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      73.    //判断是否空回滚
      74.    if(freeze == null){
      75.        freeze = new AccountFreeze();
      76.        freeze.setFreezeMoney(0);
      77.        freeze.setState(AccountFreeze.State.CANCEL);
      78.        freeze.setXid(xid);
      79.        freeze.setUserId(userId);
      80.        accountFreeMapper.insert(freeze);
      81.        return true;
      82.    }
      84.    //3. 回滚金额
      85.    String userId = ctx.getActionContext("userId").toString();
      86.    log.debug("开始回滚金额: {},userId={}", xid, userId);
      87.    accountMapper.refund(userId, freeze.getFreezeMoney());
      88.    //4. 更新冻结金额为0，且更新状态为cancel
      89.    freeze = new AccountFreeze();
      90.    freeze.setFreezeMoney(0);
      91.    freeze.setState(AccountFreeze.State.CANCEL);
      92.    freeze.setXid(xid);
      93.    int count = accountFreezeMapper.updateById(freeze);
      94.    log.debug("回滚-更新冻结状态：{}, userId={},count={}", xid, userId,count);
      95.    //5. 本地事务控制
      96.    return count==1;
      97. }
      98. }

      解决业务悬挂

      :::tips 在Try方法中，根据xid查询account_freeze ，如果已经存在则证明Cancel已经执行，拒绝执行Try业务 :::

      1. /**
      2. * @version 1.0
      3. * @description 说明
      4. * @package cn.itcast.account.service.impl
      5. */
      6. @Service
      7. @Slf4j
      8. public class AccountTCCServiceImpl implements AccountTCCService {
      10. @Autowired
      11. private AccountMapper accountMapper;
      13. @Autowired
      14. private AccountFreezeMapper accountFreezeMapper;
      16. /**
      17. * 用户账户扣款
      18. * 1 扣减account表可用金额
      19. * 2 记录冻结金额和事务状态到account_freeze表
      20. * @param userId
      21. * @param money
      22. *
      23. */
      24. @Override
      25. @Transactional
      26. public void deduct(String userId, int money) {
      27.    String xid = RootContext.getXID();
      29.    //判断Cancel是否执行过，避免业务悬挂
      30.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      31.    if(freeze != null){
      32.        //Cancel已经执行过，拒绝业务
      33.        return;
      34.    }
      36.    //1. 扣减金额
      37.    accountMapper.deduct(userId,money);
      38.    log.debug("扣减金额成功: {},userId={}", xid, userId);
      39.    //2. 添加冻结记录
      40.    AccountFreeze freeze = new AccountFreeze();
      41.    freeze.setFreezeMoney(money);
      42.    freeze.setState(AccountFreeze.State.TRY);
      43.    freeze.setXid(xid);
      44.    freeze.setUserId(userId);
      45.    accountFreezeMapper.insert(freeze);
      46.    log.debug("冻结金额成功! {},userId={}", xid, userId);
      47.    //3. 添加本地事务控制
      48. }
      50. /**
      51. * 确认业务，根据xid删除account_freeze表的冻结记录
      52. * @param ctx
      53. * @return
      54. */
      55. @Override
      56. public boolean confirm(BusinessActionContext ctx) {
      57.    //1. 获取事务Id
      58.    String xid = ctx.getXid();
      59.    log.debug("进入confirm: {}", xid);
      60.    //2. 通过事务Id删除数据
      61.    int count = accountFreezeMapper.deleteById(xid);
      62.    log.debug("删除冻结记录 {},count={}",xid,count);
      63.    return 1==count;
      64. }
      66. /**
      67. * 撤消回滚，需要把冻结金额还原
      68. * 1 修改account_freeze表，冻结金额为0，state为2
      69. * 2 修改account表，恢复可用金额
      70. * @param ctx
      71. * @return
      72. */
      73. @Override
      74. @Transactional
      75. public boolean cancel(BusinessActionContext ctx) {
      76.    //1. 获取事务Id
      77.    String xid = ctx.getXid();
      78.    //2. 查询冻结记录
      79.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      81.    //判断是否空回滚
      82.    if(freeze == null){
      83.        freeze = new AccountFreeze();
      84.        freeze.setFreezeMoney(0);
      85.        freeze.setState(AccountFreeze.State.CANCEL);
      86.        freeze.setXid(xid);
      87.        freeze.setUserId(userId);
      88.        accountFreeMapper.insert(freeze);
      89.        return true;
      90.    }
      92.    //3. 回滚金额
      93.    String userId = ctx.getActionContext("userId").toString();
      94.    log.debug("开始回滚金额: {},userId={}", xid, userId);
      95.    accountMapper.refund(userId, freeze.getFreezeMoney());
      96.    //4. 更新冻结金额为0，且更新状态为cancel
      97.    freeze = new AccountFreeze();
      98.    freeze.setFreezeMoney(0);
      99.    freeze.setState(AccountFreeze.State.CANCEL);
      100.    freeze.setXid(xid);
      101.    int count = accountFreezeMapper.updateById(freeze);
      102.    log.debug("回滚-更新冻结状态：{}, userId={},count={}", xid, userId,count);
      103.    //5. 本地事务控制
      104.    return count==1;
      105. }
      106. }

      幂等处理

      :::tips 如果冻结记录，则先判断一下这条冻结记录的状态，如果状态为2（Cancel），说明已经执行过了，不能再重复执行业务 :::

      1. /**
      2. * @version 1.0
      3. * @description 说明
      4. * @package cn.itcast.account.service.impl
      5. */
      6. @Service
      7. @Slf4j
      8. public class AccountTCCServiceImpl implements AccountTCCService {
      10. @Autowired
      11. private AccountMapper accountMapper;
      13. @Autowired
      14. private AccountFreezeMapper accountFreezeMapper;
      16. /**
      17. * 用户账户扣款
      18. * 1 扣减account表可用金额
      19. * 2 记录冻结金额和事务状态到account_freeze表
      20. * @param userId
      21. * @param money
      22. *
      23. */
      24. @Override
      25. @Transactional
      26. public void deduct(String userId, int money) {
      27.    String xid = RootContext.getXID();
      29.    //判断Cancel是否执行过，避免业务悬挂
      30.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      31.    if(freeze != null){
      32.        //Cancel已经执行过，拒绝业务
      33.        return;
      34.    }
      36.    //1. 扣减金额
      37.    accountMapper.deduct(userId,money);
      38.    log.debug("扣减金额成功: {},userId={}", xid, userId);
      39.    //2. 添加冻结记录
      40.    AccountFreeze freeze = new AccountFreeze();
      41.    freeze.setFreezeMoney(money);
      42.    freeze.setState(AccountFreeze.State.TRY);
      43.    freeze.setXid(xid);
      44.    freeze.setUserId(userId);
      45.    accountFreezeMapper.insert(freeze);
      46.    log.debug("冻结金额成功! {},userId={}", xid, userId);
      47.    //3. 添加本地事务控制
      48. }
      50. /**
      51. * 确认业务，根据xid删除account_freeze表的冻结记录
      52. * @param ctx
      53. * @return
      54. */
      55. @Override
      56. public boolean confirm(BusinessActionContext ctx) {
      57.    //1. 获取事务Id
      58.    String xid = ctx.getXid();
      59.    log.debug("进入confirm: {}", xid);
      60.    //2. 通过事务Id删除数据
      61.    int count = accountFreezeMapper.deleteById(xid);
      62.    log.debug("删除冻结记录 {},count={}",xid,count);
      63.    return 1==count;
      64. }
      66. /**
      67. * 撤消回滚，需要把冻结金额还原
      68. * 1 修改account_freeze表，冻结金额为0，state为2
      69. * 2 修改account表，恢复可用金额
      70. * @param ctx
      71. * @return
      72. */
      73. @Override
      74. @Transactional
      75. public boolean cancel(BusinessActionContext ctx) {
      76.    //1. 获取事务Id
      77.    String xid = ctx.getXid();
      78.    //2. 查询冻结记录
      79.    AccountFreeze freeze = accountFreezeMapper.selectById(xid);
      81.    //判断是否空回滚
      82.    if(freeze == null){
      83.        freeze = new AccountFreeze();
      84.        freeze.setFreezeMoney(0);
      85.        freeze.setState(AccountFreeze.State.CANCEL);
      86.        freeze.setXid(xid);
      87.        freeze.setUserId(userId);
      88.        accountFreeMapper.insert(freeze);
      89.        return true;
      90.    }
      92.    //幂等处理
      93.    if(AccountFreeze.State.CANCEL == freeze.getState().intValue()){
      94.        //状态为Cancel，说明已经执行过Cancel，不能再重复处理
      95.        return true;
      96.    }
      98.    //3. 回滚金额
      99.    String userId = ctx.getActionContext("userId").toString();
      100.    log.debug("开始回滚金额: {},userId={}", xid, userId);
      101.    accountMapper.refund(userId, freeze.getFreezeMoney());
      102.    //4. 更新冻结金额为0，且更新状态为cancel
      103.    freeze = new AccountFreeze();
      104.    freeze.setFreezeMoney(0);
      105.    freeze.setState(AccountFreeze.State.CANCEL);
      106.    freeze.setXid(xid);
      107.    int count = accountFreezeMapper.updateById(freeze);
      108.    log.debug("回滚-更新冻结状态：{}, userId={},count={}", xid, userId,count);
      109.    //5. 本地事务控制
      110.    return count==1;
      111. }
      112. }