一文搞懂 Seata 分布式事务 TCC 模式及解决空回滚、幂等、悬挂问题

最新推荐文章于 2024-07-04 00:48:22 发布
最新推荐文章于 2024-07-04 00:48:22 发布
阅读量748 收藏
点赞数
分类专栏： SpringCloudAlibaba 文章标签： 分布式

转载：https://mp.weixin.qq.com/s?__biz=Mzg3Mjk3OTA4OA==&mid=2247484545&idx=1&sn=9fe01ef81d68f1f3b8912e44b0a588b8&chksm=cee64b7ef991c2689d11a3f33ab07e4f50cd388ab487b05659995e2dcbcac4742292a79be6ee&cur_album_id=2973104649560178694&scene=189#wechat_redirect

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
* @author qingzhou
*
* 通过 @LocalTCC 这个注解，RM 初始化的时候会向 TC 注册一个分支事务。
*/
@LocalTCC
public interface OrderService {

    @TwoPhaseBusinessAction(name = "prepareSaveOrder", commitMethod = "commit", rollbackMethod = "rollback", useTCCFence = true)
    Order prepareSaveOrder(OrderVo orderVo, @BusinessActionContextParameter(paramName = "orderId") Long orderId);

    boolean commit(BusinessActionContext actionContext);

    boolean rollback(BusinessActionContext actionContext);
}

在这里插入图片描述

仓库地址：https://github.com/seata/seata/blob/v1.5.1/script/server/db/mysql.sql

CREATE TABLE IF NOT EXISTS `distributed_lock`
(
  `lock_key`       CHAR(20) NOT NULL,
  `lock_value`     VARCHAR(20) NOT NULL,
  `expire`         BIGINT,
  primary key (`lock_key`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8mb4;

INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);

CREATE TABLE `tcc_fence_log` (
  `xid` varchar(128) NOT NULL COMMENT 'global id',
  `branch_id` bigint(20) NOT NULL COMMENT 'branch id',
  `action_name` varchar(64) NOT NULL COMMENT 'action name',
  `status` tinyint(4) NOT NULL COMMENT 'status(tried:1;committed:2;rollbacked:3;suspended:4)',
  `gmt_create` datetime(3) NOT NULL COMMENT 'create time',
  `gmt_modified` datetime(3) NOT NULL COMMENT 'update time',
  PRIMARY KEY (`xid`,`branch_id`),
  KEY `idx_gmt_modified` (`gmt_modified`),
  KEY `idx_status` (`status`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

在这里插入图片描述

server:
  port: 7091

spring:
  application:
    name: seata-server

logging:
  config: classpath:logback-spring.xml
  file:
    path: ${user.home}/logs/seata
  extend:
    logstash-appender:
      destination: 127.0.0.1:4560
    kafka-appender:
      bootstrap-servers: 127.0.0.1:9092
      topic: logback_to_logstash

console:
  user:
    username: seata
    password: seata

seata:
  config:
    # support: nacos 、 consul 、 apollo 、 zk  、 etcd3
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: 7e838c12-8554-4231-82d5-6d93573ddf32
      group: SEATA_GROUP
      username:
      password:
      ##if use MSE Nacos with auth, mutex with username/password attribute
      #access-key: ""
      #secret-key: ""
      data-id: seataServer.properties
  registry:
    # support: nacos 、 eureka 、 redis 、 zk  、 consul 、 etcd3 、 sofa
    type: nacos
    preferred-networks: 30.240.*
    nacos:
      application: seata-server
      server-addr: 127.0.0.1:8848
      group: SEATA_GROUP
      namespace:
      cluster: default
      username:
      password:
      ##if use MSE Nacos with auth, mutex with username/password attribute
      #access-key: ""
      #secret-key: ""
  store:
    # support: file 、 db 、 redis
    mode: db
#  server:
#    service-port: 8091 #If not configured, the default is '${server.port} + 1000'
  security:
    secretKey: SeataSecretKey0c382ef121d778043159209298fd40bf3850a017
    tokenValidityInMilliseconds: 1800000
    ignore:
      urls: /,/**/*.css,/**/*.js,/**/*.html,/**/*.map,/**/*.svg,/**/*.png,/**/*.ico,/console-fe/public/**,/api/v1/auth/login

在这里插入图片描述

https://github.com/seata/seata/blob/v1.5.1/script/config-center/config.txt

在这里插入图片描述

config.txt 文件主要修改：

1.存储模式：

store.mode=db

2.数据库信息：

store.db.url=jdbc:mysql://127.0.0.1:3306/seata

store.db.user=root

store.db.password=root

3.事务分组一定要跟你项目中的yml文件的tx-service-group: default_tx_group对应上：

service.vgroupMapping.default_tx_group=default

内容如下：

#For details about configuration items, see https://seata.io/zh-cn/docs/user/configurations.html
#Transport configuration, for client and server
transport.type=TCP
transport.server=NIO
transport.heartbeat=true
transport.enableTmClientBatchSendRequest=false
transport.enableRmClientBatchSendRequest=true
transport.enableTcServerBatchSendResponse=false
transport.rpcRmRequestTimeout=30000
transport.rpcTmRequestTimeout=30000
transport.rpcTcRequestTimeout=30000
transport.threadFactory.bossThreadPrefix=NettyBoss
transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
transport.threadFactory.shareBossWorker=false
transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
transport.threadFactory.clientSelectorThreadSize=1
transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
transport.threadFactory.bossThreadSize=1
transport.threadFactory.workerThreadSize=default
transport.shutdown.wait=3
transport.serialization=seata
transport.compressor=none

#Transaction routing rules configuration, only for the client
service.vgroupMapping.default_tx_group=default
#If you use a registry, you can ignore it
service.default.grouplist=127.0.0.1:8091
service.enableDegrade=false
service.disableGlobalTransaction=false

#Transaction rule configuration, only for the client
client.rm.asyncCommitBufferLimit=10000
client.rm.lock.retryInterval=10
client.rm.lock.retryTimes=30
client.rm.lock.retryPolicyBranchRollbackOnConflict=true
client.rm.reportRetryCount=5
client.rm.tableMetaCheckEnable=true
client.rm.tableMetaCheckerInterval=60000
client.rm.sqlParserType=druid
client.rm.reportSuccessEnable=false
client.rm.sagaBranchRegisterEnable=false
client.rm.sagaJsonParser=fastjson
client.rm.tccActionInterceptorOrder=-2147482648
client.tm.commitRetryCount=5
client.tm.rollbackRetryCount=5
client.tm.defaultGlobalTransactionTimeout=60000
client.tm.degradeCheck=false
client.tm.degradeCheckAllowTimes=10
client.tm.degradeCheckPeriod=2000
client.tm.interceptorOrder=-2147482648
client.undo.dataValidation=true
client.undo.logSerialization=jackson
client.undo.onlyCareUpdateColumns=true
server.undo.logSaveDays=7
server.undo.logDeletePeriod=86400000
client.undo.logTable=undo_log
client.undo.compress.enable=true
client.undo.compress.type=zip
client.undo.compress.threshold=64k
#For TCC transaction mode
tcc.fence.logTableName=tcc_fence_log
tcc.fence.cleanPeriod=1h

#Log rule configuration, for client and server
log.exceptionRate=100

#Transaction storage configuration, only for the server. The file, DB, and redis configuration values are optional.
store.mode=db
store.lock.mode=file
store.session.mode=file
#Used for password encryption
store.publicKey=

#If `store.mode,store.lock.mode,store.session.mode` are not equal to `file`, you can remove the configuration block.
store.file.dir=file_store/data
store.file.maxBranchSessionSize=16384
store.file.maxGlobalSessionSize=512
store.file.fileWriteBufferCacheSize=16384
store.file.flushDiskMode=async
store.file.sessionReloadReadSize=100

#These configurations are required if the `store mode` is `db`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `db`, you can remove the configuration block.
store.db.datasource=druid
store.db.dbType=mysql
store.db.driverClassName=com.mysql.jdbc.Driver
store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true
store.db.user=root
store.db.password=root
store.db.minConn=5
store.db.maxConn=30
store.db.globalTable=global_table
store.db.branchTable=branch_table
store.db.distributedLockTable=distributed_lock
store.db.queryLimit=100
store.db.lockTable=lock_table
store.db.maxWait=5000

#These configurations are required if the `store mode` is `redis`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `redis`, you can remove the configuration block.
store.redis.mode=single
store.redis.single.host=127.0.0.1
store.redis.single.port=6379
store.redis.sentinel.masterName=
store.redis.sentinel.sentinelHosts=
store.redis.maxConn=10
store.redis.minConn=1
store.redis.maxTotal=100
store.redis.database=0
store.redis.password=
store.redis.queryLimit=100

#Transaction rule configuration, only for the server
server.recovery.committingRetryPeriod=1000
server.recovery.asynCommittingRetryPeriod=1000
server.recovery.rollbackingRetryPeriod=1000
server.recovery.timeoutRetryPeriod=1000
server.maxCommitRetryTimeout=-1
server.maxRollbackRetryTimeout=-1
server.rollbackRetryTimeoutUnlockEnable=false
server.distributedLockExpireTime=10000
server.xaerNotaRetryTimeout=60000
server.session.branchAsyncQueueSize=5000
server.session.enableBranchAsyncRemove=false

#Metrics configuration, only for the server
metrics.enabled=false
metrics.registryType=compact
metrics.exporterList=prometheus
metrics.exporterPrometheusPort=9898

在这里插入图片描述

server:
  port: 8028

spring:
  application:
    name: tcc-order-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848

  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://localhost:3306/db_tcc_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      username: root
      password: root
      initial-size: 10
      max-active: 100
      min-idle: 10
      max-wait: 60000
      pool-prepared-statements: true
      max-pool-prepared-statement-per-connection-size: 20
      time-between-eviction-runs-millis: 60000
      min-evictable-idle-time-millis: 300000
      test-while-idle: true
      test-on-borrow: false
      test-on-return: false
      stat-view-servlet:
        enabled: true
        url-pattern: /druid/*
      filter:
        stat:
          log-slow-sql: true
          slow-sql-millis: 1000
          merge-sql: false
        wall:
          config:
            multi-statement-allow: true

logging:
  level:
    com.tuling: debug

seata:
  application-id: ${spring.application.name}
  # seata 服务分组，要与服务端配置service.vgroup_mapping的后缀对应
  tx-service-group: default_tx_group
  registry:
    # 指定nacos作为注册中心
    type: nacos
    nacos:
      application: seata-server
      server-addr: 127.0.0.1:8848
      namespace:
      group: SEATA_GROUP

  config:
    # 指定nacos作为配置中心
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: 7e838c12-8554-4231-82d5-6d93573ddf32
      group: SEATA_GROUP
      data-id: seataServer.properties

#暴露actuator端点
management:
  endpoints:
    web:
      exposure:
        include: '*'

在这里插入图片描述

package com.qingzhou.tccorderservice.service.impl;
import com.qingzhou.datasource.entity.Order;
import com.qingzhou.tccorderservice.feign.AccountFeignService;
import com.qingzhou.tccorderservice.feign.StorageFeignService;
import com.qingzhou.tccorderservice.service.BussinessService;
import com.qingzhou.tccorderservice.service.OrderService;
import com.qingzhou.tccorderservice.util.UUIDGenerator;
import com.qingzhou.tccorderservice.vo.OrderVo;
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;
/**
* @author qingzhou
*/
@Service
@Slf4j
public class BusinessServiceImpl implements BussinessService {

    @Autowired
    private AccountFeignService accountFeignService;

    @Autowired
    private StorageFeignService storageFeignService;

    @Autowired
    private OrderService orderService;


    @Override
    @GlobalTransactional(name="createOrder",rollbackFor=Exception.class)
    public Order saveOrder(OrderVo orderVo) {
        log.info("=============用户下单=================");
        log.info("当前 XID: {}", RootContext.getXID());

        //获取全局唯一订单号
        Long orderId = UUIDGenerator.generateUUID();
        //阶段一： 创建订单
        Order order = orderService.prepareSaveOrder(orderVo,orderId);
        //扣减库存
        storageFeignService.deduct(orderVo.getCommodityCode(), orderVo.getCount());
        //扣减余额
        accountFeignService.debit(orderVo.getUserId(), orderVo.getMoney());
        return order;
    }
}

在这里插入图片描述

package com.qingzhou.tccorderservice.service;
import com.qingzhou.datasource.entity.Order;
import com.qingzhou.tccorderservice.vo.OrderVo;
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;

/**
 * @author qingzhou
 *
 * 通过 @LocalTCC 这个注解，RM 初始化的时候会向 TC 注册一个分支事务。
 */
@LocalTCC
public interface OrderService {

    /**
     * TCC的try方法：保存订单信息，状态为支付中
     *
     * 定义两阶段提交，在try阶段通过@TwoPhaseBusinessAction注解定义了分支事务的 resourceId，commit和 cancel 方法
     *  name = 该tcc的bean名称,全局唯一
     *  commitMethod = commit 为二阶段确认方法
     *  rollbackMethod = rollback 为二阶段取消方法
     *  BusinessActionContextParameter注解 传递参数到二阶段中
     *  useTCCFence seata1.5.1的新特性，用于解决TCC幂等，悬挂，空回滚问题，需增加日志表tcc_fence_log
     */
    @TwoPhaseBusinessAction(name = "prepareSaveOrder", commitMethod = "commit", rollbackMethod = "rollback", useTCCFence = true)
    Order prepareSaveOrder(OrderVo orderVo, @BusinessActionContextParameter(paramName = "orderId") Long orderId);

    /**
     *
     * TCC的confirm方法：订单状态改为支付成功
     *
     * 二阶段确认方法可以另命名，但要保证与commitMethod一致
     * context可以传递try方法的参数
     *
     * @param actionContext
     * @return
     */
    boolean commit(BusinessActionContext actionContext);

    /**
     * TCC的cancel方法：订单状态改为支付失败
     * 二阶段取消方法可以另命名，但要保证与rollbackMethod一致
     *
     * @param actionContext
     * @return
     */
    boolean rollback(BusinessActionContext actionContext);
}

在这里插入图片描述

package com.qingzhou.tccorderservice.service.impl;
import com.qingzhou.datasource.entity.Order;
import com.qingzhou.datasource.entity.OrderStatus;
import com.qingzhou.datasource.mapper.OrderMapper;
import com.qingzhou.tccorderservice.feign.AccountFeignService;
import com.qingzhou.tccorderservice.feign.StorageFeignService;
import com.qingzhou.tccorderservice.service.OrderService;
import com.qingzhou.tccorderservice.vo.OrderVo;
import io.seata.rm.tcc.api.BusinessActionContext;
import io.seata.rm.tcc.api.BusinessActionContextParameter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * @author qingzhou
 */
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    
    @Autowired
    private AccountFeignService accountFeignService;
    
    @Autowired
    private StorageFeignService storageFeignService;

    @Autowired
    private OrderService orderService;


    @Override
    @Transactional(rollbackFor=Exception.class)
    public Order prepareSaveOrder(OrderVo orderVo,
                                  @BusinessActionContextParameter(paramName = "orderId") Long orderId) {

        // 保存订单
        Order order = new Order();
        order.setId(orderId);
        order.setUserId(orderVo.getUserId());
        order.setCommodityCode(orderVo.getCommodityCode());
        order.setCount(orderVo.getCount());
        order.setMoney(orderVo.getMoney());
        order.setStatus(OrderStatus.INIT.getValue());
        Integer saveOrderRecord = orderMapper.insert(order);
        log.info("保存订单{}", saveOrderRecord > 0 ? "成功" : "失败");

        return order;
    }

    @Override
    public boolean commit(BusinessActionContext actionContext) {
        // 获取订单id
        long orderId = Long.parseLong(actionContext.getActionContext("orderId").toString());
        //更新订单状态为支付成功
        Integer updateOrderRecord = orderMapper.updateOrderStatus(orderId,OrderStatus.SUCCESS.getValue());
        log.info("更新订单id:{} {}", orderId, updateOrderRecord > 0 ? "成功" : "失败");

        return true;
    }

    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        //获取订单id
        long orderId = Long.parseLong(actionContext.getActionContext("orderId").toString());
        //更新订单状态为支付失败
        Integer updateOrderRecord = orderMapper.updateOrderStatus(orderId,OrderStatus.FAIL.getValue());
        log.info("更新订单id:{} {}", orderId, updateOrderRecord > 0 ? "成功" : "失败");

        return true;
    }

}

在这里插入图片描述

package com.qingzhou.tccstorageservice.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;

/**
 * @author qingzhou
 *
 * 通过 @LocalTCC 这个注解，RM 初始化的时候会向 TC 注册一个分支事务。
 */
@LocalTCC
public interface StorageService {

    /**
     * Try: 库存-扣减数量，冻结库存+扣减数量
     *
     * 定义两阶段提交，在try阶段通过@TwoPhaseBusinessAction注解定义了分支事务的 resourceId，commit和 cancel 方法
     *  name = 该tcc的bean名称,全局唯一
     *  commitMethod = commit 为二阶段确认方法
     *  rollbackMethod = rollback 为二阶段取消方法
     *  BusinessActionContextParameter注解 传递参数到二阶段中
     *
     * @param commodityCode 商品编号
     * @param count 扣减数量
     * @return
     */
    @TwoPhaseBusinessAction(name = "deduct", commitMethod = "commit", rollbackMethod = "rollback", useTCCFence = true)
    boolean deduct(@BusinessActionContextParameter(paramName = "commodityCode") String commodityCode,
                   @BusinessActionContextParameter(paramName = "count") int count);

    /**
     *
     * Confirm: 冻结库存-扣减数量
     * 二阶段确认方法可以另命名，但要保证与commitMethod一致
     * context可以传递try方法的参数
     *
     * @param actionContext
     * @return
     */
    boolean commit(BusinessActionContext actionContext);

    /**
     * Cancel: 库存+扣减数量，冻结库存-扣减数量
     * 二阶段取消方法可以另命名，但要保证与rollbackMethod一致
     *
     * @param actionContext
     * @return
     */
    boolean rollback(BusinessActionContext actionContext);
}

在这里插入图片描述

package com.qingzhou.tccstorageservice.service.impl;
import com.qingzhou.datasource.entity.Storage;
import com.qingzhou.datasource.mapper.StorageMapper;
import com.qingzhou.tccstorageservice.service.StorageService;
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;

/**
 * @author qingzhou
 */
@Service
@Slf4j
public class StorageServiceImpl implements StorageService {
    
    @Autowired
    private StorageMapper storageMapper;
    
    @Transactional
    @Override
    public boolean deduct(String commodityCode, int count){
        log.info("=============冻结库存=================");
        log.info("当前 XID: {}", RootContext.getXID());

        // 检查库存
        checkStock(commodityCode,count);
        
        log.info("开始冻结 {} 库存", commodityCode);
        //冻结库存
        Integer record = storageMapper.freezeStorage(commodityCode,count);
        log.info("冻结 {} 库存结果:{}", commodityCode, record > 0 ? "操作成功" : "扣减库存失败");
        return true;
    }

    @Override
    public boolean commit(BusinessActionContext actionContext) {
        log.info("=============扣减冻结库存=================");

        String commodityCode = actionContext.getActionContext("commodityCode").toString();
        int count = (int) actionContext.getActionContext("count");
        //扣减冻结库存
        storageMapper.reduceFreezeStorage(commodityCode,count);

        return true;
    }

    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        log.info("=============解冻库存=================");

        String commodityCode = actionContext.getActionContext("commodityCode").toString();
        int count = (int) actionContext.getActionContext("count");
        //扣减冻结库存
        storageMapper.unfreezeStorage(commodityCode,count);

        return true;
    }

    private void checkStock(String commodityCode, int count){
        
        log.info("检查 {} 库存", commodityCode);
        Storage storage = storageMapper.findByCommodityCode(commodityCode);
        if (storage.getCount() < count) {
            log.warn("{} 库存不足，当前库存:{}", commodityCode, count);
            throw new RuntimeException("库存不足");
        }
        
    }
    
}

在这里插入图片描述

package com.qingzhou.tccaccountservice.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;

/**
 * @author qingzhou
 *
 * 通过 @LocalTCC 这个注解，RM 初始化的时候会向 TC 注册一个分支事务。
 */
@LocalTCC
public interface AccountService {

    /**
     * 用户账户扣款
     *
     * 定义两阶段提交，在try阶段通过@TwoPhaseBusinessAction注解定义了分支事务的 resourceId，commit和 cancel 方法
     *  name = 该tcc的bean名称,全局唯一
     *  commitMethod = commit 为二阶段确认方法
     *  rollbackMethod = rollback 为二阶段取消方法
     *
     * @param userId
     * @param money 从用户账户中扣除的金额
     * @return
     */
    @TwoPhaseBusinessAction(name = "debit", commitMethod = "commit", rollbackMethod = "rollback", useTCCFence = true)
    boolean debit(@BusinessActionContextParameter(paramName = "userId") String userId,
                  @BusinessActionContextParameter(paramName = "money") int money);

    /**
     * 提交事务，二阶段确认方法可以另命名，但要保证与commitMethod一致
     * context可以传递try方法的参数
     *
     * @param actionContext
     * @return
     */
    boolean commit(BusinessActionContext actionContext);

    /**
     * 回滚事务，二阶段取消方法可以另命名，但要保证与rollbackMethod一致
     *
     * @param actionContext
     * @return
     */
    boolean rollback(BusinessActionContext actionContext);
}

在这里插入图片描述

package com.qingzhou.tccaccountservice.service.impl;
import com.qingzhou.datasource.entity.Account;
import com.qingzhou.datasource.mapper.AccountMapper;
import com.qingzhou.tccaccountservice.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 org.springframework.transaction.annotation.Transactional;
/**
 * @author qingzhou
 */
@Service
@Slf4j
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountMapper accountMapper;
    /**
     * 扣减用户金额
     * @param userId
     * @param money
     */
    @Transactional
    @Override
    public boolean debit(String userId, int money){
        log.info("=============冻结用户账户余额=================");
        log.info("当前 XID: {}", RootContext.getXID());
    
        checkBalance(userId, money);
        
        log.info("开始冻结用户 {} 余额", userId);
        //冻结金额
        Integer record = accountMapper.freezeBalance(userId,money);

        log.info("冻结用户 {} 余额结果:{}", userId, record > 0 ? "操作成功" : "扣减余额失败");
        return true;
    }

    @Override
    public boolean commit(BusinessActionContext actionContext) {
        log.info("=============扣减冻结金额=================");

        String userId = actionContext.getActionContext("userId").toString();
        int money = (int) actionContext.getActionContext("money");
        //扣减冻结金额
        accountMapper.reduceFreezeBalance(userId,money);

        return true;
    }

    @Override
    public boolean rollback(BusinessActionContext actionContext) {
        log.info("=============解冻金额=================");

        String userId = actionContext.getActionContext("userId").toString();
        int money = (int) actionContext.getActionContext("money");
        //解冻金额
        accountMapper.unfreezeBalance(userId,money);

        return true;
    }

    private void checkBalance(String userId, int money){
        log.info("检查用户 {} 余额", userId);
        Account account = accountMapper.selectByUserId(userId);
        
        if (account.getMoney() < money) {
            log.warn("用户 {} 余额不足，当前余额:{}", userId, account.getMoney());
            throw new RuntimeException("余额不足");
        }
        
    }
}

以上为主要的代码逻辑，完整代码 link 自取：

https://pan.baidu.com/s/1csd9l_g-huiVnf_JUXWAtA?pwd=qmo3

T取码：qmo3

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

天空～之城
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实战~阿里神器 Seata 实现 TCC模式 解决分布式事务，真香
20年码农
01-12 948
今天这篇文章介绍一下Seata如何实现TCC事务模式，文章目录如下： 什么是TCC模式？ TCC（Try Confirm Cancel）方案是一种应用层面侵入业务的两阶段提交。是目前最火的一种柔性事务方案，其核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。 TCC分为两个阶段，分别如下： 第一阶段：Try（尝试），主要是对业务系统做检测及资源预留(加锁，锁住资源) 第二阶段：本阶段根据第一阶段的结果，决定是执行confirm还是cancel Confirm（确认.
【微服务】（十六）—— 分布式事务Seata
热门推荐
jizhibing的博客
05-10 2万+
目录 事务ACID原则 一、理论基础 1）CAP理论 CAP定理- Consistency CAP定理- Availability CAP定理-Partition tolerance 2）BASE理论 二、分布式事务Seata 1）初识seata 2）Seata架构 3）微服务集成seata 1、首先，引入seata相关依赖： 2、然后，配置application.yml，让微服务通过注册中心找到seata-tc-server： 三、XA模式 1）XA模式原理 2...
seata2.0，报service.vgroupMapping.default_tx_group configuration item is required错误
最新发布
LuoFeng_next的博客
07-04 1486
Failed to get available servers: service.vgroupMapping.default_tx_group configuration item is required
关于collecting状态的分布式悬挂事务
couyu6150的博客
10-18 251
某企业集团BI数据库select * from dba_2pc_pending查出状态为collecting的悬挂事务，无法通过commit force或rollback force提交(仅限prepared事务),只好通过DB...
Apache Seata如何解决TCC 模式的幂等、悬挂和空回滚问题
IT云清
04-27 4400
Apache Seata如何解决TCC 模式的幂等、悬挂和空回滚问题
阿里 Seata 新版本终于解决了 TCC 模式的幂等、悬挂和空回滚问题
zjj2006的专栏
06-20 2842
阿里巴巴 Seata 新版本（1.5.1）解决了 TCC 模式下的幂等、悬挂和空回滚问题的。
seata 1.4.2 分布式事务TCC模式示例
03-26
1. 在seata 1.4.2 分布式事务AT模式示例的基础上增加TCC模式； 2. 目前采用的是AT模式和TCC模式混合使用的方式； 3. Account模块采用了TCC模式，整合业务代码； 4. Product模块采用了TCC模式，未整合业务代码； 5. ...
Seata的分布式事务AT模式和TCC模式实现
07-05
此代码为我的Seata专栏的配套代码，主要是Seata的AT模式和TCC模式的基本使用代码。 1. 包含seata-order-8001和seata-stock-8002两个服务 2. 包含两个数据库seata-order和seata-stock对应的表的sql结构和数据 3. ...
分布式事务 Seata TCC 模式深度解析
07-01
本文档的内容主要分为以下...1、Seata TCC 模式的原理解析； 2、从 TCC 的业务模型与并发控制分享如何设计一个 TCC 接口，并且适配 TCC 模型； 3、如何控制异常； 4、性能优化，使得 TCC 模式能够满足更高的业务需求。
seata分布式事务解决方案
10-15
Seata采用的是基于柔性事务的AT模式（Automatic Transaction Mode），它将一个全局事务分为准备、提交和回滚三个阶段，解决了传统2PC的阻塞问题，同时提供了更好的性能和可扩展性。 2. **Seata架构组件** - **TM...
seata分布式事务0.9.0
02-25
Seata（Simple Extensible Autonomous Transaction Architecture）是一款开源的分布式事务解决方案，主要针对微服务场景下的分布式事务问题。在0.9.0版本中，Seata提供了高性能和简单易用的特性，旨在帮助开发者解决...
Java微服务分布式事务框架seata的TCC模式
Java 技术专栏，从入门到精通，熟悉企业级开发
03-22 1万+
上一章节介绍微服务分布式项目中，使用的事务框架seata，本章节介绍分布式事务框架seata TCC模式，以及集成到Springboot、微服务框架里。
Seata TCC 模式
u010480873的博客
07-19 337
总之，使用 Seata 实现 TCC 模式需要进行配置和编码，主要包括添加 Seata 依赖、配置 Seata、实现 TCC 接口和测试 TCC 模式等步骤。在实现 TCC 接口时，需要实现。Seata 是一个开源的分布式事务解决方案，支持多种事务模式，包括 TCC 模式。在测试 TCC 模式时，需要在方法上添加。方法执行成功后自动提交事务，如果执行失败，则会自动回滚事务。方法执行成功后，Seata 将会调用。方法提交事务，如果执行失败，则会调用。配置 Seata 的事务组名称，方法，Seata 将会在。
seata分布式事务tcc模式和at模式配置详解
王威振的博客
08-24 6658
首先先来说at模式。这个模式是seata中最简单的。代码无侵入基于数据库实现 下面来说具体配置步骤： 1、在配置文件中增加seata spring: cloud: alibaba: seata: tx-service-group: order-service-group #seata客户端配置的实例名 2、引入seata客户端文件file.conf和registry.conf到resources目录下。注意：用到seata事务的模块都需要引入 3、增加
[分布式事务-TCC] 2. TCC的异常场景及应对机制
不忘初心，好好沉淀
06-16 1万+
文章导航TCC的异常场景幂等处理产生原因应对策略空回滚产生原因应对策略资源悬挂产生原因应对策略三种异常总结幂等空回滚资源悬挂共通点 TCC的异常场景 在分布式系统中，随时随地都需要面对网络超时，网络重发和服务器宕机等问题。所以分布式事务框架作为搭载在分布式系统之上的一个框架型应用也绕不开这些问题。具体而言，有以下常见问题： 幂等处理 空回滚 资源悬挂 这些异常的应对需要TCC框架的支持和解决方...
Seata模式-tcc
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
12-13 271
TCC 模式。
事务--03---TCC空回滚、悬挂、幂等解决方案
时光里的博客
12-14 1169
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档。
Seata实战-TCC模式分布式事务原理、源码分析
hosaos的博客
05-05 1万+
文章目录原理简介Demo回顾源码分析TCC资源注册开启TCC全局事务TCC拦截器-注册分支事务全局事务提交全局事务回滚 原理简介 TCC相关原理以及Seata中TCC例子demo的使用，在之前文章中已经说明，有兴趣的可以看看 https://blog.csdn.net/hosaos/article/details/89136666 本文会介绍下Seata中TCC模式设计思路及原理，源码版本0....
五阶段--分布式事务--Seata TCC模式-TCC模式/Spring Cloud微服务添加 TCC 分布式事务
weixin_58580280的博客
09-23 873
分布式事务（六）Seata TCC模式-TCC模式介绍 一 TCC 基本原理 TCC 与 Seata AT 事务一样都是两阶段事务，它与 AT 事务的主要区别为： TCC 对业务代码侵入严重 每个阶段的数据操作都要自己进行编码来实现，事务框架无法自动处理。 TCC 效率更高 不必对数据加全局锁，允许多个事务并发同时操作数据。 二 TCC 事务 1 创建工程,导入项目 第一步: 创建 empty project: seata-tcc ,与seata-at工程区分开 第二步: ...
seata是怎么解决空回滚和事务悬挂
03-14
在 Seata 中，空回滚和事务悬挂问题都可以通过使用超时机制来解决。具体来说，如果一个事务在执行过程中出现了异常或者超时，Seata 会将该事务标记为“回滚状态”，并通知所有参与者进行回滚操作。这样可以避免空...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值