BestHub
Sign in
Tagged articles
280 articles
Page 2 of 3
Architects Research Society
Architects Research Society
Dec 11, 2022 · Backend Development

Understanding the Saga Pattern for Distributed Transactions in Microservices

The article explains how the Saga pattern—using either choreography or orchestration—enables reliable distributed transactions across microservices by coordinating local ACID operations, handling compensating actions, and addressing the challenges of consistency, rollback, and scalability.

ChoreographyDistributed TransactionsMicroservices
0 likes · 9 min read
Understanding the Saga Pattern for Distributed Transactions in Microservices
Architect
Architect
Nov 22, 2022 · Backend Development

Handling Distributed Transaction Failures in Microservices: Blocking Retry, Async Queue, TCC, and Local Message Table

This article examines common strategies for handling inter‑service call failures in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ‑based transactions, and discusses their advantages, drawbacks, and practical implementation considerations.

Data ConsistencyDistributed TransactionsMicroservices
0 likes · 17 min read
Handling Distributed Transaction Failures in Microservices: Blocking Retry, Async Queue, TCC, and Local Message Table
Top Architect
Top Architect
Nov 19, 2022 · Backend Development

Implementing Distributed Transactions with RocketMQ and SEATA in a Microservice Architecture

This article explains the concept of distributed transactions, presents typical microservice scenarios that generate them, and demonstrates a complete implementation using RocketMQ transactional messages and SEATA, including database schema, producer and consumer code, transaction listeners, and idempotent consumption handling.

Distributed TransactionsJavaRocketMQ
0 likes · 14 min read
Implementing Distributed Transactions with RocketMQ and SEATA in a Microservice Architecture
ITPUB
ITPUB
Nov 17, 2022 · Backend Development

Mastering Distributed Transactions: From Local Basics to Advanced Solutions

This article explains the fundamentals of ACID, compares monolithic and distributed transaction models, and details various distributed transaction strategies—including 2PC, 3PC, TCC, local message tables, MQ transactions, max‑effort notifications, Saga, and Seata—highlighting their mechanisms, trade‑offs, and practical considerations.

2PC3PCDistributed Transactions
0 likes · 20 min read
Mastering Distributed Transactions: From Local Basics to Advanced Solutions
Top Architect
Top Architect
Nov 7, 2022 · Backend Development

Distributed Transaction Solutions: 2PC, TCC, Seata, Reliable Messaging, and Maximum‑Effort Notification

This article explains the fundamentals of transactions, the challenges of distributed transactions, introduces ACID, CAP and BASE theories, and compares practical solutions such as two‑phase commit, TCC, Seata, reliable message‑based eventual consistency, and maximum‑effort notification, concluding with a comparative analysis of their trade‑offs.

2PCBASE theoryCAP theorem
0 likes · 42 min read
Distributed Transaction Solutions: 2PC, TCC, Seata, Reliable Messaging, and Maximum‑Effort Notification
Top Architect
Top Architect
Oct 19, 2022 · Databases

MySQL Replication, High Availability, and Sharding: Concepts and Solutions

This article explains the evolution from single‑node MySQL databases to master‑slave replication, various replication modes, high‑availability strategies, and both vertical and horizontal sharding techniques, while discussing the associated challenges such as distributed transactions, routing, and operational complexity.

Distributed TransactionsReplicationdatabase scaling
0 likes · 11 min read
MySQL Replication, High Availability, and Sharding: Concepts and Solutions
ITPUB
ITPUB
Oct 15, 2022 · Backend Development

How Seata’s AT Mode Solves Distributed Transaction Challenges in Microservices

This article explains the fundamentals of single‑source and multi‑source transactions, reviews common distributed‑transaction patterns such as 2PC, 3PC, TCC, transaction‑status tables and message‑queue based eventual consistency, and then details the implementation and isolation mechanisms of Seata’s AT mode for microservice architectures.

2PCAT ModeDistributed Transactions
0 likes · 34 min read
How Seata’s AT Mode Solves Distributed Transaction Challenges in Microservices
Python Programming Learning Circle
Python Programming Learning Circle
Sep 30, 2022 · Databases

Understanding Database Sharding: Reasons, Methods, and Common Challenges

This article explains why database sharding (both vertical and horizontal) is needed to overcome performance bottlenecks, outlines practical thresholds for splitting tables, describes vertical and horizontal partitioning techniques, and discusses key issues such as distributed transactions, cross‑node queries, global primary keys, and scaling strategies.

Distributed TransactionsScalabilityVertical Partitioning
0 likes · 9 min read
Understanding Database Sharding: Reasons, Methods, and Common Challenges
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Sep 26, 2022 · Databases

Data Migration & Distributed Transactions: XA, BASE, TCC, AT Demystified

This article examines how vertical and horizontal data partitioning leads to migration and consistency challenges, outlines full, full‑plus‑incremental, and binlog‑based migration strategies, and compares strong‑consistency XA transactions with flexible BASE approaches such as TCC and AT, including their components, workflows, advantages, and drawbacks.

BASEData MigrationDistributed Transactions
0 likes · 9 min read
Data Migration & Distributed Transactions: XA, BASE, TCC, AT Demystified
Architecture Digest
Architecture Digest
Sep 9, 2022 · Databases

MySQL Replication, High Availability, and Sharding Strategies

This article explains the evolution from single‑node MySQL to master‑slave replication, various replication modes, high‑availability solutions such as MHA and MGR, and the challenges and techniques of vertical and horizontal sharding for scaling large‑scale internet applications.

Distributed TransactionsReplicationdatabase scaling
0 likes · 12 min read
MySQL Replication, High Availability, and Sharding Strategies
Java High-Performance Architecture
Java High-Performance Architecture
Sep 7, 2022 · Backend Development

Master Distributed Transaction Consistency: 2PC vs MQ Solutions for Java Interviews

This article explains the challenges of distributed transactions in high‑concurrency systems, compares classic two‑phase commit (2PC) with modern message‑queue‑based reliable delivery, outlines their mechanisms, pros and cons, and provides interview‑ready insights and practical implementation tips for Java developers.

2PCDistributed TransactionsJava
0 likes · 15 min read
Master Distributed Transaction Consistency: 2PC vs MQ Solutions for Java Interviews
Alibaba Cloud Native
Alibaba Cloud Native
Aug 3, 2022 · Cloud Native

How RocketMQ Transactional Messages Ensure Distributed Consistency

This article explains the challenges of maintaining atomicity across multiple downstream services in distributed systems and details how RocketMQ's transactional message feature provides a two‑phase commit mechanism, lifecycle, implementation details, and practical usage to achieve eventual consistency.

Cloud NativeDistributed TransactionsMessage Queue
0 likes · 14 min read
How RocketMQ Transactional Messages Ensure Distributed Consistency
AI Illustrated Series
AI Illustrated Series
Jul 28, 2022 · Backend Development

How to Ensure Distributed Transaction Consistency Using Message Queues

This article analyzes the challenges of distributed transactions in multi‑node systems and compares various solutions—including 2PC, 3PC, TCC, Saga, local message tables, and MQ‑based approaches—detailing their mechanisms, trade‑offs, and practical implementations with concrete examples from order and cart services.

2PCDistributed TransactionsKafka
0 likes · 19 min read
How to Ensure Distributed Transaction Consistency Using Message Queues
Top Architect
Top Architect
Jul 4, 2022 · Backend Development

Distributed Transaction Solutions and Message Queue Reliability

This article explains the challenges of distributed transactions, reviews common solutions such as 2PC, 3PC, TCC, Saga, local message tables, and MQ‑based approaches, and discusses how RocketMQ, Kafka, and RabbitMQ handle transactional messaging, message loss prevention, and duplicate processing.

Distributed TransactionsTransactional Messaging
0 likes · 17 min read
Distributed Transaction Solutions and Message Queue Reliability
Programmer DD
Programmer DD
Jul 2, 2022 · Backend Development

How to Achieve Distributed Transaction Consistency with MQs

This article explains the challenges of distributed transactions in multi‑node systems, reviews common solutions such as 2PC, TCC, Saga, and focuses on implementing eventual consistency using message queues, detailing local message tables, MQ‑based transactions, and loss‑prevention techniques across RocketMQ, Kafka, and RabbitMQ.

ConsistencyDistributed TransactionsMQ
0 likes · 19 min read
How to Achieve Distributed Transaction Consistency with MQs
Java Architecture Diary
Java Architecture Diary
May 31, 2022 · Backend Development

Explore Seata 1.5: New Enterprise Features, SkyWalking Integration, and YAML Config

Seata 1.5 introduces a stronger Enterprise edition with 20% lower latency and 30% higher TPS, a graphical console, SkyWalking transaction tracing, YAML configuration support, and detailed deployment steps for integrating Seata into Pig microservice projects, complete with code examples and database setup.

Distributed TransactionsEnterprise EditionSeata
0 likes · 5 min read
Explore Seata 1.5: New Enterprise Features, SkyWalking Integration, and YAML Config
政采云技术
政采云技术
May 19, 2022 · Databases

Distributed Transaction Consistency Solutions

This article explains the fundamentals of distributed transactions, covering ACID, CAP and BASE theories, and reviews various consistency solutions such as two‑phase commit, three‑phase commit, TCC, local message tables, MQ approaches and the Seata framework, highlighting their advantages and drawbacks.

2PCCAPConsistency
0 likes · 18 min read
Distributed Transaction Consistency Solutions
Baidu Geek Talk
Baidu Geek Talk
May 11, 2022 · Backend Development

Distributed Transactions: Concepts, TCC and Saga Patterns, and Practical Implementation

The article explains how micro‑service architectures create data‑consistency challenges that require distributed transaction strategies, compares strong‑consistency protocols like 2PC/3PC with eventual‑consistency approaches such as TCC and Saga patterns, and discusses their trade‑offs, implementation complexity, and suitability for real‑world scenarios like a points‑based sign‑in system.

Distributed TransactionsMicroservicesdatabase-consistency
0 likes · 11 min read
Distributed Transactions: Concepts, TCC and Saga Patterns, and Practical Implementation
macrozheng
macrozheng
May 11, 2022 · Databases

Mastering Database Sharding: When and How to Split Databases and Tables

This article explains the concepts of database and table sharding, why they are needed, various vertical and horizontal splitting strategies, range and hash partitioning methods, their advantages and drawbacks, timing considerations, common challenges such as transactions and distributed IDs, and introduces popular sharding middleware.

Distributed TransactionsVertical Partitioningdatabase sharding
0 likes · 12 min read
Mastering Database Sharding: When and How to Split Databases and Tables
Code Ape Tech Column
Code Ape Tech Column
May 9, 2022 · Databases

Sharding-JDBC Advanced Guide: Configuration and Practical Implementation

This article provides a comprehensive guide to Sharding-JDBC, covering the challenges of database sharding such as distributed transactions, cross‑node joins, pagination, global key collisions, and demonstrates practical configuration and code examples for vertical and horizontal partitioning using Spring Boot.

Distributed TransactionsSharding-JDBCSpring Boot
0 likes · 18 min read
Sharding-JDBC Advanced Guide: Configuration and Practical Implementation
Architect's Journey
Architect's Journey
Apr 27, 2022 · R&D Management

Essential Architecture Terms Every Architect Should Know

This article compiles core architectural concepts—including ROI, SOLID principles, system splitting, isolation, ACID, CAP/BASE, distributed transactions, and capacity estimation—explaining their definitions, practical examples, trade‑offs, and how they guide architects in making informed technical decisions.

CAP theoremDistributed TransactionsSOLID
0 likes · 19 min read
Essential Architecture Terms Every Architect Should Know
Tencent Cloud Developer
Tencent Cloud Developer
Apr 26, 2022 · Backend Development

Understanding Distributed Transactions in Microservices: Challenges and Practical Solutions

The article explains why distributed transactions in micro‑service architectures are hard—due to remote failures, timeouts, and lack of atomic guarantees—and outlines practical approaches such as unique transaction IDs, audit logs, SQL/NoSQL persistence, TCC, Saga or compensation patterns to achieve reliable consistency while balancing availability.

Distributed TransactionsIdempotencytimeout handling
0 likes · 17 min read
Understanding Distributed Transactions in Microservices: Challenges and Practical Solutions
Top Architect
Top Architect
Apr 20, 2022 · Databases

Understanding Distributed Transactions, Consistency Models, and Sharding in Database Systems

This article explains the fundamentals of distributed transactions, the ACID properties, various consistency models (strong, weak, eventual), sharding strategies (vertical and horizontal), the CAP and BASE theories, and the practical implementations of two‑phase, three‑phase, and TCC commit protocols, highlighting their advantages and drawbacks.

2PC3PCBASE
0 likes · 22 min read
Understanding Distributed Transactions, Consistency Models, and Sharding in Database Systems
Top Architect
Top Architect
Mar 16, 2022 · Databases

Comprehensive Guide to Database Sharding: Vertical & Horizontal Partitioning, Global ID Generation, and Distributed Transaction Challenges

This article explains the concepts, methods, advantages, and drawbacks of database sharding, covering vertical and horizontal partitioning, sharding rules, global primary key generation, distributed transaction issues, cross‑node queries, pagination, data migration, and practical case studies, with code examples and diagrams.

Distributed TransactionsGlobal ID Generationdatabase partitioning
0 likes · 24 min read
Comprehensive Guide to Database Sharding: Vertical & Horizontal Partitioning, Global ID Generation, and Distributed Transaction Challenges
IT Architects Alliance
IT Architects Alliance
Feb 17, 2022 · Databases

Understanding Consistency in Distributed Transactions: Strong vs. Weak, CAP Theory, and NewSQL Approaches

This article explains the concept of consistency in distributed transactions, compares strong and weak consistency, relates it to the CAP theorem, and explores theoretical and practical approaches—including XA, NewSQL, and MVCC—to achieve stronger consistency across databases and micro‑services.

ACIDCAP theoremConsistency
0 likes · 13 min read
Understanding Consistency in Distributed Transactions: Strong vs. Weak, CAP Theory, and NewSQL Approaches
Architect's Journey
Architect's Journey
Feb 9, 2022 · Databases

Choosing the Right Database Architecture: A Practical Guide

The article walks through the challenges of growing data volumes, compares master‑slave, vertical, horizontal, and sharding‑plus‑partitioning architectures, explains their pros and cons, and provides concrete guidance on selecting and implementing a suitable database solution, including middleware options and real‑world case studies.

Database ArchitectureDistributed TransactionsScalability
0 likes · 21 min read
Choosing the Right Database Architecture: A Practical Guide
政采云技术
政采云技术
Jan 6, 2022 · Operations

Mastering Seata: A Complete Guide to Distributed Transaction Setup and Configuration

This article provides a comprehensive overview of Seata, covering its origins, supported transaction modes, installation steps, database initialization, detailed configuration for registry and Apollo, client setup, transaction lifecycle components, and scheduled tasks that manage global and branch transaction states.

Distributed TransactionsJavaMicroservices
0 likes · 19 min read
Mastering Seata: A Complete Guide to Distributed Transaction Setup and Configuration
Programmer DD
Programmer DD
Dec 13, 2021 · Backend Development

Seata’s Evolution: From Alibaba’s TXC to Open‑Source Transaction Framework

This article traces Seata’s development from its 2014 origins as Alibaba’s TXC middleware, through its 2016 cloud service launch and 2019 open‑source release, detailing its architecture, module composition, core roles, and the four transaction modes (AT, TCC, Saga, XA) with practical comparisons.

AT ModeDistributed TransactionsSeata
0 likes · 17 min read
Seata’s Evolution: From Alibaba’s TXC to Open‑Source Transaction Framework
IT Architects Alliance
IT Architects Alliance
Dec 6, 2021 · Backend Development

Mastering Distributed Transactions: From XA to TCC and Beyond

This article explains the fundamentals of database transactions, defines distributed transactions, and provides a comprehensive comparison of classic solutions such as XA, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and AT mode, while also covering exception handling and the sub‑transaction barrier technique.

BackendDistributed TransactionsMicroservices
0 likes · 19 min read
Mastering Distributed Transactions: From XA to TCC and Beyond
DataFunSummit
DataFunSummit
Nov 22, 2021 · Databases

Rigid Transactions: Two-Phase Commit (2PC) and Three-Phase Commit (3PC) Explained

This article explains rigid (strong consistency) distributed transactions, detailing the XA protocol and the classic two‑phase commit (2PC) and three‑phase commit (3PC) mechanisms, their workflows, advantages, limitations, and practical considerations for database systems.

Distributed TransactionsXA protocoldatabase-consistency
0 likes · 15 min read
Rigid Transactions: Two-Phase Commit (2PC) and Three-Phase Commit (3PC) Explained
Architect
Architect
Nov 22, 2021 · Backend Development

Design and Evolution of Vivo Mall Product System: Architecture, Challenges, and Solutions

This article details the evolution of Vivo's e‑commerce product system from a monolithic design to a modular, high‑performance backend, describing architectural changes, challenges such as stability, scalability, and data consistency, and the technical solutions implemented to address them.

Distributed TransactionsMicroservicesSystem Architecture
0 likes · 10 min read
Design and Evolution of Vivo Mall Product System: Architecture, Challenges, and Solutions
dbaplus Community
dbaplus Community
Nov 18, 2021 · Databases

When Should You Split Your Database Tables? Practical Guidelines and Real‑World Cases

This article examines the signs that a database table has reached its limits, explains why vertical and horizontal sharding are needed, offers concrete sizing formulas, compares hash, range and consistent‑hash partitioning, and shares large‑scale case studies from Suning, JD, Meituan, Ant Financial and Taobao.

Distributed TransactionsPerformance Optimizationhorizontal partitioning
0 likes · 14 min read
When Should You Split Your Database Tables? Practical Guidelines and Real‑World Cases
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Nov 9, 2021 · Databases

Master‑Slave, Master‑Master, Paxos: Choosing the Right Distributed Transaction Strategy

This article compares common distributed transaction approaches—including Master‑Slave, Master‑Master, two‑phase and three‑phase commit, and Paxos—explains their mechanisms, trade‑offs, and real‑world implementations such as Alibaba’s TCC, GTS, LCN, and TXC, helping architects select the most suitable solution for high‑availability data consistency.

ConsensusDistributed TransactionsMaster‑Slave
0 likes · 23 min read
Master‑Slave, Master‑Master, Paxos: Choosing the Right Distributed Transaction Strategy
Top Architect
Top Architect
Oct 23, 2021 · Backend Development

Distributed Transaction Solutions: Theory, Patterns, and Practical Implementations

This article explains the fundamentals of distributed transactions, compares classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transaction messages, and maximum‑effort notifications, and presents a sub‑transaction barrier technique to handle network anomalies and ensure idempotency, isolation, and rollback safety.

BackendDistributed TransactionsXA
0 likes · 15 min read
Distributed Transaction Solutions: Theory, Patterns, and Practical Implementations
DevOps
DevOps
Oct 20, 2021 · Backend Development

Microservice Architecture: Stability, Service Degradation, Data Consistency, and Migration Practices

This article summarizes the author's extensive experience with microservice adoption, covering its benefits, the challenges of stability, service degradation strategies, distributed transaction patterns, data migration techniques, and practical monitoring using APM tools to help teams successfully transform to microservices.

APMData MigrationDistributed Transactions
0 likes · 35 min read
Microservice Architecture: Stability, Service Degradation, Data Consistency, and Migration Practices
Alibaba Cloud Native
Alibaba Cloud Native
Oct 17, 2021 · Backend Development

How RocketMQ Improves Financial Customer‑Accompaniment Efficiency with Transactional Messaging

This article presents a Boshi Fund case study showing how RocketMQ’s decoupling, topic/tag best practices, and transactional messaging streamline multi‑system financial customer‑accompaniment, enhance operational efficiency, and enable reliable distributed transactions in online fund‑purchase scenarios.

Backend DevelopmentDistributed TransactionsFinancial Services
0 likes · 12 min read
How RocketMQ Improves Financial Customer‑Accompaniment Efficiency with Transactional Messaging
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Oct 7, 2021 · Backend Development

Mastering Distributed Transactions: Theory, Patterns, and Practical Solutions

This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transaction messages, and presents a sub‑transaction barrier technique that gracefully handles idempotency, empty rollbacks, and hanging issues in microservice architectures.

DTMDistributed TransactionsMicroservices
0 likes · 24 min read
Mastering Distributed Transactions: Theory, Patterns, and Practical Solutions
Top Architect
Top Architect
Sep 23, 2021 · Backend Development

Distributed Transaction Solutions: Theory, Patterns, and Practical Implementations

This article explains the fundamentals of distributed transactions, illustrates classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transactional messaging, and maximum‑effort notifications, and introduces a sub‑transaction barrier technique to handle network anomalies in microservice architectures.

BackendDistributed TransactionsXA
0 likes · 19 min read
Distributed Transaction Solutions: Theory, Patterns, and Practical Implementations
Architecture Digest
Architecture Digest
Sep 21, 2021 · Fundamentals

Classic Solutions for Distributed Transactions: Theory and Practical Patterns

This article introduces the fundamental concepts of distributed transactions, explains ACID and BASE properties, and systematically presents classic solutions such as two‑phase commit, SAGA, TCC, local message tables, transaction messages, maximum‑effort notifications, and sub‑transaction barriers for reliable microservice architectures.

Distributed Transactionssagatcc
0 likes · 16 min read
Classic Solutions for Distributed Transactions: Theory and Practical Patterns
Top Architect
Top Architect
Sep 16, 2021 · Backend Development

Understanding Distributed Transaction Protocols: XA, 2PC, 3PC, TCC, Saga, and Reliable Message Consistency

This article explains the principles, advantages, and drawbacks of various distributed transaction solutions—including XA two‑phase commit, three‑phase commit, TCC, Saga, and message‑based eventual consistency—while showing how they are implemented in Java/Spring environments and when each should be used.

3PCBackendDistributed Transactions
0 likes · 16 min read
Understanding Distributed Transaction Protocols: XA, 2PC, 3PC, TCC, Saga, and Reliable Message Consistency
Java Interview Crash Guide
Java Interview Crash Guide
Sep 12, 2021 · Backend Development

Mastering Distributed Transactions: From Blocking Retries to TCC and MQ

This article examines common distributed transaction patterns in micro‑service architectures—including blocking retries, asynchronous queues, TCC compensation, local message tables, and MQ transactions—explaining their mechanisms, advantages, drawbacks, and practical implementation details.

Distributed TransactionsMessage QueueMicroservices
0 likes · 13 min read
Mastering Distributed Transactions: From Blocking Retries to TCC and MQ
Java Interview Crash Guide
Java Interview Crash Guide
Aug 27, 2021 · Backend Development

Mastering Distributed Transactions: From CAP Theory to .NET CAP Solution

This article explores the challenges of distributed transactions, explains database ACID fundamentals, introduces CAP and BASE theories, compares solutions such as two‑phase commit, TCC, local message tables, MQ transactional messages, and the Sagas model, and presents the open‑source .NET CAP framework with its features and implementation details.

.NET CAP2PCBASE theory
0 likes · 17 min read
Mastering Distributed Transactions: From CAP Theory to .NET CAP Solution
IT Architects Alliance
IT Architects Alliance
Aug 26, 2021 · Backend Development

Business Classification and Distributed Transaction Solutions with DTM, SEATA, and RocketMQ

The article classifies common microservice business scenarios, matches each with suitable distributed transaction patterns such as reliable messages, TCC, SAGA, and XA, and demonstrates practical implementations using DTM, SEATA, and RocketMQ with code examples and a feature comparison table.

DTMDistributed TransactionsMicroservices
0 likes · 8 min read
Business Classification and Distributed Transaction Solutions with DTM, SEATA, and RocketMQ
ITPUB
ITPUB
Aug 23, 2021 · Backend Development

Ensuring Microservice Data Consistency: Retry, Queues, TCC & Message Tables

The article examines common strategies for handling service call failures and maintaining data consistency in microservice architectures, comparing blocking retries, asynchronous queues, TCC compensation transactions, local message tables, and MQ transactions, highlighting their trade‑offs, implementation details, and practical considerations.

Data ConsistencyDistributed Transactionstcc
0 likes · 16 min read
Ensuring Microservice Data Consistency: Retry, Queues, TCC & Message Tables
Wukong Talks Architecture
Wukong Talks Architecture
Aug 13, 2021 · Fundamentals

Reliable Message-Based Distributed Transaction Consistency Solution

This article explains the fundamentals of distributed transactions, introduces the reliable message eventual consistency approach, analyzes its challenges such as atomicity and message reliability, and presents two practical solutions—local message tables and RocketMQ transactional messages—along with their advantages and drawbacks.

Distributed TransactionsLocal Message TableRocketMQ
0 likes · 8 min read
Reliable Message-Based Distributed Transaction Consistency Solution
Top Architect
Top Architect
Aug 8, 2021 · Databases

Understanding XA, 2PC, 3PC, JTA, TCC and Reliable Message Consistency in Distributed Transactions

This article explains the principles, workflows, advantages and drawbacks of various distributed transaction solutions—including XA two‑phase commit, Java Transaction API, chained transaction managers, three‑phase commit, TCC, reliable message‑based eventual consistency and maximum‑effort notification—while comparing ACID and BASE theories for modern backend systems.

2PC3PCDistributed Transactions
0 likes · 13 min read
Understanding XA, 2PC, 3PC, JTA, TCC and Reliable Message Consistency in Distributed Transactions
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 4, 2021 · Backend Development

Mastering Seata Global Transactions in Spring Boot 2.2: A Step-by-Step Guide

This article walks through configuring Spring Boot 2.2.11 with Seata 1.3.0, detailing environment setup, dependency configuration, global transaction activation, proxy bean creation, data source proxying, transaction interceptor mechanisms, XID propagation via RestTemplate and Feign, and the complete commit‑and‑rollback workflow.

Distributed TransactionsJavaMicroservices
0 likes · 31 min read
Mastering Seata Global Transactions in Spring Boot 2.2: A Step-by-Step Guide
IT Architects Alliance
IT Architects Alliance
Jul 18, 2021 · Databases

Mastering Distributed Transactions: From Two-Phase Commit to Saga and Beyond

This article explains the fundamentals of distributed transactions, compares classic solutions such as XA, Saga, TCC, local message tables, and transactional messages, discusses their trade‑offs, and introduces advanced techniques like sub‑transaction barriers to handle network anomalies in microservice architectures.

DTMDistributed TransactionsMicroservices
0 likes · 16 min read
Mastering Distributed Transactions: From Two-Phase Commit to Saga and Beyond
Code Ape Tech Column
Code Ape Tech Column
Jul 13, 2021 · Backend Development

Ensuring Consistent Money Transfers: Distributed Transactions & Message Queues Explained

The article examines how to prevent data inconsistency during cross‑service money transfers by using local transactions, two‑phase commit, and message‑queue based eventual consistency, providing detailed code examples, performance considerations, and practical solutions for large‑scale backend systems.

BackendData ConsistencyDistributed Transactions
0 likes · 23 min read
Ensuring Consistent Money Transfers: Distributed Transactions & Message Queues Explained
IT Architects Alliance
IT Architects Alliance
Jul 11, 2021 · Backend Development

Understanding Distributed Transactions: Two‑Phase Commit, Message‑Queue Solutions, and RocketMQ Transactional Messaging

This article explains how to guarantee data consistency when updating multiple tables or services by using local transactions for single‑node systems, two‑phase commit for distributed databases, and reliable message‑queue patterns—including RocketMQ transactional messages—to achieve eventual consistency and handle duplicate delivery.

Distributed TransactionsMessage QueueRocketMQ
0 likes · 21 min read
Understanding Distributed Transactions: Two‑Phase Commit, Message‑Queue Solutions, and RocketMQ Transactional Messaging
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jul 3, 2021 · Backend Development

Choosing the Right Distributed Transaction Strategy for Microservices

This article examines the challenges of distributed transactions in microservice architectures and compares five practical solutions—Seata (2PC), TCC, transactional messaging, local message tables, and a custom Kola approach—highlighting their principles, implementations, advantages, and prerequisites.

Distributed TransactionsMicroservicesSeata
0 likes · 14 min read
Choosing the Right Distributed Transaction Strategy for Microservices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 25, 2021 · Backend Development

Seata Distributed Transaction Framework: Concepts, Architecture, and Spring Boot Demo

This article introduces the open‑source Seata distributed transaction solution, explains its AT, TCC, SAGA and XA modes, describes the TC‑TM‑RM components and workflow, and provides a step‑by‑step Spring Boot demo with Docker, Maven dependencies, configuration, and code examples for a multi‑service purchase scenario.

AT ModeDistributed TransactionsDocker
0 likes · 11 min read
Seata Distributed Transaction Framework: Concepts, Architecture, and Spring Boot Demo
New Oriental Technology
New Oriental Technology
Jun 24, 2021 · Backend Development

Understanding Global Transaction Models and Seata's AT Mode

This article explains why global transactions are required in distributed systems, compares major transaction models such as XA, LCN, TCC, SAGA, and AT, and provides a detailed overview of Seata's architecture, deployment options, configuration, and code examples for implementing the AT mode in microservice environments.

AT ModeDistributed TransactionsMicroservices
0 likes · 15 min read
Understanding Global Transaction Models and Seata's AT Mode
Top Architect
Top Architect
Jun 22, 2021 · Databases

Database Sharding: Strategies, Bottlenecks, and Best Practices

This article explains the performance bottlenecks of relational databases, introduces sharding concepts such as horizontal, vertical, and table partitioning, discusses associated challenges like distributed transactions and global primary keys, and provides practical solutions and tool recommendations for implementing effective database partitioning.

Distributed TransactionsGlobal ID GenerationPerformance Optimization
0 likes · 18 min read
Database Sharding: Strategies, Bottlenecks, and Best Practices
Architects Research Society
Architects Research Society
Jun 18, 2021 · Backend Development

Understanding the Saga Pattern for Distributed Transactions in Microservices

The article explains why traditional two‑phase commit fails in microservice architectures, introduces the Saga pattern as a solution, compares choreography and orchestration implementations, illustrates a step‑by‑step e‑commerce example, and discusses rollback handling, benefits, and drawbacks.

Backend ArchitectureChoreographyDistributed Transactions
0 likes · 7 min read
Understanding the Saga Pattern for Distributed Transactions in Microservices
Alibaba Cloud Native
Alibaba Cloud Native
Apr 28, 2021 · Backend Development

How Seata‑Golang Enables Distributed Transactions in Go Microservices

This article introduces Seata, a high‑performance open‑source distributed transaction solution, explains the Seata‑Golang 1.0.0 release and its demo at a Go meetup, details the core AT‑mode architecture, describes the MySQL driver that integrates Seata‑Golang, and outlines future plans for broader database support.

BackendDistributed TransactionsGo
0 likes · 7 min read
How Seata‑Golang Enables Distributed Transactions in Go Microservices
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 25, 2021 · Databases

How ADB PG’s Multi‑Master Architecture Boosts HTAP Performance

This article explains the HTAP concept, describes AnalyticDB PostgreSQL’s shift from a single‑master to a Multi‑Master design, details the architecture, distributed transaction handling, global deadlock detection, DDL support, fault tolerance, and presents benchmark results that demonstrate linear scalability for real‑time data‑warehouse workloads.

AnalyticDBDatabase ArchitectureDistributed Transactions
0 likes · 23 min read
How ADB PG’s Multi‑Master Architecture Boosts HTAP Performance
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 20, 2021 · Backend Development

Understanding Seata: Principles, Deployment, and Real‑World Issues in Distributed Transactions

This article introduces Seata's background, explains the causes of data inconsistency in micro‑service architectures, details Seata's three core roles, transaction flow, isolation levels, common pitfalls with code examples, and provides guidance on high‑availability deployment, multi‑node setups, disaster recovery, and hands‑on demos.

Distributed TransactionsJavaMicroservices
0 likes · 15 min read
Understanding Seata: Principles, Deployment, and Real‑World Issues in Distributed Transactions
Java Architect Essentials
Java Architect Essentials
Apr 6, 2021 · Backend Development

Distributed Transaction Solutions: 2PC, 3PC, XA, TCC, Saga, Local Message Table, Transactional Messages, and Seata

This article explains the importance of distributed transactions in micro‑service architectures, reviews ACID properties, compares various solutions such as 2PC/3PC, XA, local message tables, transactional messages, TCC, Saga, and introduces the Seata framework with its AT, TCC, and Saga modes, while also discussing consistency versus consensus with Paxos.

2PCConsistencyDistributed Transactions
0 likes · 14 min read
Distributed Transaction Solutions: 2PC, 3PC, XA, TCC, Saga, Local Message Table, Transactional Messages, and Seata
High Availability Architecture
High Availability Architecture
Apr 6, 2021 · Backend Development

Ensuring Distributed Transaction Consistency in High‑Concurrency Flash‑Sale Systems with Transactional Messages and RocketMQ

This article explains how to achieve strong consistency for high‑traffic flash‑sale (seckill) scenarios by using distributed transaction principles, flexible transaction models, and Alibaba Cloud RocketMQ transactional messages, providing detailed architectural guidance, implementation steps, code examples, and operational best practices.

Distributed TransactionsMicroservicesRocketMQ
0 likes · 33 min read
Ensuring Distributed Transaction Consistency in High‑Concurrency Flash‑Sale Systems with Transactional Messages and RocketMQ
dbaplus Community
dbaplus Community
Apr 5, 2021 · Databases

When and How to Apply Database Sharding: Practical Guidelines and Pitfalls

This article explains why database performance bottlenecks arise, outlines criteria for deciding when to shard databases and tables, and provides detailed strategies for SQL tuning, table restructuring, horizontal and vertical splitting, single‑ versus multi‑database sharding, as well as handling cross‑database joins, distributed transactions, pagination, and ID generation.

Distributed TransactionsID generationPerformance Optimization
0 likes · 12 min read
When and How to Apply Database Sharding: Practical Guidelines and Pitfalls
MaGe Linux Operations
MaGe Linux Operations
Apr 5, 2021 · Backend Development

Mastering Distributed Transactions: Protocols, Patterns, and Seata Explained

This article explores the fundamentals of distributed transactions in microservice architectures, detailing ACID properties, classic protocols like 2PC/3PC and XA, modern patterns such as TCC, Saga, local message tables, transaction messages, and the Seata framework, while comparing their trade‑offs with Paxos consensus.

2PCConsistencyDistributed Transactions
0 likes · 16 min read
Mastering Distributed Transactions: Protocols, Patterns, and Seata Explained
ITPUB
ITPUB
Mar 25, 2021 · Backend Development

Why a TCC Framework Must Own the Spring TransactionManager

This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.

Distributed TransactionsIdempotencyTransactionManager
0 likes · 18 min read
Why a TCC Framework Must Own the Spring TransactionManager
Beike Product & Technology
Beike Product & Technology
Mar 24, 2021 · Backend Development

Optimizing Distributed Transactions with Seata in a Government Talent Housing System

This article details how the government talent housing system adopted the open‑source Seata distributed‑transaction framework, identified severe performance bottlenecks during large‑scale batch operations, and applied a series of optimizations—including query‑lock rewriting, rollback‑info compression, JDBC batch tuning, and multithreaded processing—to reduce a 30000‑record transaction from 280 seconds to under 7 seconds, achieving production‑grade reliability.

Distributed TransactionsJavaSeata
0 likes · 8 min read
Optimizing Distributed Transactions with Seata in a Government Talent Housing System
Architecture Digest
Architecture Digest
Mar 23, 2021 · Backend Development

Design and Implementation of a Data Consistency Engine for Advertising Billing Systems

This article outlines the background, design choices, and implementation details of a data‑consistency engine for an advertising billing platform, comparing TCC and saga‑style approaches, describing the state‑machine architecture, configuration, initialization, and asynchronous execution patterns.

BackendData ConsistencyDistributed Transactions
0 likes · 9 min read
Design and Implementation of a Data Consistency Engine for Advertising Billing Systems
IT Architects Alliance
IT Architects Alliance
Mar 7, 2021 · Databases

Mastering Distributed Transactions: From ACID to TCC and Sharding Strategies

This article provides a comprehensive technical guide to distributed transactions, covering ACID fundamentals, consistency models, sharding techniques, CAP and BASE theories, and detailed implementations of two‑phase, three‑phase, and TCC protocols, while highlighting their advantages, limitations, and practical considerations.

BASE theoryCAP theoremDistributed Transactions
0 likes · 23 min read
Mastering Distributed Transactions: From ACID to TCC and Sharding Strategies
JD Cloud Developers
JD Cloud Developers
Mar 5, 2021 · Databases

How Transparent Sharding Middleware Powers NewSQL: Core Functions Explained

This article explains the fundamentals of transparent sharding middleware in NewSQL systems, covering data partitioning strategies, read/write separation, the complete SQL processing pipeline, protocol adaptation for MySQL/PostgreSQL, distributed transaction models such as XA, Saga and TCC, and essential database governance and online scaling techniques.

Database GovernanceDatabase MiddlewareDistributed Transactions
0 likes · 28 min read
How Transparent Sharding Middleware Powers NewSQL: Core Functions Explained
Architect
Architect
Feb 27, 2021 · Backend Development

Distributed Transaction Solutions: 2PC, 3PC, XA, TCC, Saga, Local Message Table, Transactional Messages, and Seata

This article explains the challenges of distributed transactions in micro‑service architectures and reviews major solutions such as 2PC/3PC, XA, TCC, Saga, local message tables, transactional messages, and the Seata framework, comparing their consistency, performance, and implementation trade‑offs.

2PCDistributed TransactionsSeata
0 likes · 18 min read
Distributed Transaction Solutions: 2PC, 3PC, XA, TCC, Saga, Local Message Table, Transactional Messages, and Seata
Code Ape Tech Column
Code Ape Tech Column
Feb 19, 2021 · Databases

Understanding Timestamps in Distributed Transactions: TSO, TrueTime, Lamport Clock, and HLC

This article explains the role of timestamps in distributed transaction processing, comparing implementations such as MVCC‑based TSO, Google’s TrueTime, Lamport logical clocks, and Hybrid Logical Clocks, and discusses their impact on linearizability, consistency guarantees, and practical designs like TiDB Async Commit.

ConsistencyDistributed TransactionsHLC
0 likes · 14 min read
Understanding Timestamps in Distributed Transactions: TSO, TrueTime, Lamport Clock, and HLC
Code Ape Tech Column
Code Ape Tech Column
Feb 5, 2021 · Backend Development

How to Solve Distributed Transactions in Microservices: From 2PC to TCC and Reliable Messaging

This article analyzes the challenges of distributed transactions in microservice architectures, explains ACID, CAP and BASE theories, compares consistency models, and evaluates practical solutions such as two‑phase commit, local message tables, TCC, and reliable messaging with code examples and implementation details.

2PCBASE theoryCAP theorem
0 likes · 26 min read
How to Solve Distributed Transactions in Microservices: From 2PC to TCC and Reliable Messaging
Tencent Cloud Middleware
Tencent Cloud Middleware
Jan 8, 2021 · Cloud Native

Why Centralized Architecture Evolves to Microservices: Banking Insights

This article recaps a technical conference where experts explained how traditional centralized banking systems transition to microservice architectures, compared rigid and flexible distributed transaction models, examined IBM mainframe designs, and highlighted practical considerations for service mesh and cloud‑native deployments.

Distributed TransactionsIBMService Mesh
0 likes · 17 min read
Why Centralized Architecture Evolves to Microservices: Banking Insights
Top Architect
Top Architect
Jan 4, 2021 · Backend Development

Understanding the Saga Pattern for Distributed Data Consistency in Microservices

This article explains the importance of data consistency in distributed microservice systems, introduces the Saga pattern as a solution, compares it with two‑phase commit and TCC, and details its architecture, recovery mechanisms, and implementation considerations within ServiceComb.

Data ConsistencyDistributed Transactionsservicecomb
0 likes · 19 min read
Understanding the Saga Pattern for Distributed Data Consistency in Microservices
ITPUB
ITPUB
Dec 24, 2020 · Databases

How TDSQL Achieves Multi‑Level Strong Consistency with 4×‑3× Performance Gains

This article explains how Tencent's TDSQL database tackles the combined challenges of transaction and distributed consistency by introducing a multi‑level strong consistency model that delivers several‑fold performance improvements over Spanner, CockroachDB, and native Greenplum while preserving ACID guarantees.

Database ResearchDistributed TransactionsTDSQL
0 likes · 12 min read
How TDSQL Achieves Multi‑Level Strong Consistency with 4×‑3× Performance Gains
Java Interview Crash Guide
Java Interview Crash Guide
Dec 17, 2020 · Databases

Mastering Data Sharding: When and How to Split Your Database

This article explains the concepts, types, advantages, and drawbacks of vertical and horizontal database sharding, discusses the challenges such as distributed transactions, cross‑node joins, pagination, global primary‑key generation, migration, and provides practical guidelines and case studies for deciding when and how to apply sharding.

Distributed Transactionsdatabase partitioningglobal IDs
0 likes · 28 min read
Mastering Data Sharding: When and How to Split Your Database
Senior Brother's Insights
Senior Brother's Insights
Dec 2, 2020 · Databases

Mastering Data Sharding: When, How, and What to Watch Out For

This comprehensive guide explains why and when to split relational databases, details vertical and horizontal sharding techniques, discusses associated challenges such as distributed transactions, cross‑node joins, pagination, global primary keys, and offers practical solutions and middleware options.

Distributed TransactionsGlobal ID Generationdatabase partitioning
0 likes · 24 min read
Mastering Data Sharding: When, How, and What to Watch Out For
Programmer DD
Programmer DD
Nov 28, 2020 · Backend Development

Deep Dive into ShardingSphere XA Distributed Transaction Support and Atomikos Integration

This article provides a comprehensive technical analysis of ShardingSphere's XA distributed transaction capabilities, covering the CAP theory, X/Open DTP model, MySQL XA support, JTA mapping, Atomikos initialization, transaction lifecycle (begin, getConnection, commit, rollback), and the recovery mechanism with detailed code snippets and diagrams.

AtomikosDistributed TransactionsJTA
0 likes · 34 min read
Deep Dive into ShardingSphere XA Distributed Transaction Support and Atomikos Integration
vivo Internet Technology
vivo Internet Technology
Nov 25, 2020 · Backend Development

An Overview of the Seata Distributed Transaction Framework and Its Modes

Seata is an open‑source Java framework that simplifies distributed transactions by offering a Transaction Coordinator, embedded Transaction and Resource Managers, and four modes—AT, TCC, Saga, and XA—each with distinct consistency and performance trade‑offs, enabling high‑concurrency, zero‑intrusion handling of multi‑node operations.

AT ModeDistributed TransactionsJava
0 likes · 15 min read
An Overview of the Seata Distributed Transaction Framework and Its Modes
Java High-Performance Architecture
Java High-Performance Architecture
Nov 12, 2020 · Backend Development

Understanding SAGA Distributed Transactions: Choreography vs Orchestration

This article explains the concept and implementation approaches of SAGA as a distributed transaction solution, covering the problem definition, the two strategies—Choreography and Orchestration—including their workflows, event handling, state machine coordination, advantages, drawbacks, and references to Alibaba's Seata framework.

ChoreographyDistributed TransactionsMicroservices
0 likes · 7 min read
Understanding SAGA Distributed Transactions: Choreography vs Orchestration
Java Backend Technology
Java Backend Technology
Nov 7, 2020 · Databases

How Seata’s AT Mode Solves Distributed Transaction Challenges

This article explains the fundamentals of single- and multi-data-source transactions, reviews common distributed-transaction solutions such as 2PC, 3PC, TCC, transaction-status tables and message-queue based eventual consistency, and then details Seata’s AT mode implementation, including its workflow, undo-log mechanism, and isolation handling.

AT ModeDistributed TransactionsMicroservices
0 likes · 32 min read
How Seata’s AT Mode Solves Distributed Transaction Challenges
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 6, 2020 · Databases

Distributed Transaction Solutions and Seata AT Mode Implementation

This article explains the limitations of single‑database transactions in multi‑data‑source micro‑service scenarios, reviews common distributed‑transaction models such as 2PC, 3PC, TCC, status‑table and message‑queue based final consistency, and details the implementation of Seata's AT mode for achieving global ACID properties.

2PCAT ModeDistributed Transactions
0 likes · 30 min read
Distributed Transaction Solutions and Seata AT Mode Implementation
Aikesheng Open Source Community
Aikesheng Open Source Community
Oct 15, 2020 · Databases

MySQL Middleware Deep Dive: Sharding vs Middleware, Distributed Transactions, and DBLE Insights

The fifth episode of the MySQL 冲冲冲 livestream explores the trade‑offs between sharding and middleware architectures, discusses distributed transaction challenges, compares DBLE with MyCat and other solutions, and provides practical guidance for developers and DBAs handling high‑throughput MySQL workloads.

DBLEDatabase ArchitectureDistributed Transactions
0 likes · 19 min read
MySQL Middleware Deep Dive: Sharding vs Middleware, Distributed Transactions, and DBLE Insights
macrozheng
macrozheng
Oct 9, 2020 · Databases

How to Implement Database Sharding: Horizontal & Vertical Partitioning with Sharding-JDBC

This article explains the fundamentals of database sharding, covering both vertical and horizontal partitioning concepts, routing algorithms, advantages and drawbacks, practical implementation steps using sharding-jdbc, and discusses related challenges such as distributed transactions, pagination, global IDs, and tool selection.

Distributed TransactionsJavaVertical Scaling
0 likes · 17 min read
How to Implement Database Sharding: Horizontal & Vertical Partitioning with Sharding-JDBC
Top Architect
Top Architect
Sep 12, 2020 · Backend Development

Key Considerations for Building a Generic TCC Distributed Transaction Framework

This article explains the essential design principles of a TCC (Try‑Confirm‑Cancel) distributed transaction framework, covering the necessity of RM local transactions, integration with Spring's TransactionManager, fault‑recovery mechanisms, idempotency guarantees, and handling of parallel Try/Confirm/Cancel operations.

Distributed TransactionsTransactionManagerfault-recovery
0 likes · 22 min read
Key Considerations for Building a Generic TCC Distributed Transaction Framework
Programmer DD
Programmer DD
Sep 12, 2020 · Backend Development

What’s New in Hmily? A Deep Dive into the Latest Architecture and Roadmap

The article presents Hmily’s monthly report, detailing its high‑performance distributed transaction solution, recent architectural refactoring, newly added modules and SPI implementations, community‑driven bug fixes and feature releases, and outlines upcoming versions supporting TCC and TAC modes.

Backend DevelopmentDistributed TransactionsHmily
0 likes · 6 min read
What’s New in Hmily? A Deep Dive into the Latest Architecture and Roadmap
Java Backend Technology
Java Backend Technology
Aug 30, 2020 · Databases

Mastering Database Sharding: Core Concepts, Middleware, and Common Challenges

Sharding splits a single database into multiple servers to improve performance, covering vertical and horizontal partitioning, middleware options, and key challenges such as distributed transactions, cross‑node joins, ID generation, pagination, routing transparency, and choosing between frameworks or custom solutions.

Distributed TransactionsID generationdatabase partitioning
0 likes · 16 min read
Mastering Database Sharding: Core Concepts, Middleware, and Common Challenges