分布式事务 TCC-Transaction 源码分析 —— TCC 实现

tcc-transaction 执行流程源码分析 1.简单使用请参考如下链接: tcc-transaction demo 例程源码2.流程分析我们根据例程代码分析,可以猜测到事务的执行流程通过spring-aop实现。 ResourceCoordinatorAspect,主要为了完成confirm和cancel的执行,其执行级别为HIGHEST_PRECEDENCE + 1;:@Aspect public abstract class Reso 阅读详情

摘要: 原创出处 http://www.iocoder.cn/TCC-Transaction/tcc-core 「芋道源码」欢迎转载,保留摘要,谢谢!

本文主要基于 TCC-Transaction 1.2.3.3 正式版


������关注微信公众号:【芋道源码】有福利:
1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
4. 新的源码解析文章实时收到通知。每周更新一篇左右。
5. 认真的源码交流微信群。


1. 概述

本文分享 TCC 实现。主要涉及如下三个 Maven 项目:

  • tcc-transaction-core :tcc-transaction 底层实现。
  • tcc-transaction-api :tcc-transaction 使用 API。
  • tcc-transaction-spring :tcc-transaction Spring 支持。

你行好事会因为得到赞赏而愉悦
同理,开源项目贡献者会因为 Star 而更加有动力
为 TCC-Transaction 点赞!传送门

OK,开始我们的第一段 TCC 旅程吧。

ps:笔者假设你已经阅读过《tcc-transaction 官方文档 —— 使用指南1.2.x》。

ps2:未特殊说明的情况下,本文事务指的是 TCC事务。

2. TCC 原理

FROM https://support.hwclouds.com/devg-servicestage/zh-cn_topic_0056814426.html
TCC事务
为了解决在事务运行过程中大颗粒度资源锁定的问题,业界提出一种新的事务模型,它是基于业务层面的事务定义。锁粒度完全由业务自己控制。它本质是一种补偿的思路。它把事务运行过程分成 Try、Confirm / Cancel 两个阶段。在每个阶段的逻辑由业务代码控制。这样就事务的锁粒度可以完全自由控制。业务可以在牺牲隔离性的情况下,获取更高的性能。

  • Try 阶段
    • Try :尝试执行业务
      • 完成所有业务检查( 一致性 )
      • 预留必须业务资源( 准隔离性 )
  • Confirm / Cancel 阶段:
    • Confirm :确认执行业务
      • 真正执行业务
      • 不做任务业务检查
      • Confirm 操作满足幂等性
    • Cancel :取消执行业务
      • 释放 Try 阶段预留的业务资源
      • Cancel 操作满足幂等性
    • Confirm 与 Cancel 互斥

整体流程如下图:

  • 红框部分功能由 tcc-transaction-core 实现:

    • 启动业务活动
    • 登记业务操作
    • 提交 / 回滚业务活动
  • 黄框部分功能由 tcc-transaction-http-sample 实现( 官方提供的示例项目 ):

    • Try 操作
    • Confirm 操作
    • Cancel 操作

与 2PC协议 比较:

  • 位于业务服务层而非自愿层
  • 没有单独的准备( Prepare )阶段,Try 操作兼备自愿操作与准备能力
  • Try 操作可以灵活选择业务资源的锁定粒度
  • 较高开发成本

参考资料:

3. TCC-Transaction 原理

在 TCC 里,一个业务活动可以有多个事务,每个业务操作归属于不同的事务,即一个事务可以包含多个业务操作。TCC-Transaction 将每个业务操作抽象成事务参与者,每个事务可以包含多个参与者。

参与者需要声明 try / confirm / cancel 三个类型的方法,和 TCC 的操作一一对应。在程序里,通过 @Compensable 注解标记在 try 方法上,并填写对应的 confirm / cancel 方法,示例代码如下:

// try
@Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord", transactionContextEditor = MethodTransactionContextEditor.class)
public String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}

// confirm
public void confirmRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}

// cancel
public void cancelRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}
  • 在示例代码中,我们看到 TransactionContext,事务上下文,这个是怎么生成的呢?这里先卖一个关子。

TCC-Transaction 有两个拦截器,通过对 @Compensable AOP 切面( 参与者 try 方法 )进行拦截,透明化对参与者 confirm / cancel 方法调用,从而实现 TCC 。简化流程如下图:

第一个拦截器,可补偿事务拦截器,实现如下功能:

  • 在 Try 阶段,对事务的发起、传播。
  • 在 Confirm / Cancel 阶段,对事务提交或回滚。
  • 为什么会有对事务的传播呢?在远程调用服务的参与者时,会通过“参数”( 需要序列化 )的形式传递事务给远程参与者。

第二个拦截器,资源协调者拦截器,实现如下功能:

  • 在 Try 阶段,添加参与者到事务中。当事务上下文不存在时,进行创建。

实际拦截器对事务的处理会比上图复杂一些,在本文「6. 事务拦截器」详细解析。

在 TCC-Transaction 代码实现上,组件分层如下图:

本文按照如下顺序分享:

内容是自下而上的方式分享,每个组件可以更加整体的被认识。当然这可能对你理解时产生一脸闷逼,所以推荐两种阅读方式:

  • 简读 x 1 + 深读 x 1
  • 倒着读,发现未分享的方法,全文检索该方法。

事务存储器在《TCC-Transaction 源码解析 —— 事务存储于恢复》详细解析。

事务恢复在《TCC-Transaction 源码解析 —— 事务恢复》详细解析。

4. 事务与参与者

在 TCC 里,一个事务( org.mengyun.tcctransaction.Transaction ) 可以有多个参与者( org.mengyun.tcctransaction.Participant )参与业务活动。类图关系如下( 打开大图 ):

4.1 事务

Transaction 实现代码如下:

public class Transaction implements Serializable {

    private static final long serialVersionUID = 7291423944314337931L;

    /**
     * 事务编号
     */
    private TransactionXid xid;
    /**
     * 事务状态
     */
    private TransactionStatus status;
    /**
     * 事务类型
     */
    private TransactionType transactionType;
    /**
     * 重试次数
     */
    private volatile int retriedCount = 0;
    /**
     * 创建时间
     */
    private Date createTime = new Date();
    /**
     * 最后更新时间
     */
    private Date lastUpdateTime = new Date();
    /**
     * 版本号
     */
    private long version = 1;
    /**
     * 参与者集合
     */
    private List<Participant> participants = new ArrayList<Participant>();
    /**
     * 附带属性映射
     */
    private Map<String, Object> attachments = new ConcurrentHashMap<String, Object>();

    /**
     * 添加参与者
     *
     * @param participant 参与者
     */
    public void enlistParticipant(Participant participant) {
        participants.add(participant);
    }

    /**
     * 提交 TCC 事务
     */
    public void commit() {
        for (Participant participant : participants) {
            participant.commit();
        }
    }

    /**
     * 回滚 TCC 事务
     */
    public void rollback() {
        for (Participant participant : participants) {
            participant.rollback();
        }
    }
}
  • xid,事务编号( TransactionXid ),用于唯一标识一个事务。使用 UUID 算法生成,保证唯一性。org.mengyun.tcctransaction.api.TransactionXid 实现 javax.transaction.xa.Xid 接口,实现代码如下:

    public class TransactionXid implements Xid, Serializable {
        private static final long serialVersionUID = -6817267250789142043L;
    
        /**
         * xid 格式标识符
         */
        private int formatId = 1;
        /**
         * 全局事务编号
         */
        private byte[] globalTransactionId;
        /**
         * 分支事务编号
         */
        private byte[] branchQualifier;
    
    }
    • TODO 为什么要继承 Xid 接口?
  • status,事务状态( TransactionStatus )。org.mengyun.tcctransaction.api.TransactionStatus 实现代码如下:

    public enum TransactionStatus {
        /**
         * 尝试中状态
         */
        TRYING(1),
        /**
         * 确认中状态
         */
        CONFIRMING(2),
        /**
         * 取消中状态
         */
        CANCELLING(3);
    
        private int id;
    }
  • transactionType,事务类型( TransactionType )。org.mengyun.tcctransaction.common.TransactionType 实现代码如下:

    public enum TransactionType {
    
        /**
         * 根事务
         */
        ROOT(1),
        /**
         * 分支事务
         */
        BRANCH(2);
    
        int id;
    }
  • retriedCount,重试次数。在 TCC 过程中,可能参与者异常崩溃,这个时候会进行重试直到成功或超过最大次数。在《TCC-Transaction 源码解析 —— 事务恢复》详细解析。

  • version,版本号,用于乐观锁更新事务。在《TCC-Transaction 源码解析 —— 事务存储器》详细解析。
  • attachments,附带属性映射。在《TCC-Transaction 源码解析 —— Dubbo 支持》详细解析。
  • 提供 #enlistParticipant() 方法,添加事务参与者。
  • 提供 #commit() 方法,调用参与者们提交事务。
  • 提供 #rollback() 方法,调用参与者回滚事务。

4.2 参与者

Participant 实现代码如下:

public class Participant implements Serializable {

    private static final long serialVersionUID = 4127729421281425247L;

    /**
     * 事务编号
     */
    private TransactionXid xid;
    /**
     * 确认执行业务方法调用上下文
     */
    private InvocationContext confirmInvocationContext;
    /**
     * 取消执行业务方法
     */
    private InvocationContext cancelInvocationContext;
    /**
     * 执行器
     */
    private Terminator terminator = new Terminator();
    /**
     * 事务上下文编辑
     */
    Class<? extends TransactionContextEditor> transactionContextEditorClass;

    /**
     * 提交事务
     */
    public void commit() {
        terminator.invoke(new TransactionContext(xid, TransactionStatus.CONFIRMING.getId()), confirmInvocationContext, transactionContextEditorClass);
    }

    /**
     * 回滚事务
     */
    public void rollback() {
        terminator.invoke(new TransactionContext(xid, TransactionStatus.CANCELLING.getId()), cancelInvocationContext, transactionContextEditorClass);
    }
}
  • xid,参与者事务编号。通过 TransactionXid.globalTransactionId 属性,关联上其所属的事务。当参与者进行远程调用时,远程的分支事务的事务编号等于该参与者的事务编号。通过事务编号的关联,TCC Confirm / Cancel 阶段,使用参与者的事务编号和远程的分支事务进行关联,从而实现事务的提交和回滚,在「5.2 传播发起分支事务」 + 「6.2 可补偿事务拦截器」可以看到具体实现。
  • confirmInvocationContext,确认执行业务方法调用上下文( InvocationContext )。org.mengyun.tcctransaction.InvocationContext 实现代码如下:

    public class InvocationContext implements Serializable {
    
        private static final long serialVersionUID = -7969140711432461165L;
    
        /**
         * 类
         */
        private Class targetClass;
        /**
         * 方法名
         */
        private String methodName;
        /**
         * 参数类型数组
         */
        private Class[] parameterTypes;
        /**
         * 参数数组
         */
        private Object[] args;
    }
    • InvocationContext,执行方法调用上下文,记录类、方法名、参数类型数组、参数数组。通过这些属性,可以执行提交 / 回滚事务。在 org.mengyun.tcctransaction.Terminator 会看到具体的代码实现。本质上,TCC 通过多个参与者的 try / confirm / cancel 方法,实现事务的最终一致性。
  • cancelInvocationContext,取消执行业务方法调用上下文( InvocationContext )。

  • terminator,执行器( Terminator )。org.mengyun.tcctransaction.Terminator 实现代码如下:

    public class Terminator implements Serializable {
    
        private static final long serialVersionUID = -164958655471605778L;
    
        public Object invoke(TransactionContext transactionContext, InvocationContext invocationContext, Class<? extends TransactionContextEditor> transactionContextEditorClass) {
            if (StringUtils.isNotEmpty(invocationContext.getMethodName())) {
                try {
                    // 获得 参与者对象
                    Object target = FactoryBuilder.factoryOf(invocationContext.getTargetClass()).getInstance();
                    // 获得 方法
                    Method method = target.getClass().getMethod(invocationContext.getMethodName(), invocationContext.getParameterTypes());
                    // 设置 事务上下文 到方法参数
                    FactoryBuilder.factoryOf(transactionContextEditorClass).getInstance().set(transactionContext, target, method, invocationContext.getArgs());
                    // 执行方法
                    return method.invoke(target, invocationContext.getArgs());
                } catch (Exception e) {
                    throw new SystemException(e);
                }
            }
            return null;
        }
    
    }
    • FactoryBuilder,工厂 Builder,感兴趣的同学点击链接查看,已经添加完整中文代码注释。
    • TransactionContextEditor,在本文「6.1 Compensable」详细解析。
  • transactionContextEditorClass,事务上下文编辑,在「6.1 Compensable」详细解析。
  • 提交 #commit() 方法,提交参与者自己的事务。
  • 提交 #rollback() 方法,回滚参与者自己的事务。

5. 事务管理器

org.mengyun.tcctransaction.TransactionManager,事务管理器,提供事务的获取、发起、提交、回滚,参与者的新增等等方法。

5.1 发起根事务

提供 begin() 方法,发起根事务。该方法在调用方法类型为 MethodType.ROOT 并且 事务处于 Try 阶段被调用。MethodType 在「6.2 可补偿事务拦截器」详细解析。

实现代码如下:

// TransactionManager.java
/**
* 发起根事务
*
* @return 事务
*/
public Transaction begin() {
   // 创建 根事务
   Transaction transaction = new Transaction(TransactionType.ROOT);
   // 存储 事务
   transactionRepository.create(transaction);
   // 注册 事务
   registerTransaction(transaction);
   return transaction;
}
  • 调用 Transaction 构造方法,创建根事务。实现代码如下:

    // Transaction.java
    /**
    * 创建指定类型的事务
    *
    * @param transactionType 事务类型
    */
    public Transaction(TransactionType transactionType) {
       this.xid = new TransactionXid();
       this.status = TransactionStatus.TRYING; // 尝试中状态
       this.transactionType = transactionType;
    }
    • 目前该构造方法只有 TransactionManager#begin() 在调用,即只创建根事务。
  • 调用 TransactionRepository#crete() 方法,存储事务。
  • 调用 #registerTransaction(...) 方法,注册事务到当前线程事务队列。实现代码如下:

    // TransactionManager.java
    /**
    * 当前线程事务队列
    */
    private static final ThreadLocal<Deque<Transaction>> CURRENT = new ThreadLocal<Deque<Transaction>>();
    
    /**
    * 注册事务到当前线程事务队列
    *
    * @param transaction 事务
    */
    private void registerTransaction(Transaction transaction) {
       if (CURRENT.get() == null) {
           CURRENT.set(new LinkedList<Transaction>());
       }
       CURRENT.get().push(transaction); // 添加到头部
    }
    • 可能有同学会比较好奇,为什么使用队列存储当前线程事务?TCC-Transaction 支持多个的事务独立存在,后创建的事务先提交,类似 Spring 的org.springframework.transaction.annotation.Propagation.REQUIRES_NEW 。在下文,很快我们就会看到 TCC-Transaction 自己的 org.mengyun.tcctransaction.api.Propagation 。

5.2 传播发起分支事务

调用 #propagationNewBegin(...) 方法,传播发起分支事务。该方法在调用方法类型为 MethodType.PROVIDER 并且 事务处于 Try 阶段被调用。MethodType 在「6.2 可补偿事务拦截器」详细解析。

实现代码如下:

/**
* 传播发起分支事务
*
* @param transactionContext 事务上下文
* @return 分支事务
*/
public Transaction propagationNewBegin(TransactionContext transactionContext) {
  // 创建 分支事务
  Transaction transaction = new Transaction(transactionContext);
  // 存储 事务
  transactionRepository.create(transaction);
  // 注册 事务
  registerTransaction(transaction);
  return transaction;
}
  • 调用 Transaction 构造方法,创建分支事务。实现代码如下:

    /**
    * 创建分支事务
    *
    * @param transactionContext 事务上下文
    */
    public Transaction(TransactionContext transactionContext) {
       this.xid = transactionContext.getXid(); // 事务上下文的 xid
       this.status = TransactionStatus.TRYING; // 尝试中状态
       this.transactionType = TransactionType.BRANCH; // 分支事务
    }
    • 分支事务使用传播的事务上下文的事务编号。
  • 调用 TransactionRepository#crete() 方法,存储事务。为什么要存储分支事务,在「6.3 资源协调者拦截器」详细解析。
  • 调用 #registerTransaction(...) 方法,注册事务到当前线程事务队列。

5.3 传播获取分支事务

调用 #propagationExistBegin(...) 方法,传播发起分支事务。该方法在调用方法类型为 MethodType.PROVIDER 并且 事务处于 Confirm / Cancel 阶段被调用。MethodType 在「6.2 可补偿事务拦截器」详细解析。

实现代码如下:

/**
* 传播获取分支事务
*
* @param transactionContext 事务上下文
* @return 分支事务
* @throws NoExistedTransactionException 当事务不存在时
*/
public Transaction propagationExistBegin(TransactionContext transactionContext) throws NoExistedTransactionException {
   // 查询 事务
   Transaction transaction = transactionRepository.findByXid(transactionContext.getXid());
   if (transaction != null) {
       // 设置 事务 状态
       transaction.changeStatus(TransactionStatus.valueOf(transactionContext.getStatus()));
       // 注册 事务
       registerTransaction(transaction);
       return transaction;
   } else {
       throw new NoExistedTransactionException();
   }
}
  • 调用 TransactionRepository#findByXid() 方法,查询事务。
  • 调用 Transaction#changeStatus(...) 方法,设置事务状态为 CONFIRMING 或 CANCELLING。
  • 调用 #registerTransaction(...) 方法,注册事务到当前线程事务队列。
  • 为什么此处是分支事务呢?结合 #propagationNewBegin(...) 思考下。

5.4 提交事务

调用 #commit(...) 方法,提交事务。该方法在事务处于 Confirm / Cancel 阶段被调用。

实现代码如下:

/**
* 提交事务
*/
public void commit() {
   // 获取 事务
   Transaction transaction = getCurrentTransaction();
   // 设置 事务状态 为 CONFIRMING
   transaction.changeStatus(TransactionStatus.CONFIRMING);
   // 更新 事务
   transactionRepository.update(transaction);
   try {
       // 提交 事务
       transaction.commit();
       // 删除 事务
       transactionRepository.delete(transaction);
   } catch (Throwable commitException) {
       logger.error("compensable transaction confirm failed.", commitException);
       throw new ConfirmingException(commitException);
   }
}
  • 调用 #getCurrentTransaction() 方法, 获取事务。实现代码如下:

    public Transaction getCurrentTransaction() {
       if (isTransactionActive()) {
           return CURRENT.get().peek(); // 获得头部元素
       }
       return null;
    }
    
    public boolean isTransactionActive() {
       Deque<Transaction> transactions = CURRENT.get();
       return transactions != null && !transactions.isEmpty();
    }
    • 为什么获得队列头部元素呢?该元素即是上文调用 #registerTransaction(...) 注册到队列头部。
  • 调用 Transaction#changeStatus(...) 方法, 设置事务状态为 CONFIRMING。
  • 调用 TransactionRepository#update(...) 方法, 更新事务。
  • 调用 Transaction#commit(...) 方法, 提交事务。
  • 调用 TransactionRepository#delete(...) 方法,删除事务。

5.5 回滚事务

调用 #rollback(...) 方法,取消事务,和 #commit() 方法基本类似。该方法在事务处于 Confirm / Cancel 阶段被调用。

实现代码如下:

/**
* 回滚事务
*/
public void rollback() {
   // 获取 事务
   Transaction transaction = getCurrentTransaction();
   // 设置 事务状态 为 CANCELLING
   transaction.changeStatus(TransactionStatus.CANCELLING);
   // 更新 事务
   transactionRepository.update(transaction);
   try {
       // 提交 事务
       transaction.rollback();
       // 删除 事务
       transactionRepository.delete(transaction);
   } catch (Throwable rollbackException) {
       logger.error("compensable transaction rollback failed.", rollbackException);
       throw new CancellingException(rollbackException);
   }
}
  • 调用 #getCurrentTransaction() 方法,获取事务。
  • 调用 Transaction#changeStatus(...) 方法, 设置事务状态为 CANCELLING。
  • 调用 TransactionRepository#update(...) 方法, 更新事务。
  • 调用 Transaction#rollback(...) 方法, 回滚事务。
  • 调用 TransactionRepository#delete(...) 方法,删除事务。

5.6 添加参与者到事务

调用 #enlistParticipant(...) 方法,添加参与者到事务。该方法在事务处于 Try 阶段被调用,在「6.3 资源协调者拦截器」有详细解析。

实现代码如下:

/**
* 添加参与者到事务
*
* @param participant 参与者
*/
public void enlistParticipant(Participant participant) {
   // 获取 事务
   Transaction transaction = this.getCurrentTransaction();
   // 添加参与者
   transaction.enlistParticipant(participant);
   // 更新 事务
   transactionRepository.update(transaction);
}
  • 调用 #getCurrentTransaction() 方法,获取事务。
  • 调用 Transaction#enlistParticipant(...) 方法, 添加参与者到事务。
  • 调用 TransactionRepository#update(...) 方法, 更新事务。

6. 事务拦截器

TCC-Transaction 基于 org.mengyun.tcctransaction.api.@Compensable + org.aspectj.lang.annotation.@Aspect 注解 AOP 切面实现业务方法的 TCC 事务声明拦截,同 Spring 的 org.springframework.transaction.annotation.@Transactional 的实现。

TCC-Transaction 有两个拦截器:

  • org.mengyun.tcctransaction.interceptor.CompensableTransactionInterceptor,可补偿事务拦截器。
  • org.mengyun.tcctransaction.interceptor.ResourceCoordinatorInterceptor,资源协调者拦截器。

在分享拦截器的实现之前,我们先一起看看 @Compensable 注解。

6.1 Compensable

@Compensable,标记可补偿的方法注解。实现代码如下:

public @interface Compensable {

    /**
     * 传播级别
     */
    Propagation propagation() default Propagation.REQUIRED;

    /**
     * 确认执行业务方法
     */
    String confirmMethod() default "";

    /**
     * 取消执行业务方法
     */
    String cancelMethod() default "";

    /**
     * 事务上下文编辑
     */
    Class<? extends TransactionContextEditor> transactionContextEditor() default DefaultTransactionContextEditor.class;
}
  • propagation,传播级别( Propagation ),默认 Propagation.REQUIRED。和 Spring 的 Propagation 除了缺少几个属性,基本一致。实现代码如下:

    public enum Propagation {
    
        /**
         * 支持当前事务,如果当前没有事务,就新建一个事务。
         */
        REQUIRED(0),
        /**
         * 支持当前事务,如果当前没有事务,就以非事务方式执行。
         */
        SUPPORTS(1),
        /**
         * 支持当前事务,如果当前没有事务,就抛出异常。
         */
        MANDATORY(2),
        /**
         * 新建事务,如果当前存在事务,把当前事务挂起。
         */
        REQUIRES_NEW(3);
    
        private final int value;
    }
  • confirmMethod,确认执行业务方法名。

  • cancelMethod,取消执行业务方法名。
  • TransactionContextEditor,事务上下文编辑器( TransactionContextEditor ),用于设置和获得事务上下文( TransactionContext ),在「6.3 资源协调者拦截器」可以看到被调用,此处只看它的代码实现。org.mengyun.tcctransaction.api.TransactionContextEditor 接口代码如下:

    public interface TransactionContextEditor {
    
        /**
         * 从参数中获得事务上下文
         *
         * @param target 对象
         * @param method 方法
         * @param args 参数
         * @return 事务上下文
         */
        TransactionContext get(Object target, Method method, Object[] args);
    
        /**
         * 设置事务上下文到参数中
         *
         * @param transactionContext 事务上下文
         * @param target 对象
         * @param method 方法
         * @param args 参数
         */
        void set(TransactionContext transactionContext, Object target, Method method, Object[] args);
    
    }
    • DefaultTransactionContextEditor,默认事务上下文编辑器实现。实现代码如下:

      class DefaultTransactionContextEditor implements TransactionContextEditor {
      
          @Override
          public TransactionContext get(Object target, Method method, Object[] args) {
              int position = getTransactionContextParamPosition(method.getParameterTypes());
              if (position >= 0) {
                  return (TransactionContext) args[position];
              }
              return null;
          }
      
          @Override
          public void set(TransactionContext transactionContext, Object target, Method method, Object[] args) {
              int position = getTransactionContextParamPosition(method.getParameterTypes());
              if (position >= 0) {
                  args[position] = transactionContext; // 设置方法参数
              }
          }
      
          /**
           * 获得事务上下文在方法参数里的位置
           *
           * @param parameterTypes 参数类型集合
           * @return 位置
           */
          public static int getTransactionContextParamPosition(Class<?>[] parameterTypes) {
              int position = -1;
              for (int i = 0; i < parameterTypes.length; i++) {
                  if (parameterTypes[i].equals(org.mengyun.tcctransaction.api.TransactionContext.class)) {
                      position = i;
                      break;
                  }
              }
              return position;
          }
      }
      • x
    • NullableTransactionContextEditor,无事务上下文编辑器实现。实现代码如下:

      class NullableTransactionContextEditor implements TransactionContextEditor {
      
          @Override
          public TransactionContext get(Object target, Method method, Object[] args) {
              return null;
          }
      
          @Override
          public void set(TransactionContext transactionContext, Object target, Method method, Object[] args) {
          }
      }
    • DubboTransactionContextEditor,Dubbo 事务上下文编辑器实现,通过 Dubbo 隐式传参方式获得事务上下文,在《TCC-Transaction 源码解析 —— Dubbo 支持》详细解析。

6.2 可补偿事务拦截器

先一起来看下可补偿事务拦截器对应的切面 org.mengyun.tcctransaction.interceptor.CompensableTransactionAspect,实现代码如下:

@Aspect
public abstract class CompensableTransactionAspect {

    private CompensableTransactionInterceptor compensableTransactionInterceptor;

    public void setCompensableTransactionInterceptor(CompensableTransactionInterceptor compensableTransactionInterceptor) {
        this.compensableTransactionInterceptor = compensableTransactionInterceptor;
    }

    @Pointcut("@annotation(org.mengyun.tcctransaction.api.Compensable)")
    public void compensableService() {
    }

    @Around("compensableService()")
    public Object interceptCompensableMethod(ProceedingJoinPoint pjp) throws Throwable {
        return compensableTransactionInterceptor.interceptCompensableMethod(pjp);
    }

    public abstract int getOrder();
}
  • 通过 org.aspectj.lang.annotation.@Pointcut + org.aspectj.lang.annotation.@Around 注解,配置对 @Compensable 注解的方法进行拦截,调用 CompensableTransactionInterceptor#interceptCompensableMethod(...) 方法进行处理。

CompensableTransactionInterceptor 实现代码如下:

public class CompensableTransactionInterceptor {

    private TransactionManager transactionManager;

    private Set<Class<? extends Exception>> delayCancelExceptions;

    public Object interceptCompensableMethod(ProceedingJoinPoint pjp) throws Throwable {
        // 获得带 @Compensable 注解的方法
        Method method = CompensableMethodUtils.getCompensableMethod(pjp);
        //
        Compensable compensable = method.getAnnotation(Compensable.class);
        Propagation propagation = compensable.propagation();
        // 获得 事务上下文
        TransactionContext transactionContext = FactoryBuilder.factoryOf(compensable.transactionContextEditor()).getInstance().get(pjp.getTarget(), method, pjp.getArgs());
        // 当前线程是否在事务中
        boolean isTransactionActive = transactionManager.isTransactionActive();
        // 判断事务上下文是否合法
        if (!TransactionUtils.isLegalTransactionContext(isTransactionActive, propagation, transactionContext)) {
            throw new SystemException("no active compensable transaction while propagation is mandatory for method " + method.getName());
        }
        // 计算方法类型
        MethodType methodType = CompensableMethodUtils.calculateMethodType(propagation, isTransactionActive, transactionContext);
        // 处理
        switch (methodType) {
            case ROOT:
                return rootMethodProceed(pjp);
            case PROVIDER:
                return providerMethodProceed(pjp, transactionContext);
            default:
                return pjp.proceed();
        }
    }
}
  • 调用 CompensableMethodUtils#getCompensableMethod(...) 方法,获得带 @Compensable 注解的方法。实现代码如下:

    // CompensableMethodUtils.java
    /**
    * 获得带 @Compensable 注解的方法
    *
    * @param pjp 切面点
    * @return 方法
    */
    public static Method getCompensableMethod(ProceedingJoinPoint pjp) {
       Method method = ((MethodSignature) (pjp.getSignature())).getMethod(); // 代理方法对象
       if (method.getAnnotation(Compensable.class) == null) {
           try {
               method = pjp.getTarget().getClass().getMethod(method.getName(), method.getParameterTypes()); // 实际方法对象
           } catch (NoSuchMethodException e) {
               return null;
           }
       }
       return method;
    }
  • 调用 TransactionContextEditor#get(...) 方法,从参数中获得事务上下文。为什么从参数中可以获得事务上下文呢?在「6.3 资源协调者拦截器」揭晓答案。

  • 调用 TransactionManager#isTransactionActive() 方法,当前线程是否在事务中。实现代码如下:

    // TransactionManager.java
    private static final ThreadLocal<Deque<Transaction>> CURRENT = new ThreadLocal<Deque<Transaction>>();
    
    public boolean isTransactionActive() {
       Deque<Transaction> transactions = CURRENT.get();
       return transactions != null && !transactions.isEmpty();
    }
  • 调用 TransactionUtils#isLegalTransactionContext(...) 方法,判断事务上下文是否合法。实现代码如下:

    // TransactionUtils.java
    /**
    * 判断事务上下文是否合法
    * 在 Propagation.MANDATORY 必须有在事务内
    *
    * @param isTransactionActive 是否
    * @param propagation 传播级别
    * @param transactionContext 事务上下文
    * @return 是否合法
    */
    public static boolean isLegalTransactionContext(boolean isTransactionActive, Propagation propagation, TransactionContext transactionContext) {
       if (propagation.equals(Propagation.MANDATORY) && !isTransactionActive && transactionContext == null) {
           return false;
       }
       return true;
    }
    • 当传播级别为 Propagation.MANDATORY 时,要求必须在事务中。
  • 调用 CompensableMethodUtils#calculateMethodType(...) 方法,计算方法类型。实现代码如下:

    /**
    * 计算方法类型
    *
    * @param propagation 传播级别
    * @param isTransactionActive 是否事务开启
    * @param transactionContext 事务上下文
    * @return 方法类型
    */
    public static MethodType calculateMethodType(Propagation propagation, boolean isTransactionActive, TransactionContext transactionContext) {
       if ((propagation.equals(Propagation.REQUIRED) && !isTransactionActive && transactionContext == null) // Propagation.REQUIRED:支持当前事务,当前没有事务,就新建一个事务。
               || propagation.equals(Propagation.REQUIRES_NEW)) { // Propagation.REQUIRES_NEW:新建事务,如果当前存在事务,把当前事务挂起。
           return MethodType.ROOT;
       } else if ((propagation.equals(Propagation.REQUIRED) // Propagation.REQUIRED:支持当前事务
                   || propagation.equals(Propagation.MANDATORY)) // Propagation.MANDATORY:支持当前事务
               && !isTransactionActive && transactionContext != null) {
           return MethodType.PROVIDER;
       } else {
           return MethodType.NORMAL;
       }
    }
    • 计算方法类型( MethodType )的目的,可以根据不同方法类型,做不同的事务处理。
    • 方法类型为 MethodType.ROOT 时,发起根事务,判断条件如下二选一:
      • 事务传播级别为 Propagation.REQUIRED,并且当前没有事务。
      • 事务传播级别为 Propagation.REQUIRES_NEW,新建事务,如果当前存在事务,把当前事务挂起。此时,事务管理器的当前线程事务队列可能会存在多个事务。
    • 方法类型为 MethodType.ROOT 时,发起分支事务,判断条件如下二选一:
      • 事务传播级别为 Propagation.REQUIRED,并且当前不存在事务,并且方法参数传递了事务上下文。
      • 事务传播级别为 Propagation.PROVIDER,并且当前不存在事务,并且方法参数传递了事务上下文。
      • 当前不存在事务,方法参数传递了事务上下文是什么意思?当跨服务远程调用时,被调用服务本身( 服务提供者 )不在事务中,通过传递事务上下文参数,融入当前事务。
    • 方法类型为 MethodType.Normal 时,不进行事务处理。
    • MethodType.CONSUMER 项目已经不再使用,猜测已废弃。
  • 当方法类型为 MethodType.ROOT 时,调用 #rootMethodProceed(...) 方法,发起 TCC 整体流程。实现代码如下:

    private Object rootMethodProceed(ProceedingJoinPoint pjp) throws Throwable {
       Object returnValue;
       Transaction transaction = null;
       try {
           // 发起根事务
           transaction = transactionManager.begin();
           // 执行方法原逻辑
           try {
               returnValue = pjp.proceed();
           } catch (Throwable tryingException) {
               if (isDelayCancelException(tryingException)) { // 是否延迟回滚
               } else {
                   logger.warn(String.format("compensable transaction trying failed. transaction content:%s", JSON.toJSONString(transaction)), tryingException);
                   // 回滚事务
                   transactionManager.rollback();
               }
               throw tryingException;
           }
           // 提交事务
           transactionManager.commit();
       } finally {
           // 将事务从当前线程事务队列移除
           transactionManager.cleanAfterCompletion(transaction);
       }
       return returnValue;
    }
    • 调用 #transactionManager() 方法,发起根事务,TCC Try 阶段开始。
    • 调用 ProceedingJoinPoint#proceed() 方法,执行方法原逻辑( 即 Try 逻辑 )。
    • 当原逻辑执行异常时,TCC Try 阶段失败,调用 TransactionManager#rollback(...) 方法,TCC Cancel 阶段,回滚事务。此处 #isDelayCancelException(...) 方法,判断异常是否为延迟取消回滚异常,部分异常不适合立即回滚事务,在《TCC-Transaction 源码分析 —— 事务恢复》详细解析。
    • 当原逻辑执行成功时,TCC Try 阶段成功,调用 TransactionManager#commit(...) 方法,TCC Confirm 阶段,提交事务。
    • 调用 TransactionManager#cleanAfterCompletion(...) 方法,将事务从当前线程事务队列移除,避免线程冲突。实现代码如下:

      // TransactionManager.java
      public void cleanAfterCompletion(Transaction transaction) {
          if (isTransactionActive() && transaction != null) {
              Transaction currentTransaction = getCurrentTransaction();
              if (currentTransaction == transaction) {
                  CURRENT.get().pop();
              } else {
                  throw new SystemException("Illegal transaction when clean after completion");
              }
          }
      }
      • x
  • 当方法类型为 Propagation.PROVIDER 时,服务提供者参与 TCC 整体流程。实现代码如下:

    private Object providerMethodProceed(ProceedingJoinPoint pjp, TransactionContext transactionContext) throws Throwable {
       Transaction transaction = null;
       try {
           switch (TransactionStatus.valueOf(transactionContext.getStatus())) {
               case TRYING:
                   // 传播发起分支事务
                   transaction = transactionManager.propagationNewBegin(transactionContext);
                   return pjp.proceed();
               case CONFIRMING:
                   try {
                       // 传播获取分支事务
                       transaction = transactionManager.propagationExistBegin(transactionContext);
                       // 提交事务
                       transactionManager.commit();
                   } catch (NoExistedTransactionException excepton) {
                       //the transaction has been commit,ignore it.
                   }
                   break;
               case CANCELLING:
                   try {
                       // 传播获取分支事务
                       transaction = transactionManager.propagationExistBegin(transactionContext);
                       // 回滚事务
                       transactionManager.rollback();
                   } catch (NoExistedTransactionException exception) {
                       //the transaction has been rollback,ignore it.
                   }
                   break;
           }
       } finally {
           // 将事务从当前线程事务队列移除
           transactionManager.cleanAfterCompletion(transaction);
       }
       // 返回空值
       Method method = ((MethodSignature) (pjp.getSignature())).getMethod();
       return ReflectionUtils.getNullValue(method.getReturnType());
    }
    • 当事务处于 TransactionStatus.TRYING 时,调用 TransactionManager#propagationExistBegin(...) 方法,传播发起分支事务。发起分支事务完成后,调用 ProceedingJoinPoint#proceed() 方法,执行方法原逻辑( 即 Try 逻辑 )。
      • 为什么要传播发起分支事务?在根事务进行 Confirm / Cancel 时,调用根事务上的参与者们提交或回滚事务时,进行远程服务方法调用的参与者,可以通过自己的事务编号关联上传播的分支事务( 两者的事务编号相等 ),进行事务的提交或回滚。
    • 当事务处于 TransactionStatus.CONFIRMING 时,调用 TransactionManager#commit() 方法,提交事务。
    • 当事务处于 TransactionStatus.CANCELLING 时,调用 TransactionManager#rollback() 方法,提交事务。
    • 调用 TransactionManager#cleanAfterCompletion(...) 方法,将事务从当前线程事务队列移除,避免线程冲突。
    • 当事务处于 TransactionStatus.CONFIRMING / TransactionStatus.CANCELLING 时,调用 ReflectionUtils#getNullValue(...) 方法,返回空值。为什么返回空值?Confirm / Cancel 相关方法,是通过 AOP 切面调用,只调用,不处理返回值,但是又不能没有返回值,因此直接返回空。实现代码如下:

      public static Object getNullValue(Class type) {
         // 处理基本类型
         if (boolean.class.equals(type)) {
             return false;
         } else if (byte.class.equals(type)) {
             return 0;
         } else if (short.class.equals(type)) {
             return 0;
         } else if (int.class.equals(type)) {
             return 0;
         } else if (long.class.equals(type)) {
             return 0;
         } else if (float.class.equals(type)) {
             return 0;
         } else if (double.class.equals(type)) {
             return 0;
         }
         // 处理对象
         return null;
      }
  • 当方法类型为 Propagation.NORMAL 时,执行方法原逻辑,不进行事务处理。

6.3 资源协调者拦截器

先一起来看下资源协调者拦截器 对应的切面 org.mengyun.tcctransaction.interceptor.CompensableTransactionAspect,实现代码如下:

@Aspect
public abstract class ResourceCoordinatorAspect {

    private ResourceCoordinatorInterceptor resourceCoordinatorInterceptor;

    @Pointcut("@annotation(org.mengyun.tcctransaction.api.Compensable)")
    public void transactionContextCall() {
    }

    @Around("transactionContextCall()")
    public Object interceptTransactionContextMethod(ProceedingJoinPoint pjp) throws Throwable {
        return resourceCoordinatorInterceptor.interceptTransactionContextMethod(pjp);
    }

    public void setResourceCoordinatorInterceptor(ResourceCoordinatorInterceptor resourceCoordinatorInterceptor) {
        this.resourceCoordinatorInterceptor = resourceCoordinatorInterceptor;
    }

    public abstract int getOrder();
}
  • 通过 org.aspectj.lang.annotation.@Pointcut + org.aspectj.lang.annotation.@Around 注解,配置对 @Compensable 注解的方法进行拦截,调用 ResourceCoordinatorInterceptor#interceptTransactionContextMethod(...) 方法进行处理。

ResourceCoordinatorInterceptor 实现代码如下:

public class ResourceCoordinatorInterceptor {

    private TransactionManager transactionManager;

    public Object interceptTransactionContextMethod(ProceedingJoinPoint pjp) throws Throwable {
        Transaction transaction = transactionManager.getCurrentTransaction();
        if (transaction != null) {
            switch (transaction.getStatus()) {
                case TRYING:
                    // 添加事务参与者
                    enlistParticipant(pjp);
                    break;
                case CONFIRMING:
                    break;
                case CANCELLING:
                    break;
            }
        }
        // 执行方法原逻辑
        return pjp.proceed(pjp.getArgs());
    }
}
  • 当事务处于 TransactionStatus.TRYING 时,调用 #enlistParticipant(...) 方法,添加事务参与者。
  • 调用 ProceedingJoinPoint#proceed(...) 方法,执行方法原逻辑。

ResourceCoordinatorInterceptor#enlistParticipant() 实现代码如下:

private void enlistParticipant(ProceedingJoinPoint pjp) throws IllegalAccessException, InstantiationException {
   // 获得 @Compensable 注解
   Method method = CompensableMethodUtils.getCompensableMethod(pjp);
   if (method == null) {
       throw new RuntimeException(String.format("join point not found method, point is : %s", pjp.getSignature().getName()));
   }
   Compensable compensable = method.getAnnotation(Compensable.class);
   // 获得 确认执行业务方法 和 取消执行业务方法
   String confirmMethodName = compensable.confirmMethod();
   String cancelMethodName = compensable.cancelMethod();
   // 获取 当前线程事务第一个(头部)元素
   Transaction transaction = transactionManager.getCurrentTransaction();
   // 创建 事务编号
   TransactionXid xid = new TransactionXid(transaction.getXid().getGlobalTransactionId());
   // TODO
   if (FactoryBuilder.factoryOf(compensable.transactionContextEditor()).getInstance().get(pjp.getTarget(), method, pjp.getArgs()) == null) {
       FactoryBuilder.factoryOf(compensable.transactionContextEditor()).getInstance().set(new TransactionContext(xid, TransactionStatus.TRYING.getId()), pjp.getTarget(), ((MethodSignature) pjp.getSignature()).getMethod(), pjp.getArgs());
   }
   // 获得类
   Class targetClass = ReflectionUtils.getDeclaringType(pjp.getTarget().getClass(), method.getName(), method.getParameterTypes());
   // 创建 确认执行方法调用上下文 和 取消执行方法调用上下文
   InvocationContext confirmInvocation = new InvocationContext(targetClass,
           confirmMethodName,
           method.getParameterTypes(), pjp.getArgs());
   InvocationContext cancelInvocation = new InvocationContext(targetClass,
           cancelMethodName,
           method.getParameterTypes(), pjp.getArgs());
   // 创建 事务参与者
   Participant participant =
           new Participant(
                   xid,
                   confirmInvocation,
                   cancelInvocation,
                   compensable.transactionContextEditor());
   // 添加 事务参与者 到 事务
   transactionManager.enlistParticipant(participant);
}
  • 调用 CompensableMethodUtils#getCompensableMethod(...) 方法,获得带 @Compensable 注解的方法。
  • 调用 #getCurrentTransaction() 方法, 获取事务。
  • 调用 TransactionXid 构造方法,创建分支事务编号。实现代码如下:

    /**
     * 全局事务编号
     */
    private byte[] globalTransactionId;
    /**
     * 分支事务编号
     */
    private byte[] branchQualifier;
    
    public TransactionXid(byte[] globalTransactionId) {
       this.globalTransactionId = globalTransactionId;
       branchQualifier = uuidToByteArray(UUID.randomUUID()); // 生成 分支事务编号
    }
    • 分支事务编号( branchQualifier ) 需要生成。
  • TODO TransactionContext 和 Participant 的关系。

  • 调用 ReflectionUtils#getDeclaringType(...) 方法,获得声明 @Compensable 方法的实际类。实现代码如下:

    public static Class getDeclaringType(Class aClass, String methodName, Class<?>[] parameterTypes) {
       Method method;
       Class findClass = aClass;
       do {
           Class[] clazzes = findClass.getInterfaces();
           for (Class clazz : clazzes) {
               try {
                   method = clazz.getDeclaredMethod(methodName, parameterTypes);
               } catch (NoSuchMethodException e) {
                   method = null;
               }
               if (method != null) {
                   return clazz;
               }
           }
           findClass = findClass.getSuperclass();
       } while (!findClass.equals(Object.class));
       return aClass;
    }
  • 调用 InvocationContext 构造方法,分别创建确认执行方法调用上下文和取消执行方法调用上下文。实现代码如下:

    /**
    * 类
    */
    private Class targetClass;
    /**
    * 方法名
    */
    private String methodName;
    /**
    * 参数类型数组
    */
    private Class[] parameterTypes;
    /**
    * 参数数组
    */
    private Object[] args;
    
    public InvocationContext(Class targetClass, String methodName, Class[] parameterTypes, Object... args) {
      this.methodName = methodName;
      this.parameterTypes = parameterTypes;
      this.targetClass = targetClass;
      this.args = args;
    }
  • 调用 Participant 构造方法,创建事务参与者。实现代码如下:

    public class Participant implements Serializable {
    
        private static final long serialVersionUID = 4127729421281425247L;
    
        /**
         * 事务编号
         */
        private TransactionXid xid;
        /**
         * 确认执行业务方法调用上下文
         */
        private InvocationContext confirmInvocationContext;
        /**
         * 取消执行业务方法
         */
        private InvocationContext cancelInvocationContext;
        /**
         * 执行器
         */
        private Terminator terminator = new Terminator();
        /**
         * 事务上下文编辑
         */
        Class<? extends TransactionContextEditor> transactionContextEditorClass;
    
        public Participant() {
        }
    
        public Participant(TransactionXid xid, InvocationContext confirmInvocationContext, InvocationContext cancelInvocationContext, Class<? extends TransactionContextEditor> transactionContextEditorClass) {
            this.xid = xid;
            this.confirmInvocationContext = confirmInvocationContext;
            this.cancelInvocationContext = cancelInvocationContext;
            this.transactionContextEditorClass = transactionContextEditorClass;
        }
    }
  • 调用 TransactionManager#enlistParticipant(...) 方法,添加事务参与者到事务。

666. 彩蛋

受限于本人的能力,蛮多处表达不够清晰或者易懂,非常抱歉。如果你对任何地方有任何疑问,欢迎添加本人微信号( wangwenbin-server ),期待与你的交流。不限于 TCC,也可以是分布式事务,也可以是微服务,以及等等。

外送一本武林秘籍:带中文注释的 TCC-Transaction 仓库地址,目前正在慢慢完善。传送门:https://github.com/YunaiV/tcc-transaction。

再送一本葵花宝典:《TCC型分布式事务原理和实现》系列。

胖友,分享一个朋友圈可好?

Springboot 集成Tcc-transaction1 将所有的tcc依赖包 api, core, spring, dubbo加入maven本地仓库添加依赖包添加配置文件修改配置Springboot读取配置文件添加事 立即下载

相关推荐

从GEFCom到UCI:手把手教你构建电力负荷时空预测模型(Python版)

本文详细介绍了如何从GEFCom到UCI数据集构建电力负荷时空预测模型(Python版),涵盖数据集解析、时空特征工程、模型架构设计及工业部署优化。通过多任务图神经网络(MTGNN)实现高精度预测,并结合边缘计算和在线学习机制提升实际应用效果,为能源管理系统提供可靠解决方案。

lambda的博客 814

分布式事务之TCC事务

2019独角兽企业重金招聘Python工程师标准>>> ...

weixin_33672400的博客 407

手把手教你用TLP350驱动IGBT:光耦隔离驱动电路完整设计教程

本文详细介绍了如何使用TLP350光耦隔离驱动电路设计IGBT驱动方案。从TLP350芯片特性分析到驱动电路架构设计,包括信号调理、自举电源和栅极控制网络,再到PCB布局优化和保护电路设计,提供了完整的实战指南。通过实测波形分析和故障排查,帮助工程师快速掌握IGBT驱动电路的设计要点和进阶技巧。

weixin_30566063的博客 831

TCC-Transaction 源码分析 —— TCC 实现

摘要: 原创出处 http://www.iocoder.cn/TCC-Transaction/tcc-core 「芋道源码」欢迎转载,保留摘要,谢谢! 本文主要基于 TCC-Transaction 1.2.3.3 正式版 1. 概述 2. TCC 原理 3. TCC-Transaction 原理 4. 事务与参与者 4.1 事务 4.2 参与者 5. 事务管理器 5.1 发起根事务 5....

weixin_34175509的博客 505

有限元中的对称魔法:用1/6模型算整个涡轮叶片(含MATLAB代码)

本文深入解析了有限元分析中针对循环对称结构的高效求解策略。通过利用涡轮叶片等结构的几何重复性,仅需对1/6基本扇区建模并施加循环对称条件,即可精确推演整体力学行为,大幅降低计算规模。文章从数学原理推导到MATLAB代码实现,提供了完整的实战指南,适用于旋转机械的静力、模态及谐响应分析。

fire9的博客 312

RTC 实时时钟实验

如果在 RTC_CR 寄存器中设置了相应的允许位,则在每个TR_CLK 周期中 RTC 产生一个中断(秒中断)。void BKP_WriteBackupRegister(uint16_t BKP_DR, uint16_t Data) // 往备份区域写用户数据的函数 (这个函数的第一个参数就是寄存器的标号了,这个是通过宏定义定义的)存储在 RTC_ALR 寄存器中的可编程时间相比较,如果 RTC_CR 控制寄存器中设置了相应允许位,比较匹配时将产生一个闹钟中断。寄存器操作完成,并同步之后,设置秒钟中断。

m0_55996456的博客 1206

TCC-Transaction 分布式事务 —— 项目实战

推荐 Spring Boot/Cloud 视频: Java 微服务实践 - Spring Boot Java 微服务实践 - Spring Cloud 本文主要基于 TCC-Transaction 1.2.3.3 正式版 1. 概述 本文分享 TCC 项目实战。以官方 Maven项目 tcc-transaction-http-sample 为例子( tcc-transaction-dubbo-...

qq_43253123的博客 1万+

基于PLC的全自动洗衣机控制系统+控制程序

本设计使用PLC控制系统替换了传统的继电器控制系统,实现了全自动洗衣机在硬件方面的提升,丰富了全自动洗衣机在软件方面的功能,提高了全自动洗衣机的洗衣效率,基本可以满足用户的洗衣需求。

zzzz114231的博客 8958

tcc分布式事务_分布式事务之TCC事务模型

正文我们先套一个业务场景进去,如下图所示那页面点了支付按钮,调用支付服务,那我们后台要实现下面三个步骤[1] 订单服务-修改订单状态[2] 账户服务-扣减金钱[3] 库存服务-扣减库存达到事务的效果,要么一起成功,要么一起失败!就要采取TCC分布式事务方案!概念TCC的全称是(Try-Confirm-Cancel)。如下图所示ps:TCC又可以被称为两阶段补偿事务,第一阶段try只是预留资源,第二...

weixin_32200323的博客 175

Codex 接入自定义大模型终极教程:插件解锁、会话管理、国产模型一键搞定

🚀 Codex 默认只能使用 OpenAI 官方模型?这篇文章带你从零接入 DeepSeek、通义千问、GLM 等国产大模型,并彻底解锁插件、会话删除、多模型切换等隐藏功能。配置原理、常见坑点、傻瓜式增强工具分享,小白也能轻松上手!🔥

XiaoqiangClub的博客 3160

【推荐100个unity插件】基于关节物理控制的自行车、电动车、摩托车模拟解决方案——Simple Bicycle Physics

摘要 "简易自行车物理"是Unity的自行车模拟资源包,支持Animation Rigging,实现基于关节物理的自行车控制。兼容所有平台和渲染管线,包含预制体、材质、脚本等资源。核心脚本Bicycle Controller管理自行车物理属性,支持自定义角色设置和移动端控制。安装后,用户可快速配置骑行场景,调整转向、速度、重心等参数,并支持地面贴合、兔跳等功能。适用于开发各类自行车模拟游戏和应用。 (字数:149)

向宇的博客,专注php/web全栈 unity游戏开发,欢迎大家评论纠错 1367

视频教程-分布式事务管理器tcc-transaction实战加源码分析(纯java实现)-Java

分布式事务管理器tcc-transaction实战加源码分析(纯java实现) ...

weixin_34651901的博客 351

少儿学编程系列--使用递归画出龙形曲线DragonCurve

龙形曲线(Dragon Curve) 龙形曲线(Dragon Curve)又叫分形龙,是一种自相似碎形曲线的统称,因形似龙的蜿蜒盘曲而得名 使用黄金比例画龙形曲线 根据黄金比例画一条龙曲线。每次递归,第一步向左转32.89度,移动0.74倍原距离;第二个递归步骤向右转46.99度,移动原来距离的0.55倍。请查看这个网页(https://larryriddle.agnesscott.org/ifs/heighway/goldenDragon.htm)了解关于龙形黄线数学的细节 龙形曲线效果 .

penriver的博客 2300

@transaction 提交事务_分布式事务 TCC-Transaction 源码分析——TCC 实现

1. 概述本文分享 TCC 实现。主要涉及如下三个 Maven 项目:tcc-transaction-core :tcc-transaction 底层实现。tcc-transaction-api :tcc-transaction 使用 API。tcc-transaction-spring :tcc-transaction Spring 支持。你行好事会因为得到赞赏而愉悦同理,开源项目贡献者会因为 ...

weixin_42515120的博客 284

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

分布式学习笔记十三:分布式事务 TCC-Transaction 源码分析 —— TCC 实现

本文主要基于 TCC-Transaction 1.2.3.3 正式版 1. 概述 本文分享 TCC 实现。主要涉及如下三个 Maven 项目: tcc-transaction-core :tcc-transaction 底层实现。 tcc-transaction-api :tcc-transaction 使用 API。 tcc-transaction-spring :tcc-transa...

畅志聪的专栏 902

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

分布式事务 TCC-Transaction 源码分析 —— TCC 实现(转)

原文链接   https://cloud.tencent.com/developer/article/1049345

Thinking In Java 395

TCC-Transaction 源码分析 —— Dubbo 支持

本文详细介绍了TCC-Transaction框架与Dubbo的集成实现。该方案通过Dubbo Filter机制拦截服务调用,实现TCC模式(Try-Confirm-Cancel)的分布式事务管理。核心组件包括事务上下文过滤器、消费者/提供者端处理逻辑、事务参与者注册等模块。框架支持事务上下文传播、多种异常处理机制和事务恢复功能,并提供了连接池优化、事务超时配置等性能优化措施。通过转账业务示例展示了实际应用场景,体现了该方案在分布式系统中的事务处理能力与Dubbo集成优势。

油墨香^-^的博客 1068

tcc-transaction源码详解

本文主要介绍TCC的原理,以及从代码的角度上分析如何实现的;不涉及具体使用示例。本文通过分析tcc-transaction源码带大家了解TCC分布式事务的实现原理。 需要注意的是,本文所有代码都基于master-1.7.x分支,不同版本的源码会存在一定的差异。完整代码注释请参考:bigcoder84/tcc-transaction 一. 概述 1.1 项目模块 本文对 tcc-transaction 源码分析。主要涉及如下四个模块: tcc-transaction-core:tcc-transaction

听得到微笑的博客 4447

TCC-Transaction 源码分析 —— 运维平台

TCC-Transaction运维平台是一个基于SpringBoot+Vue.js的分布式事务管理系统,提供全生命周期的事务监控和管理功能。平台采用前后端分离架构,后端包含数据访问层、服务层和控制层,实现事务查询、手动恢复、统计分析等核心功能;前端基于Vue.js和Element UI构建可视化界面,支持事务列表展示、详情查看和操作管理。系统特色包括:实时监控(通过WebSocket实现)、智能告警(基于规则引擎)、多维统计分析和动态配置管理。部署方案采用Nginx+SpringBoot+MySQL架构,支

油墨香^-^的博客 730

TCC-Transaction 源码分析 —— TCC 实现详解

本文深入分析了TCC-Transaction分布式事务框架的核心架构与实现机制。该框架基于TCC(Try-Confirm-Cancel)模式,通过事务管理器协调分布式事务执行,包含四大核心组件:事务拦截器、参与者管理器、恢复调度器和存储模块。文章详细阐述了事务生命周期的源码实现,包括Try阶段的资源预留、Confirm/Cancel阶段的最终操作,以及基于定时任务的事务恢复机制。框架采用Spring AOP实现方法拦截,支持多种存储后端,并提供完善的异常处理和监控功能。通过异步Confirm、批量处理等优化

油墨香^-^的博客 525

TCC-Transaction 源码分析 —— 项目实战

TCC-Transaction框架是一个基于Spring的分布式事务解决方案,采用Try-Confirm-Cancel三阶段模式确保最终一致性。文章详细介绍了框架的核心实现:1.通过@Compensable注解定义事务方法;2.事务拦截器管理Try/Confirm/Cancel流程;3.事务恢复机制定期处理异常事务。以电商订单系统为例,展示了订单、库存、账户等服务的TCC实现方案,包括资源预留(Try)、确认(Confirm)和取消(Cancel)的具体业务逻辑。此外还分析了Redis存储实现、性能优化策略

油墨香^-^的博客 621

TCC-Transaction 源码分析 —— 事务存储器

本文深入分析了TCC-Transaction分布式事务框架中事务存储器的设计与实现。事务存储器作为核心组件,负责持久化事务状态、支持事务恢复,其架构设计采用接口抽象支持JDBC和Redis等多种存储介质。JDBC实现通过数据库表存储事务日志,使用乐观锁保证并发安全;Redis实现则采用Hash结构存储事务信息。文章详细介绍了事务创建、更新和恢复的关键流程,分析了Java序列化和JSON序列化机制,阐述了事务状态管理与恢复策略,并提出了批量操作和缓存优化等性能提升方案。该设计体现了可扩展架构、数据一致性和容错

油墨香^-^的博客 587
上一篇: Dubbo源码解析 —— Zookeeper 订阅
下一篇: 注册中心 Eureka 源码解析 —— 项目结构简介
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值