分布式事务

分布式事务

随着互联网的快速发展，软件系统由原来的单体应用转变为分布式应用。

分布式系统会把一个应用拆分为可独立部署的多个服务，因此需要服务与服务之间远程协作才能完成事务操作，这种分布式系统环境下由不同的服务之间通过网络远程协作完成事务称之为分布式事务，例如用户注册送积分事务，创建订单减库存事务，银行转账事务等都是分布式事务。

我们知道本地事务依赖数据库本身提供的事务特性来实现，因为以下逻辑可以控制本地事务：

begin transaction:
    //1.本地数据库操作：张三减少金额
    //2.本地数据库操作：李四增加金额
commit transation;

但是在分布式环境下，会变成下边这样：

begin transaction:
    //1.本地数据库操作：张三减少金额
    //2.远程调用：让李四增加金额
commit transation;

可以设想，当远程调用让李四增加金额成功了，由于网络问题远程调用并没有返回，此时本地事务提交失败就回滚了张三减少金额的操作，此时张三和李四的数据就不一致了。

因此在分布式架构的基础上，传统数据库事务就无法使用了，张三和李四的账户不在一个数据库甚至不在一个应用系统里，实现转账事务需要通过远程调用，由于网络问题就会导致分布式事务问题。

分布式事务产生的场景

1.典型的场景就是微服务架构

        经典的订单服务和库存服务

2.单体系统访问多个数据库实例

3.多服务访问同一个数据库实例

分布式事务基础理论

CAP理论

CAP是Consistency、Availability、Partition tolerance三个词语的缩写，分别表示一致性、可用性、分区容错性

Consistency

一致性是指写操作后的读操作可以读到最新的数据状态，当数据分布在多个节点上，从任意节点读取到的数据都是最新的状态。

 上图中，商品信息的读写要满足一致性就是实现如下目标：

1.商品服务写入主数据库成功，则向从数据库查询数据也成功

2.商品服务写入主数据库失败，则向从数据库中查询数据也失败

如何实现一致性？

1、写入主数据库要将数据同步到从数据库

2、写入主数据库后，在向从数据库同步期间要将从数据库锁定，待同步完成后再释放锁，以免在新数据写入成功后，向从数据库查询到旧的数据。

分布式系统一致性的特点：

1、由于存在数据同步的过程，写操作的响应会有一定的延迟。

2、为了保证数据一致性会对资源暂时锁定，待数据同步完成释放锁定资源。

3、如果请求数据同步失败的节点则会返回错误信息，一定不会返回旧数据

Availability

 可用性是指任何事物操作都可以得到响应结果，且不会出现响应超时或响应错误

上图中，商品信息读取满足可用性就是要实现如下目标：

1、从数据库接收到数据查询的请求则立即能够响应数据查询结果

2、从数据库不允许出现响应超时或响应错误

如何实现可用性？
1、写入主数据后要将数据同步到从数据库

2、由于要保证从数据库的可用性，不可将从数据库的资源进行锁定

3、即时数据还没有同步过来，从数据库也要返回查询的数据，哪怕是旧数据，如果连旧数据也没有则可以按照约定返回一个默认信息，但不能返回错误或响应超时。

分布式系统可用性的特点：

1、所有请求都有响应，且不会出现响应超时响应错误 

Partition tolerance

通常分布式系统的各个节点不是在不同的子网，这就是网络分区，不可避免的会出现由于网络问题而导致节点之间通信失败，此时仍可对外提供服务服务，这叫分区容忍性。

上图中，商品信息读写满足分区容忍性就是要实现如下目标：

1、主数据库向从数据库同步数据失败不影响读写操作

2、其一个结点挂掉不影响另一个结点对外提供服务。

如何实现分区容忍性？

1、尽量使用异步取代同步操作，例如使用异步方式将数据从主数据库同步到从数据库，这样结点之间能有效的实现松耦合。

2、添加从数据库节点，其中一个从节点挂掉其他从节点提供服务。

分布式分区容忍性的特点：

1、分区容忍性是分布式系统具备的基本能力，也就是说分布式系统必须有P

CAP组合方式

在所有分布式事务场景中不会同时具备CAP三个特性，因为在具备了P的前提下C和A是不能共存的。

AP：

放弃一致性，追求分区容忍性和可用性，这是很多分布式系统设计时的选择。

例如：

上边的商品管理，完全可以实现AP，前提是只要用户可以接受所查询的数据在一定时间内不是最新的即可。

通常实现AP都会保证最终一致性，后面的BASE理论就是根据AP来扩展的，一些业务场景 比如：订单退款，今日退款成功，明日账户到账，只要用户可以接受在一定时间内到账即可。

CP:

放弃可用性，追求一致性和分区容错性，我们的zookeeper其实就是追求的强一致，又比如跨行转账，一次转账请求要等待双方银行都完成整个事务才算完成。

CA:

放弃分区容忍性，即不进行分区，不考虑由于网络不通或节点挂掉的问题，则可以实现一致性和可用性，那么系统将不是一个标准的分布式系统，我们最常用的关系型数据库就满足了CA

上边的商品管理，如果要实现CA则架构如下：

BASE理论介绍

BASE是Basically Available(基本可用) 、Soft state(软状态)、Eventually consistent(最终一致性)三个短语的缩写。BASE理论是对CAP中AP的一个扩展，通过牺牲强一致性来获得可用性，当出现故障允许部分不可用但要保证核心功能可用，允许数据在一段时间内是不一致的，但最终达到一致状态，满足BASE理论的事务，我们称之为“柔性事务”

•基本可用：分布式系统在出现故障时，允许损失部分可用功能，保证核心功能可用。如：电商网站交易付款出现问题了，商品依然可以正常浏览。

•软状态：由于不要求强一致性，所以BASE允许系统中存在中间状态，也叫软状态。这个状态不影响系统可用性，如订单的支付中，数据同步中等状态，待数据最终一致后状态改为成功状态

•最终一致：最终一致是指经过一段时间后，所有节点数据都将会达到一致，如订单的支付中状态，最终会变为支付成功或者支付失败，使订单与实际交易结果达成一致，但需要一定时间的延迟、等待。

分布式事务解决方案之2PC(两阶段提交)

2PC即两阶段提交协议，是将整个事务流程分为两个阶段，准备阶段(Prepare phase)，提交阶段（commit phase）2是指两个阶段、P是指准备阶段、C是指提交阶段

举例：张三和李四好久不见，老友约起聚餐，饭店老板要求先买单，才能出票。这时张三和李四分别抱怨近况不如意，囊中羞涩，都不愿意请客，这时只能AA。只有张三和李四都付款，老板才能出票安排就餐。但由于张三和李四都是铁公鸡，形成了尴尬的一幕：

准备阶段：老板要求张三付款，张三付款。老板要求李四付款，李四付款。

提交阶段：老板出票，两人拿票纷纷落座就餐。

例子中形成了一个事务，若张三或李四其中一人拒绝付款，或钱不够，店老板都不会给出票，并且会把已收款退回。

整个事务过程由事务管理器和参与者组成，店老板就是事务管理器，张三、李四就是事务参与者，事务管理器负责决策整个分布式事务的提交和回滚，事务参与者负责自己本地事务的提交和回滚。

在计算机中部分关系数据库如Oracle、MySQL支持两阶段提交协议，如下图：

1.准备阶段（Prepare phase）：事务管理器给每个参与者发送Prepare消息，每个数据库参与者在本地执行事务，并写本地的Undo/Redo日志，此时事务没有提交。

（Undo日志是记录修改前的数据，用于数据库回滚，Redo日志是记录修改后的数据，用于提交事务后写入数据文件）

2.提交阶段（commit phase）:如果事务管理器收到了参与者的执行失败或者超时消息时，直接给每个参与者发送回滚（Rollback）消息；否则，发送提交（commit）消息;参与者根据事务管理器的指令执行提交或者回滚操作，并释放事务处理过程中使用的锁资源。注意：必须在最后阶段释放锁·资源。 

成功情况：

 

Seata方案：

Seata是由阿里中间件团队发起的开源项目。它是一个开源的分布式事务框架。传统2PC的问题在Seata中得到了解决，它通过对本地关系数据库的分支事务的协调来驱动完成全局事务，是工作在应用层的中间件。主要优点是性能较好，且不长时间占用连接资源，它以高效并且对业务0侵入的方式解决微服务场景下面临的分布式事务问题，它目前提供了AT模式(即2PC)及TCC模式的分布式就事务解决方案。

Seata的设计思想如下：

        Seata的设计目标其一是对业务无侵入，因为从业务无侵入的2PC方案着手，在传统的2PC的基础上演进，并解决2PC方案面临的问题。

        Seata把一个分布式事务理解成一个包含了若干分支事务的全局事务。全局事务的职责是协调其下管辖的分支事务达成一致，要么一起成功提交，要么一起失败回滚。此外，通常分支事务本身就是一个关系数据库的本地事务，下面是全局事务与分支事务的关系图：

与 传统 2PC 的模型类似， Seata 定义了 3 个组件来协议分布式事务的处理过程：

Version:0.9 StartHTML:0000000105 EndHTML:0000002864 StartFragment:0000000141 EndFragment:0000002824

Transaction Coordinator (TC) ： 事务协调器，它是独立的中间件，需要独立部署运行，它维护全局事务的运

行状态，接收 TM 指令发起全局事务的提交与回滚，负责与 RM 通信协调各各分支事务的提交或回滚。

Transaction Manager (TM) ： 事务管理器， TM 需要嵌入应用程序中工作，它负责开启一个全局事务，并最终

向 TC 发起全局提交或全局回滚的指令。

Resource Manager (RM) ： 控制分支事务，负责分支注册、状态汇报，并接收事务协调器 TC 的指令，驱动分

支（本地）事务的提交和回滚。

具体的执行流程如下：

1. 用户服务的 TM 向 TC 申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的 XID 。

2. 用户服务的 RM 向 TC 注册 分支事务，该分支事务在用户服务执行新增用户逻辑，并将其纳入 XID 对应全局

事务的管辖。

3. 用户服务执行分支事务，向用户表插入一条记录。

4. 逻辑执行到远程调用积分服务时 (XID 在微服务调用链路的上下文中传播 ) 。积分服务的 RM 向 TC 注册分支事

务，该分支事务执行增加积分的逻辑，并将其纳入 XID 对应全局事务的管辖。

5. 积分服务执行分支事务，向积分记录表插入一条记录，执行完毕后，返回用户服务。

6. 用户服务分支事务执行完毕。

7. TM 向 TC 发起针对 XID 的全局提交或回滚决议。

8. TC 调度 XID 下管辖的全部分支事务完成提交或回滚请求。

Seata 实现 2PC 与传统 2PC 的差别 ：

架构层次方面， 传统 2PC 方案的 RM 实际上是在数据库层， RM 本质上就是数据库自身，通过 XA 协议实现，而

Seata 的 RM 是以 jar 包的形式作为中间件层部署在应用程序这一侧的。

两阶段提交方面， 传统 2PC 无论第二阶段的决议是 commit 还是 rollback ，事务性资源的锁都要保持到 Phase2 完成才释放。而Seata 的做法是在 Phase1 就将本地事务提交，这样就可以省去 Phase2 持锁的时间，整体提高效率。

 

3.3.seata 实现 2PC 事务

3.3.1. 业务说明

本示例通过 Seata 中间件实现分布式事务，模拟三个账户的转账交易过程。

两个账户在三个不同的银行 ( 张三在 bank1 、李四在 bank2) ， bank1 和 bank2 是两个个微服务。交易过程是，张三

给李四转账指定金额。 上述交易步骤，要么一起成功，要么一起失败，必须是一个整体性的事务。

 

 环境搭建不赘述了 可以自己去看下官网

主要是创建代理数据源

新增 DatabaseConfifiguration.java ， Seata 的 RM 通过 DataSourceProxy 才能在业务代码的事务提交时，通过这个切

入点，与 TC 进行通信交互、记录 undo_log 等。

@Configuration 
public class DatabaseConfiguration { 

    @Bean 
    @ConfigurationProperties(prefix = "spring.datasource.ds0") 
    public DruidDataSource ds0() { 
    DruidDataSource druidDataSource = new DruidDataSource();
    return druidDataSource;
}

3.3.7 Seata 执行流程

1 、正常提交流程

2 、回滚流程

回滚流程省略前的 RM 注册过程。

要点说明：

1 、每个 RM 使用 DataSourceProxy 连接数据库，其目的是使用 ConnectionProxy ，使用数据源和数据连接代理的目的就是在第一阶段将undo_log 和业务数据放在一个本地事务提交，这样就保存了只要有业务操作就一定有undo_log。

2 、在第一阶段 undo_log 中存放了数据修改前和修改后的值，为事务回滚作好准备，所以第一阶段完成就已经将分支事务提交，也就释放了锁资源。

3 、 TM 开启全局事务开始，将 XID 全局事务 id 放在事务上下文中，通过 feign 调用也将 XID 传入下游分支事务，每个分支事务将自己的Branch ID 分支事务 ID 与 XID 关联。

4 、第二阶段全局事务提交， TC 会通知各各分支参与者提交分支事务，在第一阶段就已经提交了分支事务，这里各各参与者只需要删除undo_log 即可，并且可以异步执行，第二阶段很快可以完成。

5 、第二阶段全局事务回滚， TC 会通知各各分支参与者回滚分支事务，通过 XID 和 Branch ID 找到相应的回滚日 志，通过回滚日志生成反向的 SQL 并执行，以完成分支事务回滚到之前的状态，如果回滚失败则会重试回滚操作。

 

3.3.8 dtx-seata-demo-bank1

dtx-seata-demo-bank1 实现如下功能：

1 、张三账户减少金额，开启全局事务。

2 、远程调用 bank2 向李四转账。

（ 1 ） DAO

@Mapper
@Component
public interface AccountInfoDao {
//更新账户金额
@Update("update account_info set account_balance = account_balance + #{amount} where
account_no = #{accountNo}")
int updateAccountBalance(@Param("accountNo") String accountNo, @Param("amount") Double
amount);
}

（ 2 ） FeignClient

远程调用 bank2 的客户端

@FeignClient(value = "seata‐demo‐bank2",fallback = Bank2ClientFallback.class)
public interface Bank2Client {

@GetMapping("/bank2/transfer")
String transfer(@RequestParam("amount") Double amount);
}


@Component
public class Bank2ClientFallback implements Bank2Client{
@Override
public String transfer(Double amount) {
return "fallback";
}
}

（ 3 ） Service

@Service
public class AccountInfoServiceImpl implements AccountInfoService {
private Logger logger = LoggerFactory.getLogger(AccountInfoServiceImpl.class);
@Autowired
AccountInfoDao accountInfoDao;
@Autowired
Bank2Client bank2Client;
//张三转账
@Override
@GlobalTransactional
@Transactional
public void updateAccountBalance(String accountNo, Double amount) {
logger.info("******** Bank1 Service Begin ... xid: {}" , RootContext.getXID());
//张三扣减金额
accountInfoDao.updateAccountBalance(accountNo,amount*‐1);
//向李四转账
String remoteRst = bank2Client.transfer(amount);
//远程调用失败
if(remoteRst.equals("fallback")){
throw new RuntimeException("bank1 下游服务异常");
}
//人为制造错误
if(amount==3){
throw new RuntimeException("bank1 make exception 3");
}
}
}

将@GlobalTransactional注解标注在全局事务发起的Service实现方法上，开启全局事务：

GlobalTransactionalInterceptor 会拦截 @GlobalTransactional 注解的方法，生成全局事务 ID(XID) ， XID 会在整个

分布式事务中传递。 在远程调用时，spring-cloud-alibaba-seata 会拦截 Feign 调用将 XID 传递到下游服务。 （ 6 ）

Controller
@RestController
public class Bank1Controller {
@Autowired
AccountInfoService accountInfoService;
//转账
@GetMapping("/transfer")
public String transfer(Double amount){
accountInfoService.updateAccountBalance("1",amount);
return "bank1"+amount;
}
}

3.3.9 dtx-seata-demo-bank2

dtx-seata-demo-bank2 实现如下功能：

1 、李四账户增加金额。

dtx-seata-demo-bank2 在本账号事务中作为分支事务不使用 @GlobalTransactional 。

（ 1 ） DAO

@Mapper
@Component
public interface AccountInfoDao {
//向李四转账
@Update("UPDATE account_info SET account_balance = account_balance + #{amount} WHERE
account_no = #{accountNo}")
int updateAccountBalance(@Param("accountNo") String accountNo, @Param("amount") Double
amount);
}

（2 ） Service

@Service
public class AccountInfoServiceImpl implements AccountInfoService {
private Logger logger = LoggerFactory.getLogger(AccountInfoServiceImpl.class);
@Autowired
AccountInfoDao accountInfoDao;
@Override
@Transactionalpublic void updateAccountBalance(String accountNo, Double amount) {
logger.info("******** Bank2 Service Begin ... xid: {}" , RootContext.getXID());
//李四增加金额
accountInfoDao.updateAccountBalance(accountNo,amount);
//制造异常
if(amount==2){
throw new RuntimeException("bank1 make exception 2");
}
}
}

（3）Controller

@RestController

public class Bank2Controller {

@Autowired
AccountInfoService accountInfoService;
@GetMapping("/transfer")
public String transfer(Double amount){
accountInfoService.updateAccountBalance("2",amount);
return "bank2"+amount;
}
}

3.3.10 测试场景

张三向李四转账成功。

李四事务失败，张三事务回滚成功。

张三事务失败，李四事务回滚成功。

分支事务超时测试。

3.4. 小结

本节讲解了传统 2PC （基于数据库 XA 协议）和 Seata 实现 2PC 的两种 2PC 方案，由于 Seata 的 0 侵入性并且解决了传

统 2PC 长期锁资源的问题，所以推荐采用 Seata 实现 2PC 。

Seata 实现 2PC 要点：

1 、全局事务开始使用 @GlobalTransactional 标识 。

2 、每个本地事务方案仍然使用 @Transactional 标识。

3 、每个数据都需要创建 undo_log 表，此表是 seata 保证本地事务一致性的关键。

4. 分布式事务解决方案之 TCC

4.1. 什么是 TCC 事务

TCC 是 Try 、 Confifirm 、 Cancel 三个词语的缩写， TCC 要求每个分支事务实现三个操作：预处理 Try 、确认

Confifirm 、撤销 Cancel 。 Try 操作做业务检查及资源预留， Confifirm 做业务确认操作， Cancel 实现一个与 Try 相反的

操作即回滚操作。 TM 首先发起所有的分支事务的 try 操作，任何一个分支事务的 try 操作执行失败， TM 将会发起所

有分支事务的 Cancel 操作，若 try 操作全部成功， TM 将会发起所有分支事务的 Confifirm 操作，其中 Confifirm/Cancel

操作若执行失败， TM 会进行重试。

 Version:0.9 StartHTML:0000000105 EndHTML:0000010827 StartFragment:0000000141 EndFragment:0000010787

TCC 分为三个阶段：

1. Try 阶段是做业务检查 ( 一致性 ) 及资源预留 ( 隔离 ) ，此阶段仅是一个初步操作，它和后续的 Confifirm 一起才能 真正构成一个完整的业务逻辑。

2. Confifirm 阶段是做确认提交， Try 阶段所有分支事务执行成功后开始执行 Confifirm 。通常情况下，采用 TCC 则 认为 Confifirm 阶段是不会出错的。即：只要 Try 成功， Confifirm 一定成功。若 Confifirm 阶段真的出错了，需引 入重试机制或人工处理。

3. Cancel 阶段是在业务执行错误需要回滚的状态下执行分支事务的业务取消，预留资源释放。通常情况下，采用TCC 则认为 Cancel 阶段也是一定成功的。若 Cancel 阶段真的出错了，需引入重试机制或人工处理。

4. TM 事务管理器

TM 事务管理器可以实现为独立的服务，也可以让 全局事务发起方 充当 TM 的角色， TM 独立出来是为了成为公 用组件，是为了考虑系统结构和软件复用。

TM在发起全局事务时生成全局事务记录，全局事务 ID 贯穿整个分布式事务调用链条，用来记录事务上下文， 追踪和记录状态，由于Confifirm 和 cancel 失败需进行重试，因此需要实现为幂等，幂等性是指同一个操作无论请求 多少次，其结果都相同。

4.2.TCC 解决方案

上一节所讲的 Seata 也支持 TCC ，但 Seata 的 TCC 模式对 Spring Cloud 并没有提供支持。我们的目标是理解 TCC 的原理以及事务协调运作的过程，因此更请倾向于轻量级易于理解的框架，因此最终确定了Hmily 。

Hmily 是一个高性能分布式事务 TCC 开源框架。基于 Java 语言来开发（ JDK1.8 ），支持 Dubbo ， Spring Cloud 等 RPC框架进行分布式事务。它目前支持以下特性：

支持嵌套事务 (Nested transaction support).

采用 disruptor 框架进行事务日志的异步读写，与 RPC 框架的性能毫无差别。

支持 SpringBoot-starter 项目启动，使用简单。

RPC 框架支持 : dubbo,motan,springcloud 。

本地事务存储支持 : redis,mongodb,zookeeper,fifile,mysql 。

事务日志序列化支持 ： java ， hessian ， kryo ， protostuffff 。

采用 Aspect AOP 切面思想与 Spring 无缝集成，天然支持集群。

RPC 事务恢复，超时异常恢复等。

Hmily 利用 AOP 对参与分布式事务的本地方法与远程方法进行拦截处理，通过多方拦截，事务参与者能透明的

调用到另一方的 Try 、 Confifirm 、 Cancel 方法；传递事务上下文；并记录事务日志，酌情进行补偿，重试等。

Hmily 不需要事务协调服务，但需要提供一个数据库 (mysql/mongodb/zookeeper/redis/fifile) 来进行日志存

储。

Hmily 实现的 TCC 服务与普通的服务一样，只需要暴露一个接口，也就是它的 Try 业务。 Confifirm/Cancel 业务

逻辑，只是因为全局事务提交 / 回滚的需要才提供的，因此 Confifirm/Cancel 业务只需要被 Hmily TCC 事务框架

发现即可，不需要被调用它的其他业务服务所感知。

 

TCC 需要注意三种异常处理分别是空回滚、幂等、悬挂 :

空回滚 ：

在没有调用 TCC 资源 Try 方法的情况下，调用了二阶段的 Cancel 方法， Cancel 方法需要识别出这是一个空回

滚，然后直接返回成功。

出现原因是当一个分支事务所在服务宕机或网络异常，分支事务调用记录为失败，这个时候其实是没有执行 Try 阶

段，当故障恢复后，分布式事务进行回滚则会调用二阶段的 Cancel 方法，从而形成空回滚。

解决思路是关键就是要识别出这个空回滚。思路很简单就是需要知道一阶段是否执行，如果执行了，那就是正常回

滚；如果没执行，那就是空回滚。前面已经说过 TM 在发起全局事务时生成全局事务记录，全局事务 ID 贯穿整个分

布式事务调用链条。再额外增加一张分支事务记录表，其中有全局事务 ID 和分支事务 ID ，第一阶段 Try 方法里会

插入一条记录，表示一阶段执行了。 Cancel 接口里读取该记录，如果该记录存在，则正常回滚；如果该记录不存

在，则是空回滚。

幂等 ：

通过前面介绍已经了解到，为了保证 TCC 二阶段提交重试机制不会引发数据不一致，要求 TCC 的二阶段 Try 、

Confifirm 和 Cancel 接口保证幂等，这样不会重复使用或者释放资源。如果幂等控制没有做好，很有可能导致数据

不一致等严重问题。

解决思路在上述 “ 分支事务记录 ” 中增加执行状态，每次执行前都查询该状态。

悬挂 ：

悬挂就是对于一个分布式事务，其二阶段 Cancel 接口比 Try 接口先执行。

出现原因是在 RPC 调用分支事务 try 时，先注册分支事务，再执行 RPC 调用，如果此时 RPC 调用的网络发生拥堵，

通常 RPC 调用是有超时时间的， RPC 超时以后， TM 就会通知 RM 回滚该分布式事务，可能回滚完成后， RPC 请求

才到达参与者真正执行，而一个 Try 方法预留的业务资源，只有该分布式事务才能使用，该分布式事务第一阶段预

留的业务资源就再也没有人能够处理了，对于这种情况，我们就称为悬挂，即业务资源预留后没法继续处理。

解决思路是如果二阶段执行完成，那一阶段就不能再继续执行。在执行一阶段事务时判断在该全局事务下， “ 分支

事务记录 ” 表中是否已经有二阶段事务记录，如果有则不执行 Try 。

 

举例，场景为 A 转账 30 元给 B ， A 和 B 账户在不同的服务。

方案 1 ：

账户 A

try：检查余额是否够30元 扣减30元 
confirm： 空 
cancel：增加30元

账户 B

try：增加30元 
confirm： 空 
cancel：减少30元

方案 1 说明：

1 ）账户 A ，这里的余额就是所谓的业务资源，按照前面提到的原则，在第一阶段需要检查并预留业务资源，因此，

我们在扣钱 TCC 资源的 Try 接口里先检查 A 账户余额是否足够，如果足够则扣除 30 元。 Confifirm 接口表示正式

提交，由于业务资源已经在 Try 接口里扣除掉了，那么在第二阶段的 Confifirm 接口里可以什么都不用做。 Cancel

接口的执行表示整个事务回滚，账户 A 回滚则需要把 Try 接口里扣除掉的 30 元还给账户。

2 ）账号 B ，在第一阶段 Try 接口里实现给账户 B 加钱， Cancel 接口的执行表示整个事务回滚，账户 B 回滚则需要把

Try 接口里加的 30 元再减去。

方案 1 的问题分析：

1 ）如果账户 A 的 try 没有执行在 cancel 则就多加了 30 元。

2 ）由于 try ， cancel 、 confifirm 都是由单独的线程去调用，且会出现重复调用，所以都需要实现幂等。

3 ）账号 B 在 try 中增加 30 元，当 try 执行完成后可能会其它线程给消费了。

4 ）如果账户 B 的 try 没有执行在 cancel 则就多减了 30 元。

问题解决：

1 ）账户 A 的 cancel 方法需要判断 try 方法是否执行，正常执行 try 后方可执行 cancel 。

2 ） try ， cancel 、 confifirm 方法实现幂等。

3 ）账号 B 在 try 方法中不允许更新账户金额，在 confifirm 中更新账户金额。

4 ）账户 B 的 cancel 方法需要判断 try 方法是否执行，正常执行 try 后方可执行 cancel 。

优化方案 ：

账户 A

try：try幂等校验 try悬挂处理 检查余额是否够30元 扣减30元 
confirm： 空 
cancel：
cancel幂等校验 
cancel空回滚处理 
增加可用余额30元

账户 B

try：空 
confirm： 
confirm幂等校验 
正式增加30元 
cancel：空

4.3.Hmily 实现 TCC 事务

4.3.1. 业务说明

本实例通过 Hmily 实现 TCC 分布式事务，模拟两个账户的转账交易过程。

两个账户分别在不同的银行 ( 张三在 bank1 、李四在 bank2) ， bank1 、 bank2 是两个微服务。交易过程是，张三给

李四转账指定金额。

上述交易步骤，要么一起成功，要么一起失败，必须是一个整体性的事务。

4.3.2. 程序组成部分

数据库： MySQL-5.7.25

JDK ： 64 位 jdk1.8.0_201

微服务： spring-boot-2.1.3 、 spring-cloud-Greenwich.RELEASE

Hmily ： hmily-springcloud.2.0.4-RELEASE

微服务及数据库的关系 ：

dtx/dtx-tcc-demo/dtx-tcc-demo-bank1 银行 1 ，操作张三账户， 连接数据库 bank1

dtx/dtx-tcc-demo/dtx-tcc-demo-bank2 银行 2 ，操作李四账户，连接数据库 bank2

服务注册中心： dtx/discover-server

 

4.3.3. 创建数据库

 

导入数据库脚本：资料 \sql\bank1.sql 、资料 \sql\bank2.sql 、已经导过不用重复导入。

创建 hmily 数据库，用于存储 hmily 框架记录的数据。

CREATE DATABASE `hmily` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

创建 bank1 库，并导入以下表结构和数据 ( 包含张三账户 )

CREATE DATABASE `bank1` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

DROP TABLE IF EXISTS `account_info`; 
CREATE TABLE 
`account_info` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, 
`account_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '户 主姓名', 
`account_no` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '银行 卡号', 
`account_password` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '帐户密码', 
`account_balance` double NULL DEFAULT NULL COMMENT '帐户余额', 
PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Dynamic; INSERT INTO `account_info` VALUES (2, '张三的账户', '1', '', 10000);

创建 bank2 库，并导入以下表结构和数据 ( 包含李四账户 )

CREATE DATABASE `bank2` CHARACTER SET 'utf8' COLLATE 'utf8_general_ci';

CREATE TABLE 
`account_info` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, 
`account_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '户 主姓名', 
`account_no` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '银行 卡号', 
`account_password` varchar(100) CHARACTER SET utf8 COLLATE utf8_bin NULL DEFAULT NULL COMMENT '帐户密码', 
`account_balance` double NULL DEFAULT NULL COMMENT '帐户余额', PRIMARY KEY (`id`) USING BTREE ) ENGINE = InnoDB AUTO_INCREMENT = 5 CHARACTER SET = utf8 COLLATE = utf8_bin ROW_FORMAT = Dynamic; INSERT INTO `account_info` VALUES (3, '李四的账户', '2', NULL, 0);

每个数据库都创建 try 、 confifirm 、 cancel 三张日志表：

CREATE TABLE `local_try_log` ( `tx_no` varchar(64) NOT NULL COMMENT '事务id', `create_time` datetime DEFAULT NULL, PRIMARY KEY (`tx_no`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 
CREATE TABLE `local_confirm_log` ( `tx_no` varchar(64) NOT NULL COMMENT '事务id', `create_time` datetime DEFAULT NULL ) ENGINE=InnoDB DEFAULT CHARSET=utf8 
CREATE TABLE `local_cancel_log` ( `tx_no` varchar(64) NOT NULL COMMENT '事务id', `create_time` datetime DEFAULT NULL, PRIMARY KEY (`tx_no`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8

4.3.5 discover-server

discover-server 是服务注册中心，测试工程将自己注册至 discover-server 。

导入：资料 \ 基础代码 \dtx 父工程，此工程自带了 discover-server ， discover-server 基于 Eureka 实现。

已经导过不用重复导入。

4.3.6 导入案例工程 dtx-tcc-demo

dtx-tcc-demo 是 tcc 的测试工程，根据业务需求需要创建两个 dtx-tcc-demo 工程。

（ 1 ）导入 dtx-tcc-demo

导入：资料 \ 基础代码 \dtx-tcc-demo 到父工程 dtx 下。

两个测试工程如下：

dtx/dtx-tcc-demo/dtx-tcc-demo-bank1 银行 1 ，操作张三账户，连接数据库 bank1

dtx/dtx-tcc-demo/dtx-tcc-demo-bank2 银行 2 ，操作李四账户，连接数据库 bank2

 

（ 2 ）引入 maven 依赖

 

<dependency>
<groupId>org.dromara</groupId>
<artifactId>hmily‐springcloud</artifactId>
<version>2.0.4‐RELEASE</version>
</dependency>

（ 3 ）配置 hmily

application.yml ：

新增配置类接收 application.yml 中的 Hmily 配置信息，并创建 HmilyTransactionBootstrap Bean ：

 

 4.3.7 dtx-tcc-demo-bank1

dtx-tcc-demo-bank1 实现 try 和 cancel 方法，如下：

try ：

try 幂等校验

try 悬挂处理

检查余额是够扣减金额

扣减金额

confirm ：

空

cancel ：

cancel 幂等校验

cancel 空回滚处理

增加可用余额

1 ） Dao

hmilyTransactionBootstrap . setStarted ( Boolean . parseBoolean ( env . getProperty ( "org.dromara.hmily.st

arted" )));

HmilyDbConfig hmilyDbConfig = new HmilyDbConfig ();

hmilyDbConfig . setDriverClassName ( env . getProperty ( "org.dromara.hmily.hmilyDbConfig.driverClassNa

me" ));

hmilyDbConfig . setUrl ( env . getProperty ( "org.dromara.hmily.hmilyDbConfig.url" ));

hmilyDbConfig . setUsername ( env . getProperty ( "org.dromara.hmily.hmilyDbConfig.username" ));

hmilyDbConfig . setPassword ( env . getProperty ( "org.dromara.hmily.hmilyDbConfig.password" ));

hmilyTransactionBootstrap . setHmilyDbConfig ( hmilyDbConfig );

return hmilyTransactionBootstrap ;

}

@SpringBootApplication

@EnableDiscoveryClient

@EnableHystrix

@EnableFeignClients ( basePackages = { "cn.itcast.dtx.tccdemo.bank1.spring" })

@ComponentScan ({ "cn.itcast.dtx.tccdemo.bank1" , "org.dromara.hmily" })

public class Bank1HmilyServer {

public static void main ( String [] args ) {

SpringApplication . run ( Bank1HmilyServer . class , args );

}

} @Mapper

@Component

public interface AccountInfoDao {

@Update("update account_info set account_balance=account_balance ‐ #{amount} where

account_balance>#{amount} and account_no=#{accountNo} ")

int subtractAccountBalance(@Param("accountNo") String accountNo, @Param("amount") Double

amount);

@Update("update account_info set account_balance=account_balance + #{amount} where

account_no=#{accountNo} ")

int addAccountBalance(@Param("accountNo") String accountNo, @Param("amount") Double amount);

/**

* 增加某分支事务 try 执行记录

* @param localTradeNo 本地事务编号

* @return

*/

@Insert("insert into local_try_log values(#{txNo},now());")

int addTry(String localTradeNo);

@Insert("insert into local_confirm_log values(#{txNo},now());")

int addConfirm(String localTradeNo);

@Insert("insert into local_cancel_log values(#{txNo},now());")

int addCancel(String localTradeNo);

/**

* 查询分支事务 try 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_try_log where tx_no = #{txNo} ")

int isExistTry(String localTradeNo);

/**

* 查询分支事务 confirm 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_confirm_log where tx_no = #{txNo} ")

int isExistConfirm(String localTradeNo);

/**

* 查询分支事务 cancel 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_cancel_log where tx_no = #{txNo} ")

int isExistCancel(String localTradeNo);

}

2 ） try 和 cancel 方法 @Service

@Slf4j

public class AccountInfoServiceImpl implements AccountInfoService {

private Logger logger = LoggerFactory.getLogger(AccountInfoServiceImpl.class);

@Autowired

private AccountInfoDao accountInfoDao;

@Autowired

private Bank2Client bank2Client;

@Override

@Transactional

@Hmily(confirmMethod = "commit", cancelMethod = "rollback")

public void updateAccountBalance(String accountNo, Double amount) {

// 事务 id

String transId = HmilyTransactionContextLocal.getInstance().get().getTransId();

log.info("******** Bank1 Service begin try... "+transId );

int existTry = accountInfoDao.isExistTry(transId);

//try 幂等校验

if(existTry>0){

log.info("******** Bank1 Service 已经执行 try ，无需重复执行，事务 id:{} "+transId );

return ;

}

//try 悬挂处理

if(accountInfoDao.isExistCancel(transId)>0 || accountInfoDao.isExistConfirm(transId)>0){

log.info("******** Bank1 Service 已经执行 confirm 或 cancel ，悬挂处理，事务 id:{} "+transId

);

return ;

}

// 从账户扣减

if(accountInfoDao.subtractAccountBalance(accountNo ,amount )<=0){

// 扣减失败

throw new HmilyRuntimeException("bank1 exception ，扣减失败，事务 id:{}"+transId);

}

// 增加本地事务 try 成功记录，用于幂等性控制标识

accountInfoDao.addTry(transId);

// 远程调用 bank2

if(!bank2Client.test2(amount,transId)){

throw new HmilyRuntimeException("bank2Client exception ，事务 id:{}"+transId);

}

if(amount==10){// 异常一定要抛在 Hmily 里面

throw new RuntimeException("bank1 make exception 10");

}

log.info("******** Bank1 Service end try... "+transId );

}

@Transactional

public void commit( String accountNo, double amount) {

String localTradeNo = HmilyTransactionContextLocal.getInstance().get().getTransId(); logger.info("******** Bank1 Service begin commit..."+localTradeNo );

}

@Transactional

public void rollback( String accountNo, double amount) {

String localTradeNo = HmilyTransactionContextLocal.getInstance().get().getTransId();

log.info("******** Bank1 Service begin rollback... " +localTradeNo);

if(accountInfoDao.isExistTry(localTradeNo) == 0){ // 空回滚处理， try 阶段没有执行什么也不用做

log.info("******** Bank1 try 阶段失败 ... 无需 rollback "+localTradeNo );

return;

}

if(accountInfoDao.isExistCancel(localTradeNo) > 0){ // 幂等性校验，已经执行过了，什么也不用做

log.info("******** Bank1 已经执行过 rollback... 无需再次 rollback " +localTradeNo);

return;

}

// 再将金额加回账户

accountInfoDao.addAccountBalance(accountNo,amount);

// 添加 cancel 日志，用于幂等性控制标识

accountInfoDao.addCancel(localTradeNo);

log.info("******** Bank1 Service end rollback... " +localTradeNo);

}

}

3 ） feignClient

@FeignClient(value = "seata‐demo‐bank2", fallback = Bank2Fallback.class)

public interface Bank2Client {

@GetMapping("/bank2/transfer")

@Hmily

Boolean transfer(@RequestParam("amount") Double amount);

}

4) Controller

@RestController

public class Bank1Controller {

@Autowired

AccountInfoService accountInfoService;

@RequestMapping("/transfer")

public String test(@RequestParam("amount") Double amount) {

this.accountInfoService.updateAccountBalance("1", amount);

return "cn/itcast/dtx/tccdemo/bank1" + amount;

}

} 4.3.8 dtx-tcc-demo-bank2

dtx-tcc-demo-bank2 实现如下功能：

try ：

空

confirm ：

confirm 幂等校验

正式增加金额

cancel ：

空

1 ） Dao

@Component

@Mapper

public interface AccountInfoDao {

@Update("update account_info set account_balance=account_balance + #{amount} where

account_no=#{accountNo} ")

int addAccountBalance(@Param("accountNo") String accountNo, @Param("amount") Double amount);

/**

* 增加某分支事务 try 执行记录

* @param localTradeNo 本地事务编号

* @return

*/

@Insert("insert into local_try_log values(#{txNo},now());")

int addTry(String localTradeNo);

@Insert("insert into local_confirm_log values(#{txNo},now());")

int addConfirm(String localTradeNo);

@Insert("insert into local_cancel_log values(#{txNo},now());")

int addCancel(String localTradeNo);

/**

* 查询分支事务 try 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_try_log where tx_no = #{txNo} ")

int isExistTry(String localTradeNo);

/**

* 查询分支事务 confirm 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_confirm_log where tx_no = #{txNo} ")

int isExistConfirm(String localTradeNo); /**

* 查询分支事务 cancel 是否已执行

* @param localTradeNo 本地事务编号

* @return

*/

@Select("select count(1) from local_cancel_log where tx_no = #{txNo} ")

int isExistCancel(String localTradeNo);

}

2 ）实现 confifirm 方法

@Service

@Slf4j

public class AccountInfoServiceImpl implements AccountInfoService {

@Autowired

private AccountInfoDao accountInfoDao;

@Override

@Transactional

@Hmily(confirmMethod = "confirmMethod", cancelMethod = "cancelMethod")

public void updateAccountBalance(String accountNo, Double amount) {

String localTradeNo = HmilyTransactionContextLocal.getInstance().get().getTransId();

log.info("******** Bank2 Service Begin try ..."+localTradeNo);

}

@Transactional

public void confirmMethod(String accountNo, Double amount) {

String localTradeNo = HmilyTransactionContextLocal.getInstance().get().getTransId();

log.info("******** Bank2 Service commit... " +localTradeNo);

if(accountInfoDao.isExistConfirm(localTradeNo) > 0){ // 幂等性校验，已经执行过了，什么也不用做

log.info("******** Bank2 已经执行过 confirm... 无需再次 confirm "+localTradeNo );

return ;

}

// 正式增加金额

accountInfoDao.addAccountBalance(accountNo,amount);

// 添加 confirm 日志

accountInfoDao.addConfirm(localTradeNo);

}

@Transactional

public void cancelMethod(String accountNo, Double amount) {

String localTradeNo = HmilyTransactionContextLocal.getInstance().get().getTransId();

log.info("******** Bank2 Service begin cancel... "+localTradeNo );

}

} 3 ） Controller

@RestController

public class Bank2Controller {

@Autowired

AccountInfoService accountInfoService;

@RequestMapping("/transfer")

public Boolean test2(@RequestParam("amount") Double amount) {

this.accountInfoService.updateAccountBalance("2", amount);

return true;

}

}

3.3.9 测试场景

张三向李四转账成功。

李四事务失败，张三事务回滚成功。

张三事务失败，李四分支事务回滚成功。

分支事务超时测试。

4.4. 小结

如果拿 TCC 事务的处理流程与 2PC 两阶段提交做比较， 2PC 通常都是在跨库的 DB 层面，而 TCC 则在应用层面的处

理，需要通过业务逻辑来实现。这种分布式事务的实现方式的优势在于，可以让 应用自己定义数据操作的粒度，使

得降低锁冲突、提高吞吐量成为可能 。

而不足之处则在于对应用的侵入性非常强，业务逻辑的每个分支都需要实现 try 、 confifirm 、 cancel 三个操作。此

外，其实现难度也比较大，需要按照网络状态、系统故障等不同的失败原因实现不同的回滚策略。