分布式事务 Seata TCC

最新推荐文章于 2024-08-07 14:56:32 发布

natashaVR

最新推荐文章于 2024-08-07 14:56:32 发布

阅读量204

点赞数

文章标签： docker 容器运维

本文链接：https://blog.csdn.net/liymaVR/article/details/121567677

版权

TCC 基本原理

TCC 与 Seata AT 事务一样都是两阶段事务，它与 AT 事务的主要区别为：

TCC 对业务代码侵入严重
每个阶段的数据操作都要自己进行编码来实现，事务框架无法自动处理。
TCC 效率更高
不必对数据加全局锁，允许多个事务同时操作数据。
第一阶段 Try

以账户服务为例，当下订单时要扣减用户账户金额：

假如用户购买 100 元商品，要扣减 100 元。

TCC 事务首先对这100元的扣减金额进行预留，或者说是先冻结这100元：

第二阶段 Confirm

如果第一阶段能够顺利完成，那么说明“扣减金额”业务（分支事务）最终肯定是可以成功的。当全局事务提交时， TC会控制当前分支事务进行提交，如果提交失败，TC 会反复尝试，直到提交成功为止。

当全局事务提交时，就可以使用冻结的金额来最终实现业务数据操作：

第二阶段 Cancel

如果全局事务回滚，就把冻结的金额进行解冻，恢复到以前的状态，TC 会控制当前分支事务回滚，如果回滚失败，TC 会反复尝试，直到回滚完成为止。

多个事务并发的情况

多个TCC全局事务允许并发，它们执行扣减金额时，只需要冻结各自的金额即可：

Seata TCC事务模式

Seata 支持 TCC 事务模式，与 AT 模式相同的，也需要以下组件来支持全局事务的控制：

TC 事务协调器
TM 事务管理器
RM 资源管理器

导入订单项目，无事务版本

下载项目代码:微儿VR (weier-vr) - Gitee.com

order启动全局事务，添加“保存订单”分支事务

在订单项目中执行添加订单：

我们要添加以下 TCC 事务操作的代码：

Try - 第一阶，冻结数据阶段，向订单表直接插入订单，订单状态设置为0（冻结状态）。

Confirm - 第二阶段，提交事务，将订单状态修改成1（正常状态）。

Cancel - 第二阶段，回滚事务，删除订单。

order-parent 添加 seata 依赖

打开 order-parent 中注释掉的 seata 依赖：

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.tedu</groupId>
    <artifactId>order-parent</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    <name>order-parent</name>


    <properties>
        <mybatis-plus.version>3.3.2</mybatis-plus.version>
        <druid-spring-boot-starter.version>1.1.23</druid-spring-boot-starter.version>
        <seata.version>1.3.0</seata.version>
        <spring-cloud-alibaba-seata.version>2.0.0.RELEASE</spring-cloud-alibaba-seata.version>
        <spring-cloud.version>Hoxton.SR6</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>${mybatis-plus.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>${druid-spring-boot-starter.version}</version>
        </dependency>


		<!-- 打开 seata 依赖 -->
        <dependency>
          <groupId>com.alibaba.cloud</groupId>
          <artifactId>spring-cloud-alibaba-seata</artifactId>
          <version>${spring-cloud-alibaba-seata.version}</version>
          <exclusions>
            <exclusion>
              <artifactId>seata-all</artifactId>
              <groupId>io.seata</groupId>
            </exclusion>
          </exclusions>
        </dependency>
        <dependency>
          <groupId>io.seata</groupId>
          <artifactId>seata-all</artifactId>
          <version>${seata.version}</version>
        </dependency>


        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

设置全局事务组的组名：

spring:
  application:
    name: order

  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost/seata_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
    username: root
    password: root

  # 事务组设置
  cloud:
    alibaba:
      seata:
        tx-service-group: order_tx_group

......

registry.conf 和 file.conf

与 AT 事务中的配置完全相同：

registry.conf：

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "eureka"

  nacos {
    serverAddr = "localhost"
    namespace = ""
    cluster = "default"
  }
  eureka {
    serviceUrl = "http://localhost:8761/eureka"
    # application = "default"
    # weight = "1"
  }
  redis {
    serverAddr = "localhost:6379"
    db = "0"
    password = ""
    cluster = "default"
    timeout = "0"
  }
  zk {
    cluster = "default"
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
    username = ""
    password = ""
  }
  consul {
    cluster = "default"
    serverAddr = "127.0.0.1:8500"
  }
  etcd3 {
    cluster = "default"
    serverAddr = "http://localhost:2379"
  }
  sofa {
    serverAddr = "127.0.0.1:9603"
    application = "default"
    region = "DEFAULT_ZONE"
    datacenter = "DefaultDataCenter"
    cluster = "default"
    group = "SEATA_GROUP"
    addressWaitTime = "3000"
  }
  file {
    name = "file.conf"
  }
}

config {
  # file、nacos 、apollo、zk、consul、etcd3、springCloudConfig
  type = "file"

  nacos {
    serverAddr = "localhost"
    namespace = ""
    group = "SEATA_GROUP"
  }
  consul {
    serverAddr = "127.0.0.1:8500"
  }
  apollo {
    app.id = "seata-server"
    apollo.meta = "http://192.168.1.204:8801"
    namespace = "application"
  }
  zk {
    serverAddr = "127.0.0.1:2181"
    session.timeout = 6000
    connect.timeout = 2000
    username = ""
    password = ""
  }
  etcd3 {
    serverAddr = "http://localhost:2379"
  }
  file {
    name = "file.conf"
  }
}

file.conf：

transport {
  # tcp udt unix-domain-socket
  type = "TCP"
  #NIO NATIVE
  server = "NIO"
  #enable heartbeat
  heartbeat = true
  # the client batch send request enable
  enableClientBatchSendRequest = true
  #thread factory for netty
  threadFactory {
    bossThreadPrefix = "NettyBoss"
    workerThreadPrefix = "NettyServerNIOWorker"
    serverExecutorThread-prefix = "NettyServerBizHandler"
    shareBossWorker = false
    clientSelectorThreadPrefix = "NettyClientSelector"
    clientSelectorThreadSize = 1
    clientWorkerThreadPrefix = "NettyClientWorkerThread"
    # netty boss thread size,will not be used for UDT
    bossThreadSize = 1
    #auto default pin or 8
    workerThreadSize = "default"
  }
  shutdown {
    # when destroy server, wait seconds
    wait = 3
  }
  serialization = "seata"
  compressor = "none"
}
service {
  #transaction service group mapping
  # order_tx_group 与 yml 中的 “tx-service-group: order_tx_group” 配置一致
  # “seata-server” 与 TC 服务器的注册名一致
  # 从eureka获取seata-server的地址，再向seata-server注册自己，设置group
  vgroupMapping.order_tx_group = "seata-server"
  #only support when registry.type=file, please don't set multiple addresses
  order_tx_group.grouplist = "127.0.0.1:8091"
  #degrade, current not support
  enableDegrade = false
  #disable seata
  disableGlobalTransaction = false
}

client {
  rm {
    asyncCommitBufferLimit = 10000
    lock {
      retryInterval = 10
      retryTimes = 30
      retryPolicyBranchRollbackOnConflict = true
    }
    reportRetryCount = 5
    tableMetaCheckEnable = false
    reportSuccessEnable = false
  }
  tm {
    commitRetryCount = 5
    rollbackRetryCount = 5
  }
  undo {
    dataValidation = true
    logSerialization = "jackson"
    logTable = "undo_log"
  }
  log {
    exceptionRate = 100
  }
}

OrderMapper 添加更新订单状态、删除订单

根据前面的分析，订单数据操作有以下三项：

插入订单
修改订单状态
删除订单

package cn.tedu.order.mapper;

import cn.tedu.order.entity.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface OrderMapper extends BaseMapper<Order> {
    void create(Order order);

    //插入冻结订单
    void  insertFrozen(Order order);
    //修改订单状态
    void updateStatus(Long orderId ,Integer status);
    //删除订单,使用继承的 deleteById();
    void deleteById();

}

那么对应的 OrderMapper.xml 中也要添加 sql：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.tedu.order.mapper.OrderMapper" >
    <resultMap id="BaseResultMap" type="Order" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="user_id" property="userId" jdbcType="BIGINT" />
        <result column="product_id" property="productId" jdbcType="BIGINT" />
        <result column="count" property="count" jdbcType="INTEGER" />
        <result column="money" property="money" jdbcType="DECIMAL" />
        <result column="status" property="status" jdbcType="INTEGER" />
    </resultMap>
    <insert id="create">
        INSERT INTO `order` (id,user_id,product_id,`count`,`money`,`status`)
        VALUES(#{id}, #{userId}, #{productId}, #{count}, #{money},1);
    </insert>
    <insert id="insertFrozen">
        INSERT INTO `order` (id,user_id,product_id,`count`,`money`,`status`)
        VALUES(#{id}, #{userId}, #{productId}, #{count}, #{money},0);
    </insert>
    <update id="updateStatus">
        update `order` set status=#{status} where id=#{orderId}
    </update>
    <delete id="deleteById">
        delete from `order` where id=#{orderId}
    </delete>
</mapper>

Seata 实现订单的 TCC 操作方法
第一阶段 Try
第二阶段
Confirm
Cancel
第二阶段为了处理幂等性问题这里首先添加一个工具类

interface OrderMapper

package cn.tedu.order.mapper;

import cn.tedu.order.entity.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface OrderMapper extends BaseMapper<Order> {
    void create(Order order);

    //插入冻结订单
    void  insertFrozen(Order order);
    //修改订单状态
    void updateStatus(Long orderId ,Integer status);
    //删除订单,使用继承的 deleteById();
    void deleteById();

}

。

这个工具也可以在第二阶段 Confirm 或 Cancel 阶段对第一阶段的成功与否进行判断，在第一阶段成功时需要保存一个标识。

OrderTccAction

Seata 实现 TCC 操作需要定义一个接口，我们在接口中添加以下方法

package cn.tedu.order.tcc;

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;

/**
 * TCC 操作接口
 * 定义三个操作的方法
 */
@LocalTCC
public interface OrderTccAction {
    /**为了避开 seata 的一个bug,不传Order封装对象
     * 而是把order里的订单打散一个个传
     *@TwoPhaseBusinessAction第一阶段的方法名
     * @BusinessActionContextParameter 只要第二阶段用的都要加上这个注解
     */


    @TwoPhaseBusinessAction(name = "OrderTccAction",
            commitMethod = "commit",
    rollbackMethod = "rollback")
    boolean prepare(BusinessActionContext ctx,
                   @BusinessActionContextParameter(paramName = "orderId") Long orderId,
                    Long userId,
                    Long productId,
                    Integer count,
                    BigDecimal money);//这里不用对象就是为了避免阿里的Bug
    boolean commit(BusinessActionContext ctx);
    boolean rollback(BusinessActionContext ctx);



}

实现类：

package cn.tedu.order.tcc;

import cn.tedu.order.entity.Order;
import cn.tedu.order.mapper.OrderMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
@Component
public class OrderTccActionImpl implements OrderTccAction{
    @Autowired
    private OrderMapper orderMapper;

    @Transactional
    @Override
    public boolean prepare(BusinessActionContext ctx, Long orderId, Long userId, Long productId, Integer count, BigDecimal money) {
        orderMapper.insertFrozen(
                new Order(orderId,userId,productId,count,money,0));

        return true;
    }
    @Transactional
    @Override
    public boolean commit(BusinessActionContext ctx) {
        Long orderId = Long.valueOf(ctx.getActionContext("orderId").toString());
        orderMapper.updateStatus(orderId,1);
        return true;

    }
    @Transactional
    @Override
    public boolean rollback(BusinessActionContext ctx) {
        Long orderId = Long.valueOf(ctx.getActionContext("orderId").toString());
        orderMapper.deleteById(orderId);

        return true;
    }
}

启动 order 进行测试

按顺序启动服务：

Eureka
Seata Server
Easy Id Generator
Order

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

storage添加“减少库存”分支事务

在库存项目中执行减少库存：

我们要添加以下 TCC 事务操作的代码：

Try - 第一阶，冻结数据阶段，将要减少的库存量先冻结：

Confirm - 第二阶段，提交事务，使用冻结的库存完成业务数据处理：

Cancel - 第二阶段，回滚事务，冻结的库存解冻，恢复以前的库存量：

配置

有三个文件需要配置：

application.yml
registry.conf
file.conf

这三个文件的设置与上面 order 项目的配置完全相同，请参考上面订单配置一章进行配置。

StorageMapper 添加冻结库存相关方法

根据前面的分析，库存数据操作有以下三项：

冻结库存
冻结库存量修改为已售出量
解冻库存

在 StorageMapper 中添加三个方法：

package cn.tedu.order;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

@EnableFeignClients
@MapperScan("cn.tedu.order.mapper")
@SpringBootApplication
public class OrderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderApplication.class,args);
    }
}

那么对应的 StorageMapper.xml 中也要添加 sql：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.tedu.storage.mapper.StorageMapper" >
    <resultMap id="BaseResultMap" type="Storage" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="product_id" property="productId" jdbcType="BIGINT" />
        <result column="total" property="total" jdbcType="INTEGER" />
        <result column="used" property="used" jdbcType="INTEGER" />
        <result column="residue" property="residue" jdbcType="INTEGER" />
    </resultMap>
    <update id="decrease">
        UPDATE storage
        SET used = used + #{count},
            residue = residue - #{count}
        WHERE product_id = #{productId}
    </update>
    <select id="selectByProductId" resultMap="BaseResultMap">
        select * from storage WHERE product_id = #{productId}
    </select>
    <update id="updateResidueToFrozen">
        update storage
        set Residue=Residue-#{count}, Frozen=Frozen+#{count} WHERE product_id = #{productId}
    </update>
    <update id="updateFrozenToUsed">
        update storage
        set Frozen=Frozen-#{count}, Used=Used+#{count} WHERE product_id = #{productId}
    </update>
    <update id="updateFrozenToResidue">
        update storage
        set Frozen=Frozen-#{count}, Residue=Residue+#{count} WHERE product_id = #{productId}
    </update>

</mapper>

添加 TCC 接口，在接口中添加以下方法：

Try - prepareDecreaseStorage()
Confirm - commit()
Cancel - rollback()

package cn.tedu.storage.tcc;

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

    @TwoPhaseBusinessAction(name = "StorageTccAction")
    boolean prepare(BusinessActionContext ctx,
                    @BusinessActionContextParameter(paramName = "productId") Long productId,
                    @BusinessActionContextParameter(paramName = "count") Integer count);
    boolean commit(BusinessActionContext ctx);
    boolean rollback(BusinessActionContext ctx);


}

实现类：

package cn.tedu.storage.tcc;

import cn.tedu.storage.entity.Storage;
import cn.tedu.storage.mapper.StorageMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class StorageTccActionImpl implements StorageTccAction {
    @Autowired
    private StorageMapper storageMapper;
    @Transactional
    @Override
    public boolean prepare(BusinessActionContext ctx, Long productId, Integer count) {
        //先查询库存,判断有没有足够的库存
        Storage storage = storageMapper.selectByProductId(productId);
        if(storage.getResidue()<count){
            throw  new RuntimeException("库存不足");
        }
        //冻结库存
        storageMapper.updateResidueToFrozen(productId,count);
        return true;
    }
   @Transactional
    @Override
    public boolean commit(BusinessActionContext ctx) {
       Long productId = Long.valueOf(ctx.getActionContext("productId").toString());
       Integer count = Integer.valueOf(ctx.getActionContext("count").toString());
       storageMapper.updateFrozenToUsed(productId,count);
       //如果提交失败,或提交出现异常
        return true;
    }
    @Transactional
    @Override
    public boolean rollback(BusinessActionContext ctx) {
        Long productId = Long.valueOf(ctx.getActionContext("productId").toString());
        Integer count = Integer.valueOf(ctx.getActionContext("count").toString());
        storageMapper.updateFrozenToResidue(productId,count);
        return true;
    }
}

启动 storage 进行测试

按顺序启动服务：

Eureka
Seata Server
Easy Id Generator
Storage
Order
调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100
观察 storage 的控制台日志：

切记不管是seata-at,还是seata-tcc,在启动时都要启动seata-server

storage添加“减少库存”分支事务

在库存项目中执行减少库存：

配置

有三个文件需要配置：

application.yml
registry.conf
file.conf

这三个文件的设置与上面 order 项目的配置完全相同，请参考上面订单配置一章进行配置

StorageMapper 添加冻结库存相关方法

根据前面的分析，库存数据操作有以下三项：

冻结库存
冻结库存量修改为已售出量
解冻库存

在 StorageMapper 中添加三个方法：

package cn.tedu.storage.mapper;

import cn.tedu.storage.entity.Storage;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

public interface StorageMapper extends BaseMapper<Storage> {
    void decrease(Long productId, Integer count);
    //查询库存
    Storage selectByProductId(Long productId);
    //冻结库存 可用--->冻结
    void updateResidueToFrozen(Long productId,Integer count);
    //冻结--> 已使用库存
    void updateFrozenToUsed(Long productId,Integer count);
    // 冻结-->可用(恢复可用)
    void updateFrozenToResidue(Long productId,Integer count);
}

那么对应的 StorageMapper.xml 中也要添加 sql：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.tedu.storage.mapper.StorageMapper" >
    <resultMap id="BaseResultMap" type="Storage" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="product_id" property="productId" jdbcType="BIGINT" />
        <result column="total" property="total" jdbcType="INTEGER" />
        <result column="used" property="used" jdbcType="INTEGER" />
        <result column="residue" property="residue" jdbcType="INTEGER" />
    </resultMap>
    <update id="decrease">
        UPDATE storage
        SET used = used + #{count},
            residue = residue - #{count}
        WHERE product_id = #{productId}
    </update>
    <select id="selectByProductId" resultMap="BaseResultMap">
        select * from storage WHERE product_id = #{productId}
    </select>
    <update id="updateResidueToFrozen">
        update storage
        set Residue=Residue-#{count}, Frozen=Frozen+#{count} WHERE product_id = #{productId}
    </update>
    <update id="updateFrozenToUsed">
        update storage
        set Frozen=Frozen-#{count}, Used=Used+#{count} WHERE product_id = #{productId}
    </update>
    <update id="updateFrozenToResidue">
        update storage
        set Frozen=Frozen-#{count}, Residue=Residue+#{count} WHERE product_id = #{productId}
    </update>

</mapper>

Seata 实现库存的 TCC 操作方法

工具类 ResultHolder：

package cn.tedu.storage.tcc;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ResultHolder {
    private static Map<Class<?>, Map<String, String>> map = new ConcurrentHashMap<Class<?>, Map<String, String>>();

    public static void setResult(Class<?> actionClass, String xid, String v) {
        Map<String, String> results = map.get(actionClass);

        if (results == null) {
            synchronized (map) {
                if (results == null) {
                    results = new ConcurrentHashMap<>();
                    map.put(actionClass, results);
                }
            }
        }

        results.put(xid, v);
    }

    public static String getResult(Class<?> actionClass, String xid) {
        Map<String, String> results = map.get(actionClass);
        if (results != null) {
            return results.get(xid);
        }

        return null;
    }

    public static void removeResult(Class<?> actionClass, String xid) {
        Map<String, String> results = map.get(actionClass);
        if (results != null) {
            results.remove(xid);
        }
    }
}

添加 TCC 接口，在接口中添加以下方法：(在o

Try - prepareDecreaseStorage()
Confirm - commit()
Cancel - rollback()

package cn.tedu.storage.tcc;

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

    @TwoPhaseBusinessAction(name = "StorageTccAction")
    boolean prepare(BusinessActionContext ctx,
                    @BusinessActionContextParameter(paramName = "productId") Long productId,
                    @BusinessActionContextParameter(paramName = "count") Integer count);
    boolean commit(BusinessActionContext ctx);
    boolean rollback(BusinessActionContext ctx);


}

实现类：

package cn.tedu.storage.tcc;

import cn.tedu.storage.entity.Storage;
import cn.tedu.storage.mapper.StorageMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

@Component
public class StorageTccActionImpl implements StorageTccAction {
    @Autowired
    private StorageMapper storageMapper;
    @Transactional
    @Override
    public boolean prepare(BusinessActionContext ctx, Long productId, Integer count) {
        //先查询库存,判断有没有足够的库存
        //第一阶段成功时,添加一阶段成功的标记
        ResultHolder.setResult(StorageTccAction.class,ctx.getXid(),"P");//给予第一个阶段的成功唯一id==p
        Storage storage = storageMapper.selectByProductId(productId);
        if(storage.getResidue()<count){
            throw  new RuntimeException("库存不足");
        }
        




        
        //冻结库存
        storageMapper.updateResidueToFrozen(productId,count);
        return true;
    }
   @Transactional
    @Override
    public boolean commit(BusinessActionContext ctx) {
       //检查一阶段成功标记是否存在,不存在二阶段不再重复的执行
       if(ResultHolder.getResult(StorageTccAction.class,ctx.getXid())==null){
           return true;
       }
       Long productId = Long.valueOf(ctx.getActionContext("productId").toString());
       Integer count = Integer.valueOf(ctx.getActionContext("count").toString());
       storageMapper.updateFrozenToUsed(productId,count);
       // 二阶段执行成功时,删除标记
       ResultHolder.removeResult(StorageTccAction.class,ctx.getXid());
       //如果提交失败,或提交出现异常
        return true;
    }
    @Transactional
    @Override
    public boolean rollback(BusinessActionContext ctx) {
        //检查一阶段成功标记是否存在,不存在二阶段不再重复的执行
        if(ResultHolder.getResult(StorageTccAction.class,ctx.getXid())==null){
            return true;
        }
        Long productId = Long.valueOf(ctx.getActionContext("productId").toString());
        Integer count = Integer.valueOf(ctx.getActionContext("count").toString());
        storageMapper.updateFrozenToResidue(productId,count);
        // 二阶段执行成功时,删除标记
        ResultHolder.removeResult(StorageTccAction.class,ctx.getXid());
        return true;
    }
}

在业务代码中调用 Try 阶段方法

业务代码中调用 TCC 第一阶段方法prepareDecreaseStorage()，并添加全局事务注解 @GlobalTransactional：

package cn.tedu.storage.service;
import cn.tedu.storage.mapper.StorageMapper;
import cn.tedu.storage.tcc.StorageTccAction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StorageServiceImpl extends StorageService {
    @Autowired
    private StorageTccAction tcc;
    @Override
    public void decrease(Long productId, Integer count) {
        //不直接减库存的业务,而是冻结库存
        /**
         * 这里可以给null 是因为前端码会自动生成上下文
         */

        tcc.prepare(null,productId,count);
    }
}

启动 storage 进行测试

按顺序启动服务：

启动seata server
Eureka
Seata Server
Easy Id Generator
Storage
Order

启动seata server

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

观察 storage 的控制台日志：

查看数据库表中的库存数据：

account添加“扣减金额”分支事务

配置

有三个文件需要配置：

application.yml
registry.conf
file.conf

这三个文件的设置与上面 order 项目的配置完全相同，请参考上面订单配置一章进行配置。

AccountMapper 添加冻结库存相关方法

根据前面的分析，库存数据操作有以下三项：

冻结库存
冻结库存量修改为已售出量
解冻库存

在 AccountMapper 中添加三个方法

package cn.tedu.account.mapper;

import cn.tedu.account.entity.Account;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import java.math.BigDecimal;

public interface AccountMapper extends BaseMapper<Account> {
    //扣减账户金额
    void decrease(Long userId, BigDecimal money);
    //查询帐户,用业判断是否有足够可用金额
    Account selectByUserId(Long userId);
    //可用 ---> 冻结
    void updateResidueToFrozen(Long userId, BigDecimal money);
    //冻结 ---> 已使用
    void updateFrozenToUsed(Long userId, BigDecimal money);
    //冻结 ---> 可用
    void updateFrozenToResidue(Long userId, BigDecimal money);
}

那么对应的 AccountMapper.xml 中添加 sql：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="cn.tedu.account.mapper.AccountMapper" >
    <resultMap id="BaseResultMap" type="Account" >
        <id column="id" property="id" jdbcType="BIGINT" />
        <result column="user_id" property="userId" jdbcType="BIGINT" />
        <result column="total" property="total" jdbcType="DECIMAL" />
        <result column="used" property="used" jdbcType="DECIMAL" />
        <result column="residue" property="residue" jdbcType="DECIMAL"/>
        <result column="frozen" property="frozen" jdbcType="DECIMAL"/>
    </resultMap>
    <update id="decrease">
        UPDATE account
        SET residue = residue - #{money},
            used = used + #{money}
        where user_id = #{userId}
    </update>

<select id="selectByUserId" resultMap="BaseResultMap">
select * from account where user_id = #{userId}
</select>
<update id="updateResidueToFrozen">
update  account set Residue =Residue-#{money},Frozen=Frozen+#{money}
 where user_id = #{userId}
</update>
<update id="updateFrozenToUsed">
update  account set Frozen =Frozen-#{money},Used=Used+#{money}
 where user_id = #{userId}
</update>
<update id="updateFrozenToResidue">
update  account set Frozen =Frozen-#{money},Residue=Residue+#{money}
 where user_id = #{userId}

</update>
</mapper>

Seata 实现库存的 TCC 操作方法

工具类 ResultHolder：

package cn.tedu.account.tcc;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class ResultHolder {
    private static Map<Class<?>, Map<String, String>> map = new ConcurrentHashMap<Class<?>, Map<String, String>>();

    public static void setResult(Class<?> actionClass, String xid, String v) {
        Map<String, String> results = map.get(actionClass);

        if (results == null) {
            synchronized (map) {
                if (results == null) {
                    results = new ConcurrentHashMap<>();
                    map.put(actionClass, results);
                }
            }
        }

        results.put(xid, v);
    }

    public static String getResult(Class<?> actionClass, String xid) {
        Map<String, String> results = map.get(actionClass);
        if (results != null) {
            return results.get(xid);
        }

        return null;
    }

    public static void removeResult(Class<?> actionClass, String xid) {
        Map<String, String> results = map.get(actionClass);
        if (results != null) {
            results.remove(xid);
        }
    }
}

添加 TCC 接口，在接口中添加以下方法：

Try - prepareDecreaseAccount()
Confirm - commit()
Cancel - rollback()

package cn.tedu.account.tcc;

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 AccountTccAction {
    @TwoPhaseBusinessAction(name = "AccountTccAction")
    boolean prepare(BusinessActionContext ctx,
                    @BusinessActionContextParameter(paramName = "userId") Long userId,
                    @BusinessActionContextParameter(paramName = "money") BigDecimal money);
    boolean commit(BusinessActionContext ctx);
    boolean rollback(BusinessActionContext ctx);
}

实现类：

package cn.tedu.account.tcc;

import cn.tedu.account.entity.Account;
import cn.tedu.account.mapper.AccountMapper;
import io.seata.rm.tcc.api.BusinessActionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;

@Component
public class AccountTccActionImpl implements AccountTccAction {
    @Autowired
    private AccountMapper accountMapper;

    @Transactional
    @Override
    public boolean prepare(BusinessActionContext ctx, Long userId, BigDecimal money) {
        Account account = accountMapper.selectByUserId(userId);
        if(account.getResidue().compareTo(money)<0){
            throw new RuntimeException("可用金额不足");
        }
        accountMapper.updateResidueToFrozen(userId,money);
        ResultHolder.setResult(AccountTccAction.class,ctx.getXid(),"p");

        return true;
    }
    @Transactional
    @Override
    public boolean commit(BusinessActionContext ctx) {
        if(ResultHolder.getResult(AccountTccAction.class,ctx.getXid())==null){
            return true;
        }
        Long userId = Long.valueOf(ctx.getActionContext("userId").toString());
        BigDecimal money =new BigDecimal(ctx.getActionContext("money").toString());
        accountMapper.updateFrozenToUsed(userId,money);
        ResultHolder.removeResult(AccountTccAction.class,ctx.getXid());
        return true;
    }
    @Transactional
    @Override
    public boolean rollback(BusinessActionContext ctx) {
        if(ResultHolder.getResult(AccountTccAction.class,ctx.getXid())==null){
            return true;
        }
        Long userId = Long.valueOf(ctx.getActionContext("userId").toString());
        BigDecimal money =new BigDecimal(ctx.getActionContext("money").toString());
        accountMapper.updateFrozenToResidue(userId,money);
        ResultHolder.removeResult(AccountTccAction.class,ctx.getXid());
        return true;
    }
}

在业务代码中调用 Try 阶段方法

业务代码中调用 TCC 第一阶段方法prepareDecreaseAccount()，并添加全局事务注解 @GlobalTransactional：

package cn.tedu.account.service;

import cn.tedu.account.mapper.AccountMapper;
import cn.tedu.account.tcc.AccountTccAction;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
@Service
public class AccountServiceImpl implements AccountService {
//    @Autowired
//    private AccountMapper accountMapper;
    @Autowired
    private AccountTccAction tcc;

    @Override
    public void decrease(Long userId, BigDecimal money) {
        tcc.prepare(null,userId,money);//这个可以给null,是因为aop已经自动创建了对象
    }
}

启动 account 进行测试

按顺序启动服务：

Eureka
Seata Server#####这个小窗口中启动,前面说明了
Easy Id Generator
Storage
Account
Order

调用保存订单，地址：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

观察 account 的控制台日志：

查看数据库表中的账户数据：

全局事务回滚测试

下面来测试全局事务回滚的情况。

订单和库存第一阶段成功，而账户第一阶段失败了，这时会触发全局事务的回滚，如下图所示：

首先在 account 的第一阶段代码中添加模拟异常：

AccountTccActionImpl 的 prepareDecreaseAccount 方法

@Transactional
    @Override
    public boolean prepareDecreaseAccount(BusinessActionContext businessActionContext, Long userId, BigDecimal money) {
        log.info("减少账户金额，第一阶段锁定金额，userId="+userId+"， money="+money);

        Account account = accountMapper.selectById(userId);
        if (account.getResidue().compareTo(money) < 0) {
            throw new RuntimeException("账户金额不足");
        }

        /*
        余额-money
        冻结+money
         */
        accountMapper.updateFrozen(userId, account.getResidue().subtract(money), account.getFrozen().add(money));

        if (Math.random() < 0.5) {
            throw new RuntimeException("模拟异常");
        }

        //保存标识
        ResultHolder.setResult(getClass(), businessActionContext.getXid(), "p");
        return true;
    }

重启 account 后，访问订单：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100

查看控制台，可以看到 storage 和 order 的回滚日志，order 的回滚日志如下

项目源码:微儿VR/seata-tcc