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

TCC-Transaction分布式事务DEMO TCC-Transaction分布式事务DEMO,基于Mysql数据库的事务,包括分布式提交和回滚,例子完成,可以正常跑,基于Maven构建的项目 立即下载

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

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


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


1. 概述

本文分享 事务存储器。主要涉及如下 Maven 项目:

  • tcc-transaction-core :tcc-transaction 底层实现。

在 TCC 的过程中,根据应用内存中的事务信息完成整个事务流程。But 实际业务场景中,将事务信息只放在应用内存中是远远不够可靠的。例如:

  1. 应用进程异常崩溃,未完成的事务信息将丢失。
  2. 应用进程集群,当提供远程服务调用时,事务信息需要集群内共享。
  3. 发起事务的应用需要重启部署新版本,因为各种原因,有未完成的事务。

因此,TCC-Transaction 将事务信息添加到内存中的同时,会使用外部存储进行持久化。目前提供四种外部存储:

  • JdbcTransactionRepository,JDBC 事务存储器
  • RedisTransactionRepository,Redis 事务存储器
  • ZooKeeperTransactionRepository,Zookeeper 事务存储器
  • FileSystemTransactionRepository,File 事务存储器

本文涉及到的类关系如下图( 打开大图 ):

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

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

2. 序列化

在《TCC-Transaction 源码分析 —— TCC 实现》「4. 事务与参与者」,可以看到 Transaction 是一个比较复杂的对象,内嵌 Participant 数组,而 Participant 本身也是复杂的对象,内嵌了更多的其他对象,因此,存储器在持久化 Transaction 时,需要序列化后才能存储。

org.mengyun.tcctransaction.serializer.ObjectSerializer,对象序列化接口。实现代码如下:

public interface ObjectSerializer<T> {

    byte[] serialize(T t);

    T deserialize(byte[] bytes);

}

目前提供 JDK自带序列化 和 Kyro序列化 两种实现。

2.1 JDK 序列化实现

org.mengyun.tcctransaction.serializer.JdkSerializationSerializer,JDK 序列化实现。比较易懂,点击链接直接查看。

TCC-Transaction 使用的默认的序列化。

2.2 Kyro 序列化实现

org.mengyun.tcctransaction.serializer.KryoTransactionSerializer,Kyro 序列化实现。比较易懂,点击链接直接查看。

2.3 JSON 序列化实现

JDK 和 Kyro 的序列化实现,肉眼无法直观具体存储事务的信息,你可以通过实现 ObjectSerializer 接口,实现自定义的 JSON 序列化。

3. 存储器

org.mengyun.tcctransaction.TransactionRepository,事务存储器接口。实现代码如下:

public interface TransactionRepository {

    /**
     * 新增事务
     *
     * @param transaction 事务
     * @return 新增数量
     */
    int create(Transaction transaction);

    /**
     * 更新事务
     *
     * @param transaction 事务
     * @return 更新数量
     */
    int update(Transaction transaction);

    /**
     * 删除事务
     *
     * @param transaction 事务
     * @return 删除数量
     */
    int delete(Transaction transaction);

    /**
     * 获取事务
     *
     * @param xid 事务编号
     * @return 事务
     */
    Transaction findByXid(TransactionXid xid);

    /**
     * 获取超过指定时间的事务集合
     *
     * @param date 指定时间
     * @return 事务集合
     */
    List<Transaction> findAllUnmodifiedSince(Date date);
}

不同的存储器通过实现该接口,提供事务的增删改查功能。

3.1 可缓存的事务存储器抽象类

org.mengyun.tcctransaction.repository.CachableTransactionRepository,可缓存的事务存储器抽象类,实现增删改查事务时,同时缓存事务信息。在上面类图,我们也可以看到 TCC-Transaction 自带的多种存储器都继承该抽象类。

CachableTransactionRepository 构造方法实现代码如下:

public abstract class CachableTransactionRepository implements TransactionRepository {

    /**
     * 缓存过期时间
     */
    private int expireDuration = 120;
    /**
     * 缓存
     */
    private Cache<Xid, Transaction> transactionXidCompensableTransactionCache;

    public CachableTransactionRepository() {
        transactionXidCompensableTransactionCache = CacheBuilder.newBuilder().expireAfterAccess(expireDuration, TimeUnit.SECONDS).maximumSize(1000).build();
    }
}
  • 使用 Guava Cache 内存缓存事务信息,设置最大缓存个数为 1000 个,缓存过期时间为最后访问时间 120 秒。

#create(...) 实现代码如下:

@Override
public int create(Transaction transaction) {
   int result = doCreate(transaction);
   if (result > 0) {
       putToCache(transaction);
   }
   return result;
}

/**
* 添加到缓存
*
* @param transaction 事务
*/
protected void putToCache(Transaction transaction) {
   transactionXidCompensableTransactionCache.put(transaction.getXid(), transaction);
}

/**
* 新增事务
*
* @param transaction 事务
* @return 新增数量
*/
protected abstract int doCreate(Transaction transaction);
  • 调用 #doCreate(...) 方法,新增事务。新增成功后,调用 #putToCache(...) 方法,添加事务到缓存。
  • #doCreate(...) 为抽象方法,子类实现该方法,提供新增事务功能。

#update(...) 实现代码如下:

@Override
public int update(Transaction transaction) {
   int result = 0;
   try {
       result = doUpdate(transaction);
       if (result > 0) {
           putToCache(transaction);
       } else {
           throw new OptimisticLockException();
       }
   } finally {
       if (result <= 0) { // 更新失败,移除缓存。下次访问,从存储器读取
           removeFromCache(transaction);
       }
   }
   return result;
}

/**
* 移除事务从缓存
*
* @param transaction 事务
*/
protected void removeFromCache(Transaction transaction) {
   transactionXidCompensableTransactionCache.invalidate(transaction.getXid());
}

/**
* 更新事务
*
* @param transaction 事务
* @return 更新数量
*/
protected abstract int doUpdate(Transaction transaction);
  • 调用 #doUpdate(...) 方法,更新事务。
    • 若更新成功后,调用 #putToCache(...) 方法,添加事务到缓存。
    • 若更新失败后,抛出 OptimisticLockException 异常。有两种情况会导致更新失败:(1) 该事务已经被提交,被删除;(2) 乐观锁更新时,缓存的事务的版本号( Transaction.version )和存储器里的事务的版本号不同,更新失败。为什么?在《TCC-Transaction 源码分析 —— 事务恢复》详细解析。更新失败,意味着缓存已经不不一致,调用 #removeFromCache(...) 方法,移除事务从缓存中。
  • #doUpdate(...) 为抽象方法,子类实现该方法,提供更新事务功能。

#delete(...) 实现代码如下:

@Override
public int delete(Transaction transaction) {
   int result;
   try {
       result = doDelete(transaction);
   } finally {
       removeFromCache(transaction);
   }
   return result;
}

/**
* 删除事务
*
* @param transaction 事务
* @return 删除数量
*/
protected abstract int doDelete(Transaction transaction);
  • 调用 #doDelete(...) 方法,删除事务。
  • 调用 #removeFromCache(...) 方法,移除事务从缓存中。
  • #doDelete(...) 为抽象方法,子类实现该方法,提供删除事务功能。

#findByXid(...) 实现代码如下:

@Override
public Transaction findByXid(TransactionXid transactionXid) {
   Transaction transaction = findFromCache(transactionXid);
   if (transaction == null) {
       transaction = doFindOne(transactionXid);
       if (transaction != null) {
           putToCache(transaction);
       }
   }
   return transaction;
}

/**
* 获得事务从缓存中
*
* @param transactionXid 事务编号
* @return 事务
*/
protected Transaction findFromCache(TransactionXid transactionXid) {
   return transactionXidCompensableTransactionCache.getIfPresent(transactionXid);
}

/**
* 查询事务
*
* @param xid 事务编号
* @return 事务
*/
protected abstract Transaction doFindOne(Xid xid);
  • 调用 #findFromCache() 方法,优先从缓存中获取事务。
  • 调用 #doFindOne() 方法,缓存中事务不存在,从存储器中获取。获取到后,调用 #putToCache() 方法,添加事务到缓存中。
  • #doFindOne(...) 为抽象方法,子类实现该方法,提供查询事务功能。

#findAllUnmodifiedSince(...) 实现代码如下:

@Override
public List<Transaction> findAllUnmodifiedSince(Date date) {
   List<Transaction> transactions = doFindAllUnmodifiedSince(date);
   // 添加到缓存
   for (Transaction transaction : transactions) {
       putToCache(transaction);
   }
   return transactions;
}

/**
* 获取超过指定时间的事务集合
*
* @param date 指定时间
* @return 事务集合
*/
protected abstract List<Transaction> doFindAllUnmodifiedSince(Date date);
  • 调用 #findAllUnmodifiedSince(...) 方法,从存储器获取超过指定时间的事务集合。调用 #putToCache(...) 方法,循环事务集合添加到缓存。
  • #doFindAllUnmodifiedSince(...) 为抽象方法,子类实现该方法,提供获取超过指定时间的事务集合功能。

3.2 JDBC 事务存储器

org.mengyun.tcctransaction.repository.JdbcTransactionRepository,JDBC 事务存储器,通过 JDBC 驱动,将 Transaction 存储到 MySQL / Oracle / PostgreSQL / SQLServer 等关系数据库。实现代码如下:

public class JdbcTransactionRepository extends CachableTransactionRepository {

    /**
     * 领域
     */
    private String domain;
    /**
     * 表后缀
     */
    private String tbSuffix;
    /**
     * 数据源
     */
    private DataSource dataSource;
    /**
     * 序列化
     */
    private ObjectSerializer serializer = new JdkSerializationSerializer();
}
  • domain,领域,或者也可以称为模块名,应用名,用于唯一标识一个资源。例如,Maven 模块 xxx-order,我们可以配置该属性为 ORDER。
  • tbSuffix,表后缀。默认存储表名为 TCC_TRANSACTION,配置表名后,为 TCC_TRANSACTION${tbSuffix}。
  • dataSource,存储数据的数据源。
  • serializer,序列化。当数据库里已经有数据的情况下,不要更换别的序列化,否则会导致反序列化报错。建议:TCC-Transaction 存储时,新增字段,记录序列化的方式。

表结构如下:

CREATE TABLE `TCC_TRANSACTION` (
  `TRANSACTION_ID` int(11) NOT NULL AUTO_INCREMENT,
  `DOMAIN` varchar(100) DEFAULT NULL,
  `GLOBAL_TX_ID` varbinary(32) NOT NULL,
  `BRANCH_QUALIFIER` varbinary(32) NOT NULL,
  `CONTENT` varbinary(8000) DEFAULT NULL,
  `STATUS` int(11) DEFAULT NULL,
  `TRANSACTION_TYPE` int(11) DEFAULT NULL,
  `RETRIED_COUNT` int(11) DEFAULT NULL,
  `CREATE_TIME` datetime DEFAULT NULL,
  `LAST_UPDATE_TIME` datetime DEFAULT NULL,
  `VERSION` int(11) DEFAULT NULL,
  PRIMARY KEY (`TRANSACTION_ID`),
  UNIQUE KEY `UX_TX_BQ` (`GLOBAL_TX_ID`,`BRANCH_QUALIFIER`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8
  • TRANSACTION_ID,仅仅数据库自增,无实际用途。
  • CONTENT,Transaction 序列化。

ps:点击链接查看 JdbcTransactionRepository 代码实现,已经添加完整中文注释。

3.3 Redis 事务存储器

org.mengyun.tcctransaction.repository.RedisTransactionRepository,Redis 事务存储器,将 Transaction 存储到 Redis。实现代码如下:

public class RedisTransactionRepository extends CachableTransactionRepository {

    /**
     * Jedis Pool
     */
    private JedisPool jedisPool;
    /**
     * key 前缀
     */
    private String keyPrefix = "TCC:";
    /**
     * 序列化
     */
    private ObjectSerializer serializer = new JdkSerializationSerializer();

}
  • keyPrefix,key 前缀。类似 JdbcTransactionRepository 的 domain 属性。

一个事务存储到 Reids,使用 Redis 的数据结构为 HASHES。

  • key : 使用 keyPrefix + xid,实现代码如下:

    /**
    * 创建事务的 Redis Key
    *
    * @param keyPrefix key 前缀
    * @param xid 事务
    * @return Redis Key
    */
    public static byte[] getRedisKey(String keyPrefix, Xid xid) {
       byte[] prefix = keyPrefix.getBytes();
       byte[] globalTransactionId = xid.getGlobalTransactionId();
       byte[] branchQualifier = xid.getBranchQualifier();
       // 拼接 key
       byte[] key = new byte[prefix.length + globalTransactionId.length + branchQualifier.length];
       System.arraycopy(prefix, 0, key, 0, prefix.length);
       System.arraycopy(globalTransactionId, 0, key, prefix.length, globalTransactionId.length);
       System.arraycopy(branchQualifier, 0, key, prefix.length + globalTransactionId.length, branchQualifier.length);
       return key;
    }
  • HASHES 的 key :使用 version。

    • 添加和更新 Transaction 时,使用 Redis HSETNX,不存在当前版本的值时,进行设置,重而实现类似乐观锁的更新。
    • 读取 Transaction 时,使用 Redis HGETALL,将 Transaction 所有 version 对应的值读取到内存后,取 version 值最大的对应的值。
  • HASHES 的 value :调用 TransactionSerializer#serialize(...) 方法,序列化 Transaction。实现代码如下:

    public static byte[] serialize(ObjectSerializer serializer, Transaction transaction) {
       Map<String, Object> map = new HashMap<String, Object>();
       map.put("GLOBAL_TX_ID", transaction.getXid().getGlobalTransactionId());
       map.put("BRANCH_QUALIFIER", transaction.getXid().getBranchQualifier());
       map.put("STATUS", transaction.getStatus().getId());
       map.put("TRANSACTION_TYPE", transaction.getTransactionType().getId());
       map.put("RETRIED_COUNT", transaction.getRetriedCount());
       map.put("CREATE_TIME", transaction.getCreateTime());
       map.put("LAST_UPDATE_TIME", transaction.getLastUpdateTime());
       map.put("VERSION", transaction.getVersion());
       // 序列化
       map.put("CONTENT", serializer.serialize(transaction));
       return serializer.serialize(map);
    }
    • TODO 为什么序列化两次

在实现 #doFindAllUnmodifiedSince(date) 方法,无法像数据库使用时间条件进行过滤,因此,加载所有事务后在内存中过滤。实现代码如下:

@Override
protected List<Transaction> doFindAllUnmodifiedSince(Date date) {
   // 获得所有事务
   List<Transaction> allTransactions = doFindAll();
   // 过滤时间
   List<Transaction> allUnmodifiedSince = new ArrayList<Transaction>();
   for (Transaction transaction : allTransactions) {
       if (transaction.getLastUpdateTime().compareTo(date) < 0) {
           allUnmodifiedSince.add(transaction);
       }
   }
   return allUnmodifiedSince;
}

ps:点击链接查看 RedisTransactionRepository 代码实现,已经添加完整中文注释。

FROM 《TCC-Transaction 官方文档 —— 使用指南1.2.x》
使用 RedisTransactionRepository 需要配置 Redis 服务器如下:
appendonly yes
appendfsync always

3.4 Zookeeper 事务存储器

org.mengyun.tcctransaction.repository.ZooKeeperTransactionRepository,Zookeeper 事务存储器,将 Transaction 存储到 Zookeeper。实现代码如下:

public class ZooKeeperTransactionRepository extends CachableTransactionRepository {

    /**
     * Zookeeper 服务器地址数组
     */
    private String zkServers;
    /**
     * Zookeeper 超时时间
     */
    private int zkTimeout;
    /**
     * TCC 存储 Zookeeper 根目录
     */
    private String zkRootPath = "/tcc";
    /**
     * Zookeeper 连接
     */
    private volatile ZooKeeper zk;
    /**
     * 序列化
     */
    private ObjectSerializer serializer = new JdkSerializationSerializer();
}
  • zkRootPath,存储 Zookeeper 根目录,类似 JdbcTransactionRepository 的 domain 属性。

一个事务存储到 Zookeeper,使用 Zookeeper 的持久数据节点。

  • path:${zkRootPath} + / + ${xid}。实现代码如下:

    // ZooKeeperTransactionRepository.java
    private String getTxidPath(Xid xid) {
       return String.format("%s/%s", zkRootPath, xid);
    }
    
    // TransactionXid.java
    @Override
    public String toString() {
       StringBuilder stringBuilder = new StringBuilder();
       stringBuilder.append("globalTransactionId:").append(UUID.nameUUIDFromBytes(globalTransactionId).toString());
       stringBuilder.append(",").append("branchQualifier:").append(UUID.nameUUIDFromBytes(branchQualifier).toString());
       return stringBuilder.toString();
    }
  • data:调用 TransactionSerializer#serialize(...) 方法,序列化 Transaction。

  • version:使用 Zookeeper 数据节点自带版本功能。这里要注意下,Transaction 的版本从 1 开始,而 Zookeeper 数据节点版本从 0 开始。

ps:点击链接查看 ZooKeeperTransactionRepository 代码实现,已经添加完整中文注释。

另外,在生产上暂时不建议使用 ZooKeeperTransactionRepository,原因有两点:

  • 不支持 Zookeeper 安全认证。
  • 使用 Zookeeper 时,未考虑断网重连等情况。

如果你要使用 Zookeeper 进行事务的存储,可以考虑使用 Apache Curator 操作 Zookeeper,重写 ZooKeeperTransactionRepository 部分代码。

3.5 File 事务存储器

org.mengyun.tcctransaction.repository.FileSystemTransactionRepository,File 事务存储器,将 Transaction 存储到文件系统。

实现上和 ZooKeeperTransactionRepository,区别主要在于不支持乐观锁更新。有兴趣的同学点击链接查看,这里就不拓展开来。

另外,在生产上不建议使用 FileSystemTransactionRepository,因为不支持多节点共享。用分布式存储挂载文件另说,当然还是不建议,因为不支持乐观锁并发更新。

666. 彩蛋

这篇略( 超 )微( 级 )水更,哈哈哈,为《TCC-Transaction 源码分析 —— 事务恢复》做铺垫啦。

使用 RedisTransactionRepository 和 ZooKeeperTransactionRepository 存储事务还是 Get 蛮多点的。

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

YOLO-V8训练自己的数据集之标注样本 四、标注样本 4.1、标注样本概述 4.1.1、样本标注主要方法 4.1.2、标注样本概念 4.1.3、标注样本实现方式 4.1.4、常见标注样本软件 4.2、标注工具LabelImg 4.2.1、LabelImg介绍 4.2.2、LabelImg特点 4.2.3、LabelImg安装方法 4.2.4、LabelImg使用方法 4.3、标注样本实操 4.3.1、安装标注软件Labelimg 4.3.2、Labelimg界面介绍 4.3.3、LabelImg实操过程中常 阅读详情

相关推荐

微前端实战:MicroApp内存泄漏优化策略与性能调优

本文分享了在大型后台管理系统微前端化过程中,使用MicroApp框架时遇到的内存泄漏实战问题与优化策略。通过深入分析沙箱机制,提出动态加载、精准卸载、沙箱配置优化及第三方库补丁等核心方案,并结合Vue/React子应用专项检查清单,有效解决了内存占用飙升问题,为微前端架构的性能调优提供了系统性解决方案。

weixin_29014939的博客 285

源码解读 - Tcc-Transaction框架(一)初探实现思路

前言 一个成熟的开源项目,其代码量还是较为客观的,拿到手通常不知如何下手。那么一套清洗的分析思路尤为重要,帮助自己快速理解作者思路。 1、首要工作是fork一份源码,在这个基础上做一些诸如,添加注释、debug等操作比较方便。 2、查看作者的提交历史,也就是通过git历史来查看这个项目的进化过程。 第一步以及clone到本地,可自行百度如何操作。我们从第二步开始。 正文 1、找到感兴趣...

技术架构公社 773

AMCL代码详解(六)amcl中的重采样

每次都从w1左边的竖线开始转,显而易见,转到w1的概率为0-w1之间的随机数,转到w2的概率为w1到w1+w2之间的随机数,转到w3的概率为w1+w2到w1+w2+w3之间的随机数,后面的依次类推。当某个粒子的权值较大的时候,产生的随机数落在相应区间的概率就会增大,从而实现了对权值大粒子的多次复制,权值小的粒子的剔除。可以看出,在整个重采样的过程中,粒子进行了两次种情况的刷新,一种是随机生成的新的粒子,一种是对原来的粒子的复制。得到的值越大,说明粒子的权重越小,当前粒子的可信度比较小,需要重采样粒子。

YiYeZhiNian的博客 1580

刚柔并济的开源分布式事务解决方案

★作者★张亮,京东数科数据研发负责人,Apache ShardingSphere发起人 & PPMC热爱开源,目前主导开源项目ShardingSphere(原名S...

ShardingSphere官微 2172

新手DIY无人机,从电机到飞控,这份配件清单和避坑指南请收好

本文为无人机DIY新手提供从电机到飞控的完整配件清单和避坑指南。详细解析电机KV值选择、电调匹配、飞控系统调试等核心问题,帮助初学者避开常见雷区,顺利完成首飞。特别推荐FPV竞速机和航拍机的配件组合方案,并附赠实用调试命令和故障排查表。

weixin_27032989的博客 239

告别裸机:在FreeRTOS上为STM32移植SOEM 1.4.0的完整指南

本文详细介绍了在FreeRTOS环境下为STM32H7系列芯片移植SOEM 1.4.0的完整指南,涵盖环境准备、任务架构设计、OSAL层适配及网络驱动优化等关键步骤。通过EtherCAT主站解决方案的实现,帮助开发者构建稳定可靠的工业自动化系统,提升实时通信性能。

weixin_33582311的博客 364

TCC-Transaction原理

本文主要介绍TCC的原理,以及从代码的角度上分析如何实现的;不涉及具体使用示例。本文分析的是github中开源项目tcc-transaction。当然github上有多个tcc项目,但是他们原理相近,所以不过多介绍,有兴趣的小伙伴自行阅读源码。 1 TCC架构 1.1 原理 一个完整的业务活动由一个主业务服务与若干从业务服务组成。 主业务服务负责发起并完成整个业务活动。 从业务服务提供TCC型业务操作。 业务活动管理器控制业务活动的一致性,它登记业务活动中的操作,并在业务活动提交时进行confirm操作

wuzhengfei1112的博客 1683

2026实测可用!4个专业AI Agent Skills垂直搜索平台对比

📊本文以表格形式整理4个实测可用的专业AI Agent Skills垂直搜索平台,涵盖资源规模、适配生态等关键维度🤖,适合开发者按需选择技能获取渠道,解决平台筛选与访问难题✨

XiaoqiangClub的博客 526

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万+

软解调详解

在这个示例中,生成了一个随机的比特序列,将其调制为QPSK信号,添加了高斯白噪声,然后计算了每个比特的LLR,并根据LLR的符号进行了解调判决。软解调是一种基于接收信号的概率估计进行解调的方法。与传统的硬解调相比,软解调不仅考虑了接收信号的幅度和相位信息,还利用统计特性计算每个比特为0或1的概率,从而提高了解调性能。软解调过程中涉及的主要公式包括对数似然比(LLR)的计算公式、信号的概率分布函数以及解调判决公式等。软解调的计算处理流程包括信号接收、预处理、相位估计、LLR计算、解调判决和输出等步骤。

ahah12345678的博客 1227

【常见开源库的二次开发】基于openssl的加密与解密——openssl认识与配置(一)

OpenSSL 是一个开源的软件库,它提供了一系列加密工具和协议,主要用于实现安全通信,如在网络上的数据传输。它支持多种加密算法,包括对称加密、非对称加密、散列函数、伪随机数生成器、数字签名、密钥交换以及证书管理等。

嵌入式技术开发 4165

tcc-transaction源码详解

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

听得到微笑的博客 4447

告警不是闹钟:AI 如何把告警过滤成真正的“求救信号”?

告警不是闹钟:AI 如何把告警过滤成真正的“求救信号”?

Echo_Wish 243

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

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

油墨香^-^的博客 587

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

TMS_WebGMaps_1.9.8.0_Full_Source

TMS_WebGMaps_1.9.8.0_Full_Source 全源码 delphi cbuilder

分布式事务中间件 TCC-Transaction 源码解析合集

目录如下:TCC-Transaction 源码解析 —— 调试环境搭建TCC-Transaction 源码分析 —— TCC 实现TCC-Transaction 源码分析 —— 事务存储...

芋艿V 660

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

基于tcc-transaction spring 和 nutz 容器的分布式事务实现方案

1 背景 分布式事务实现的方案,大体分为三种。第一种是使用控制资源管理层,实现事务两阶段提交两阶段事务(全局事务)。第二种是基于TCC的在业务层,利用反交易实现分布式事务。第三种是蚂蚁金服自己研发的收费的中间件DTX。 全局事务,是反伸缩设计,不适合在分布式系统应用。 TCC能在业务层,实现事务最终一致性,缺点是增加开发工作量。 DTX分析执行的sql,生成提交和回滚,解决了易用性...

soar5237893的博客 899

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

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

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

油墨香^-^的博客 621

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

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

weixin_42073629的博客 657

事务回滚什么意思 try_分布式事务 TCC-Transaction 源码分析——事务恢复

1. 概述本文分享 TCC 恢复。主要涉及如下二个 package 路径下的类:org.mengyun.tcctransaction.recoverRecoverConfig,事务恢复配置接口TransactionRecovery,事务恢复逻辑org.mengyun.tcctransaction.spring.recover :DefaultRecoverConfig,默认事务恢复配置实现Reco...

weixin_35572715的博客 273

TCC-Transaction 源码解析合集

《TCC-Transaction 源码解析 —— 调试环境搭建》《TCC-Transaction 源码分析 —— TCC 实现》《TCC-Transaction 源码解析...

芋道源码 887

分布式事务 TCC-Transaction 源码分析 —— 事务恢复

摘要: 原创出处 http://www.iocoder.cn/TCC-Transaction/transaction-recovery/ 「芋道源码」欢迎转载,保留摘要,谢谢! 本文主要基于 TCC-Transaction 1.2.3.3 正式版 1. 概述 2. 事务重试配置 3. 事务重试定时任务 4. 异常事务恢复 4.1 加载异常事务集合 4.2 恢复异常事务集合 666. 彩...

芋艿V 1398

分布式事务 TCC-Transaction 源码分析 —— 运维平台

本文主要基于 TCC-Transaction 1.2.3.3 正式版1. 概述2. 数据访问层2.1 JDBC 事务 DAO2.2 Redis 事务 DAO3. 控制层3.1 查看未完成的事务列表3.2 重置事务恢复重试次数666. 彩蛋友情提示:欢迎关注公众号【芋道源码】。?关注后,拉你进【源码圈】微信群讨论技术和源码。友情提示:欢迎关注公众号【芋道源码】。?关注后,拉你进【源码圈】微信群讨论技

芋道源码 791
上一篇: 【死磕Java并发】-----J.U.C之读写锁:ReentrantReadWriteLock
下一篇: 注册中心 Eureka 源码解析 —— 调试环境搭建
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值