This guide explains how to replace inefficient cron polling with RocketMQ's delayed message feature in Spring Boot, covering the core concept, configuration, producer and consumer implementation, testing, and how to customize delay levels for reliable time‑sensitive operations.
This article explains what message queues are, why they are essential for decoupling, asynchronous processing, and traffic shaping, examines common architectural issues, and presents real‑world implementations such as RocketMQ, Kafka, and CMQ in high‑traffic scenarios like Double‑11, TikTok, and WeChat red‑packet payments.
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.
The article introduces RoP 0.2.0, a redesign of RocketMQ on Pulsar that eliminates message loss, duplicate consumption, and partial partition consumption, adds ACL authentication, partition expansion for higher throughput, native RocketMQ management APIs, refactors MessageID and routing models, and outlines future features such as tracing, delayed messages, and advanced monitoring.
This article introduces the fundamentals of message queues and compares five popular products—ActiveMQ, RabbitMQ, ZeroMQ, Kafka, and RocketMQ—detailing their features, typical use cases, and providing curated learning resources for each.
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.
This article explains how RocketMQ's six core features—asynchronous decoupling, peak‑shaving, distributed transaction messages, message filtering, scheduled messages, and ordered delivery—enable Alibaba's Double 11 platform to handle billions of transactions and hundreds of thousands of orders per second while maintaining system stability and reliability.
This article explains RocketMQ’s disk‑based storage design—including CommitLog, ConsumeQueue, and Index files—detailing sequential writes, memory‑mapped I/O, flexible flush strategies, and memory‑level read/write separation that together enable unlimited backlog, high throughput, and low latency messaging.
This article provides a comprehensive technical analysis of Apache RocketMQ's storage subsystem, detailing the architecture of CommitLog, ConsumeQueue, and IndexFile, the use of PageCache and mmap, the message write path, flush strategies, and read mechanisms, complete with code excerpts and diagrams.
This article explains the core storage design of RocketMQ, covering the CommitLog, ConsumeQueue, and Index files, their organization, sequential write strategy, memory‑mapped I/O, and flexible flushing policies that together provide high‑throughput, low‑latency messaging for backend systems.
This article reviews the evolution of RocketMQ from its early MetaQ roots through the 4.x releases, explains the motivations behind RocketMQ 5.0, and details its cloud‑native architecture, lightweight SDK, storage‑compute separation, POP consumption model, elastic scaling, and the upcoming RocketMQ Streams framework.
This article compares Pulsar with Kafka, RocketMQ and InLong‑TubeMQ, focusing on cloud‑native multi‑tenant design, multi‑level flow control, compute‑storage separation, partitioning strategies, metadata storage, and message delivery mechanisms, highlighting each system's architectural advantages and trade‑offs.
Pulsar’s cloud‑native, multi‑tenant architecture with hierarchical flow control, stateless brokers separated from BookKeeper storage, global partitions supporting multiple consumers, push‑based dispatch, and precise acknowledgment outperforms Kafka, RocketMQ, and InLong‑TubeMQ, though its reliance on ZooKeeper and higher resource usage demand careful operational planning.
This article examines RocketMQ's routing registration process, identifies its two main shortcomings—delayed failure detection and NameServer inconsistency—and explores how network partitions can cause prolonged data inconsistency, uneven message distribution, and partitioned consumption, while discussing the architectural trade‑offs behind these design choices.
This article explains why RocketMQ guarantees at‑least‑once delivery, describes the three typical duplicate‑message scenarios, compares transaction‑based and non‑transactional deduplication approaches (including a Redis‑based solution), provides sample SQL and Java code, and discusses the limitations and best‑practice recommendations for achieving idempotent message consumption.
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 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.
This article explains the fundamentals of message queues, describing how MQ, Kafka, and RocketMQ handle asynchronous processing, traffic shaping, and decoupling through topics, partitions, consumer groups, and storage mechanisms such as sequential writes and page‑cache optimization.
Message middleware guarantees at-least-once delivery, but duplicate deliveries can cause issues; this article explains RocketMQ’s three duplication scenarios, explores simple and advanced deduplication strategies—including database-transaction and non-transactional approaches using Redis—and provides practical code samples for implementing reliable exactly-once processing.
This article provides a comprehensive comparison between RocketMQ and Kafka, covering data reliability, performance, queue capacity, real‑time delivery, retry mechanisms, ordering guarantees, scheduled messages, transactional support, query capabilities, message tracing, consumer parallelism, filtering, and commercial backing, helping engineers choose the right messaging middleware for their workloads.
This article introduces the concepts, core features, deployment environments, architectures, high‑availability solutions, advantages and disadvantages of four widely used open‑source distributed message queue systems—Kafka, ActiveMQ, RabbitMQ, and RocketMQ—and provides a comparative analysis to help practitioners choose the right middleware for their distributed applications.
This guide explains RocketMQ's four core components, details its architecture, walks through configuring and starting the NameServer and Broker, and provides troubleshooting steps for common startup problems, all illustrated with commands and diagrams.
This guide shows how to configure Spring Boot 2.3.9 with RocketMQ 4.8.0, add the necessary dependencies, and implement two message‑filtering methods—tag‑based and SQL‑92 expression‑based—complete with code samples, configuration snippets, and testing steps.
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.
This article explains why message middleware guarantees at‑least‑once delivery, the problems caused by duplicate consumption, and presents both transaction‑based and non‑transactional deduplication solutions—including a Redis‑backed idempotent table—to achieve exactly‑once semantics in RocketMQ.
This article analyzes the at‑least‑once guarantee of message middleware, explains why duplicate deliveries occur, compares simple database‑based deduplication methods, explores concurrency challenges, and presents a non‑transactional, status‑driven idempotence solution using MySQL or Redis with practical code examples and limitations.
This article explains why message middleware guarantees at‑least‑once delivery, describes three common duplication scenarios in RocketMQ, and presents both transactional and non‑transactional deduplication solutions—including SQL examples and a Redis‑based idempotence library—to achieve exactly‑once processing.
This article examines the key problems message middleware must address—such as publish/subscribe, ordering, filtering, persistence, reliability, latency, and transaction support—and explains how Apache RocketMQ’s architecture and design choices provide high‑performance, high‑throughput solutions to each of these challenges.
The article thoroughly examines RocketMQ’s NameServer, detailing its lightweight registration-center architecture, startup sequence, and the three core routing mechanisms—registration via broker heartbeats, timed removal of stale brokers, and client‑pulled discovery—while explaining key metadata tables and design patterns such as JVM shutdown hooks and read‑write locks for high‑concurrency safety.
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 provides a comprehensive overview of Apache RocketMQ, detailing its core components—Namesrv, Broker, Producer, and Consumer—explaining routing registration, message storage, queue allocation strategies, and key concepts such as topics, tags, and consumer types, while comparing it with Kafka.
Facing over a million concurrent connected vehicles, Chinese IoT leader ZhongRui chose RocketMQ over Kafka, leveraging Alibaba Cloud’s managed service to achieve low‑latency, high‑throughput, fault‑tolerant messaging, while adopting cloud‑native microservices, containerization, and serverless techniques to streamline operations and reduce costs.
Message middleware guarantees at-least-once delivery, but repeated deliveries cause duplicate processing; this article explains RocketMQ's duplicate scenarios, explores simple and advanced deduplication techniques—including database-transactional and Redis-based idempotent tables—and provides practical Java code for implementing exactly-once semantics.
This guide demonstrates how to integrate RocketMQ 4.8.0 into a Spring Boot 2.3.9 application, covering dependency setup, configuration, sending and receiving plain, ordered, clustered, broadcast, and transactional messages, with complete code examples and execution results.
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.
This article explains how to identify, locate, and resolve consumer-side bottlenecks in RocketMQ during technical interviews, covering key metrics, log analysis, thread inspection, and practical troubleshooting steps.
This article provides a comprehensive overview of RocketMQ's evolution, core architecture, communication flow, storage mechanisms, flushing strategies, high‑availability synchronization, and transaction message implementation, illustrating each component with diagrams and key source‑code excerpts for developers seeking an in‑depth understanding of the system.
This article explains how to achieve high‑throughput, high‑availability ordered messaging in RocketMQ by using multi‑partition designs, routing strategies, and consumer locking mechanisms to guarantee local order while handling scaling, failures, and consumer concurrency.
The article explains how to analyze and resolve RocketMQ consumption bottlenecks during an interview by examining key metrics, checking logs, tracing thread stacks, and applying appropriate optimization or scaling strategies while engaging the interviewer in a thoughtful discussion.
The article explains message queues, their primary use cases—async processing, system decoupling, and traffic peak shaving—compares five mainstream products (ActiveMQ, RabbitMQ, Kafka, RocketMQ, Pulsar), and examines core design principles such as architecture, storage choices, push/pull models, and consumer groups, highlighting broader relevance to distributed systems.
This article traces RocketMQ's evolution from its early Alibaba projects, explains its core components and communication roles, walks through the startup process, client message flow, remoting layer, broker handling, storage mechanisms, flush strategies, HA synchronization, and finally details the implementation of transactional messages.
This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both transactional and non‑transactional deduplication strategies—including database and Redis‑based solutions—to achieve idempotent processing in RocketMQ.
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.
This article outlines the technical and business goals, design architecture, technology selection, and operational considerations for creating a message center capable of handling 10,000 messages per second upstream and 1,000 downstream, while ensuring 100% high availability and easy integration with third‑party push services.
This article outlines a backend messaging center architecture that targets 10,000 messages per second inbound via RocketMQ, 1,000 messages per second outbound to third‑party platforms, and ensures 100% high availability using Spring Cloud Gateway, Kubernetes, Elasticsearch, and related technologies.
This article details a multi‑lane approach for test environment governance that isolates services, databases, and messaging, dramatically improves stability and efficiency, and outlines the technical architecture, implementation steps, challenges, and future automation plans.
This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both simple and advanced deduplication strategies—including transactional and non‑transactional approaches using relational databases or Redis—to achieve effectively exactly‑once semantics in RocketMQ.
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.
The article compares the architectures of NSQ (YouZan branch), Kafka, and RocketMQ—detailing their coordination mechanisms, storage models, consistency guarantees, and operational trade‑offs—while recommending Kafka for log‑big‑data workloads, RocketMQ for massive topic counts, and NSQ for extensibility and lightweight deployment.
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.
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.
This article outlines the technical, business, and product goals for a messaging center, presents a prototype and functional requirements, evaluates RocketMQ and Elasticsearch as core technologies, and details the architectural design, underlying frameworks, and DevOps strategies—including Spring Cloud Gateway, Kubernetes, and Docker—to achieve 10,000 msg/s upstream throughput, 1,000 msg/s downstream delivery, and 100 % high availability.
This article chronicles my step‑by‑step journey of learning Apache RocketMQ, from downloading the source and building it with Maven, configuring mirrors, launching NameServer, Broker, Producer and Consumer on Windows, to exploring the system’s architecture and design principles.
This article explains why RocketMQ was chosen, describes its large‑scale usage, details the design and implementation of a same‑city dual‑center architecture with near‑by production and consumption, outlines failover mechanisms, governance practices, lessons learned, and future plans for the messaging platform.
This article provides a comprehensive guide to using Apache RocketMQ with Spring Boot, covering core components, basic concepts, key features, step‑by‑step configuration, producer and consumer code examples, advanced message types, transaction handling, and common interview questions for distributed messaging systems.
This article explains why message queues are used in modern systems, outlines common interview questions about MQ, discusses the advantages of decoupling, asynchronous processing, and traffic shaping, examines the pros and cons of MQ, and compares the four major MQ products—Kafka, ActiveMQ, RabbitMQ, and RocketMQ—to help candidates prepare for technical interviews.
The article explains how to detect and prevent message loss, guarantee reliable delivery, handle duplicate consumption, manage message backlog, and implement distributed transaction messages in systems like Kafka, RocketMQ, and RabbitMQ, providing practical code examples and best‑practice guidelines.
After receiving a Sentry alert for a NullPointerException in a Java backend, the author traced the issue through user context handling with TransmittableThreadLocal, uncovered mismatched RocketMQ header propagation, multiple retry attempts, and a manual message injection, ultimately revealing how a missing header caused the NPE.
This article shares Haro's practical experience in designing and operating a distributed message governance platform that unifies RocketMQ, Kafka, and other middleware, covering metrics, monitoring, alerting, scenario‑based controls, and high‑availability strategies to keep microservices reliable under sudden traffic spikes.
This article evaluates open‑source message‑queue options by examining company, middleware‑team, and end‑user criteria, then explains why RocketMQ’s low technical and labor costs, stability, rich features, high performance, built‑in management tools, monitoring support, and active community make it a cost‑effective choice over alternatives like Kafka and Pulsar.
The RoP (RocketMQ‑to‑Pulsar) plugin adds a pluggable protocol handler to Apache Pulsar, allowing RocketMQ clients to connect without code changes and leveraging Pulsar's features such as multi‑tenant storage, geo‑replication, and lightweight functions.
This article explores the role of message queues in microservice architectures, discussing their advantages such as decoupling, asynchronous processing, and load shedding, while also addressing design challenges like concurrency, ordering, duplicate handling, and transactional messaging with solutions including Kafka partitions, outbox patterns, CDC, and RocketMQ.
This guide walks you through setting up RocketMQ Console 2.0 on a RocketMQ 4.8.0 cluster, configuring its properties, building and running the service, and testing message sending and receiving using a Spring Boot application, including topic creation tips.
This article breaks down the design and source‑code implementation of RocketMQ's NameServer, detailing its core responsibilities, component interactions, and the seven Java classes that together provide network handling, connection management, routing, configuration, and startup logic.
This article compares RabbitMQ, Kafka, and RocketMQ from a high‑availability perspective, explaining each system's deployment modes, replication mechanisms, and the trade‑offs between scalability and fault tolerance.
The guide details how to build a distributed message‑governance platform for the Hello mobility service, covering unified SDK design, RocketMQ pitfalls, client and cluster health monitoring, risk mitigation, and a tiered microservice high‑availability architecture that uses circuit‑breaking, rate‑limiting, and pre‑heating to ensure resilient traffic handling.
The article recounts a production incident caused by an ungraceful RocketMQ consumer shutdown, analyzes the root cause involving Spring's bean destruction order and ShutdownHook behavior, and presents two solutions—using the official Spring‑Boot starter with SmartLifecycle or handling ContextClosedEvent—to achieve orderly termination.
In a late-night deployment, the author traced a persistent ‘DataSource already closed’ error to an ungraceful RocketMQ consumer shutdown, explored Spring’s ShutdownHook behavior, and ultimately implemented a SmartLifecycle-based solution for orderly bean destruction.
This guide walks through the complete process of installing RocketMQ 4.8.0, configuring a two‑master‑two‑slave asynchronous high‑availability cluster across two Linux servers, setting up the web console, and troubleshooting common pitfalls such as missing JDK, memory limits, firewall rules, and network address issues.
System health checks, akin to medical exams, are vital for modern IT infrastructure, using active and passive monitoring, failover strategies, and tools like Spring Boot Actuator to detect hardware, network, load, or software issues, prevent single points of failure, and ensure continuous high‑availability service operation.
This tutorial demonstrates how to integrate Spring Boot with RocketMQ and implement two message filtering strategies—TAG-based and SQL expression-based—covering dependencies, configuration, code examples, and testing procedures for reliable message consumption.
This article provides a detailed side‑by‑side analysis of four major distributed message‑queue systems—Kafka, RabbitMQ, RocketMQ, and ActiveMQ—examining them across seventeen criteria such as documentation, language support, protocols, storage, transactions, load balancing, clustering, management UI, availability, duplication, throughput, subscription models, ordering, acknowledgments, replay, retry, and concurrency.
This guide explains the design and implementation of RocketMQ‑Exporter, walks through setting up RocketMQ, compiling and running the exporter, configuring Prometheus to scrape its metrics, defining alert rules, and visualizing data with Grafana for a complete DevOps monitoring solution.
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.
This article details RocketMQ's 2020 Double‑11 transformation, covering its migration to a Kubernetes‑based operator, a MessageType‑indexed filter optimization that cut CPU usage by up to 32%, and the introduction of a POP consumption model that eliminates rebalance‑induced latency and improves reliability.
This guide walks through installing RocketMQ 4.5.1, launching NameServer and broker, testing with sample producer/consumer scripts, explains core components and console setup, shows Spring Boot starter integration with example code, and demonstrates sending normal, ordered, and transactional messages.
This article explains the principle of reliable message eventual consistency using Spring Boot 2.3.9 and RocketMQ 4.8.0, detailing the transaction flow, broker handling of commit/rollback, project structure, code implementation for producers and consumers, and testing procedures.
The article investigates a performance bottleneck in Tesla's interface testing platform where large test tasks experience up to nine‑minute report delays, identifies the hidden latency in RocketMQ message dispatch to handlers, and proposes a redesign of channel scheduling that reduces execution time to under four minutes.
This article presents the design, implementation, and performance evaluation of a Netty‑based WebSocket long‑connection gateway that centralizes session management, decouples business logic, supports horizontal scaling, and provides monitoring and alerting for high‑throughput real‑time data push in iQIYI’s platform.
A production RocketMQ cluster suffered a 10‑minute message‑send timeout after a broker’s memory failure caused a server reboot, and the post analyzes the routing registration, name‑server removal logic, client‑side timeout handling, root cause of name‑server “dead‑lock”, and proposes deployment and code‑level fixes to prevent recurrence.
This article outlines five Spring-based approaches for using Apache RocketMQ—including Spring Messaging, Spring Cloud Stream, Spring Cloud Bus, Spring Cloud Data Flow, and Spring Cloud Function—detailing each project's features, typical use cases, and how they fit into modern Java microservice architectures.
This article explores five integration approaches for using Apache RocketMQ within the Spring ecosystem, detailing each project's features, typical use cases, and how they complement Spring Boot, Spring Messaging, and Spring Cloud Stream for building robust, scalable microservices.
This article explains why Kuaishou needed a dedicated online messaging system, how RocketMQ was chosen and integrated, the deployment strategies, client SDK design, load‑balancing and disaster‑recovery mechanisms, diverse message features, distributed reconciliation monitoring, and performance‑tuning parameters.
iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.
This article provides a comprehensive guide to installing and configuring Apache RocketMQ, covering its history, core features, high‑availability architectures, detailed port planning, downloading, editing broker configuration files, creating data directories, starting NameServer and brokers, troubleshooting common issues, and deploying the web console for monitoring.
This article explains why message queues are used, outlines their advantages and disadvantages, compares Kafka, ActiveMQ, RabbitMQ, and RocketMQ in terms of throughput, latency, reliability and features, and provides interview‑style guidance on high availability, idempotency, data loss prevention, ordering, and scaling strategies.
This article explains why message middleware like RocketMQ guarantees at‑least‑once delivery, the resulting duplicate‑delivery problem, and presents both transaction‑based and non‑transactional idempotency solutions—including select‑for‑update, optimistic locking, and a Redis‑backed deduplication table—to achieve exactly‑once semantics in distributed systems.
This article compares ActiveMQ, RocketMQ, and Kafka across multiple dimensions such as messaging models, API completeness, language support, throughput, latency, availability, message loss risk, documentation, community activity, and commercial backing, helping readers choose the most suitable queue for their backend needs.
This article explains why the team built a dedicated online messaging system, the scenarios where Kafka fell short, the decision to adopt RocketMQ, deployment strategies, SDK design, load‑balancing, distributed monitoring, and performance tuning tips for a robust backend solution.
This guide demonstrates how to navigate to the RocketMQ bin directory and use various mqadmin CLI commands to list available commands, check help, monitor producer and consumer connections, query topic status, retrieve messages by offset or ID, and shut down the NameServer and brokers.
This guide details how to set up a high‑availability RocketMQ cluster with two name servers and four brokers across two Linux hosts, covering directory preparation, configuration file edits, service startup commands, and verification of the deployment.
This article explains RocketMQ consumer fundamentals, covering concurrent and ordered consumption modes, how to achieve idempotent processing with Redis locks, the load‑balancing strategy implemented by RebalanceImpl, and the complete pull‑process‑consume workflow including code examples.
This article examines RocketMQ's end‑to‑end reliability mechanisms, covering producer‑side sending strategies, broker storage guarantees, and consumer‑side consumption semantics to show how the system minimizes message loss in distributed environments.
This guide walks through downloading, extracting, configuring, and starting RocketMQ 4.8 on a Kubernetes master, covering directory setup, configuration edits, and verification of the NameServer and Broker processes to complete a production‑ready message‑queue deployment.
This article explains RocketMQ’s core features, the operational challenges of using its console, and how the MQCloud platform was designed to separate business and admin roles, provide comprehensive monitoring, automated deployment, security hardening, and a customized client, ultimately turning operational pain into a scalable, open‑source solution.
Apache RocketMQ 4.8.0 has been released, featuring extensive optimizations and bug fixes, with significant performance, functionality, and stability enhancements to the Raft‑based DLedger mode, including asynchronous pipeline processing, batch log replication, and various lock and cache improvements that boost throughput by multiple times.
This article details how to migrate Spark Streaming jobs to Flink Streaming by creating custom SourceFunction and SinkFunction implementations, including a RocketMQ source connector and an HBase sink, with code examples, configuration tips, and discussion of checkpointing and watermark handling.
This article details how Alibaba Cloud transformed RocketMQ with a Kubernetes‑based operator, optimized message filtering by indexing MessageType for up to 30% CPU reduction, and introduced a POP consumption model that eliminates rebalance delays, achieving stable performance during the 2020 Double‑11 peak.
This article explains the concept and common use cases of delayed messages and compares five practical implementation methods—using Redis sorted sets, RabbitMQ delayed‑message exchange plugin, ActiveMQ scheduled messages, RocketMQ fixed delay levels, and a custom RocketMQ solution—detailing their workflows, advantages, and drawbacks.
This article explains how to build a highly available, high‑throughput, and horizontally scalable RocketMQ cluster by deploying multiple NameServers and using the Dledger mode to achieve fault‑tolerance, load distribution, and massive message handling for demanding business scenarios.
