0 views collected around this technical thread.
This article explains RocketMQ's transactional message mechanism, covering half‑message concepts, back‑check processes, implementation steps with code examples, and how to achieve reliable event handling and distributed transaction consistency in a microservice architecture.
This article shares seven practical scenarios—such as asynchronous processing, traffic smoothing, message bus, delayed tasks, broadcast consumption, distributed transactions, and data hub integration—where message queues like RocketMQ, Kafka, ActiveMQ, and RabbitMQ help solve high‑concurrency challenges in modern backend systems.
This article explains the practical problems encountered when using Kafka directly, introduces SFMQ—a Kafka‑based HTTP proxy that unifies client access, simplifies upgrades, provides delay and transaction capabilities via Redis, and demonstrates how its architecture resolves producer, consumer, and operational challenges.
This article compares four distributed transaction solutions—local message tables, RocketMQ transactional messages, Seata AT mode, and Seata TCC mode—detailing their advantages, limitations, workflow phases, and common exception‑handling techniques for ensuring data consistency across services.
This article explains the principles of distributed transaction messages, comparing 2PC, TCC, and transactional messaging, and provides detailed walkthroughs of RocketMQ and Kafka implementations, including their two‑phase processes, broker handling, and source‑code insights for ensuring data consistency in asynchronous systems.
This guide explains how to achieve reliable message consistency in a Spring Boot 2.3.9 application using RocketMQ 4.8.0 by outlining the transactional message flow, broker handling, project structure, code implementation, and testing procedures.
This article provides an in‑depth tutorial on RocketMQ, covering normal, ordered, delayed, transactional, and batch messages, their production and consumption patterns, retry mechanisms, message filtering, and dead‑letter handling, complete with Java code examples for each scenario.
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.
This article explains the concept of distributed transactions, presents typical micro‑service scenarios that generate them, and demonstrates a complete solution using RocketMQ transaction messages together with SQL table definitions and Java code for producers, transaction listeners, and consumers to achieve eventual consistency.
This article explains how RocketMQ implements distributed transaction messages using a two‑phase commit model, detailing the problems with RPC and ordinary MQ, the step‑by‑step workflow, relevant code snippets, and how consistency is ensured across microservice subsystems.
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.
This article provides a comprehensive guide to RocketMQ, covering Windows installation, environment configuration, startup commands, visual monitoring integration, SpringBoot dependency setup, core components, message models, reliability strategies, idempotent processing, transactional messaging, and ordering guarantees for distributed systems.
This article explains the principles and implementation of RocketMQ's transactional messages, batch messages, and delayed messages, describing the message flow, compensation mechanisms, broker and producer handling, and providing detailed source code snippets to illustrate each process.
The article outlines essential practices for migrating to microservices, covering service dependency rules to avoid circular dependencies, interface version compatibility strategies, isolation techniques for data, deployment and business logic, and methods to ensure eventual data consistency using scheduled retries and transactional messaging.
The article analyzes three typical RocketMQ message‑loss scenarios—network glitches during production, incomplete disk persistence, and premature consumer acknowledgments—and presents concrete solutions such as transactional messaging, synchronous flush with replication, and proper consumer‑ack handling, while discussing their performance impact.
This guide explains the principle and step‑by‑step implementation of reliable transactional messaging using Spring Boot 2.3.9 and RocketMQ 4.8.0, covering execution flow, broker handling, project structure, code examples for entities, repositories, services, listeners, and testing.
The article compares how RocketMQ, Apache Kafka, and Apache Pulsar implement transactional messaging—each using a two‑phase commit with half‑messages or transaction buffers, distinct coordinators, and idempotent producers—to provide atomicity and either strong consistency (RocketMQ) or exactly‑once delivery for high‑throughput stream processing (Kafka and Pulsar).
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.
The article explains how to guarantee data consistency across distributed systems by using local transactions, two‑phase commit protocols, message‑queue based eventual consistency, deduplication techniques, and practical RocketMQ transactional messaging code examples in Java.
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.