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 事务操作的代码:
T
ry - 第一阶,冻结数据阶段,向订单表直接插入订单,订单状态设置为0(冻结状态)。
C
onfirm - 第二阶段,提交事务,将订单状态修改成1(正常状态)。
C
ancel - 第二阶段,回滚事务,删除订单。
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 事务操作的代码:
T
ry - 第一阶,冻结数据阶段,将要减少的库存量先冻结:
C
onfirm - 第二阶段,提交事务,使用冻结的库存完成业务数据处理:
C
ancel - 第二阶段,回滚事务,冻结的库存解冻,恢复以前的库存量:
配置
有三个文件需要配置:
- 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