RocketMQ Windows Installation, Configuration, Core Concepts, and Best Practices

Windows Installation and Configuration

Download the RocketMQ binary from Apache mirror , unzip it, and set the following system variables:

ROCKETMQ_HOME → F:\RocketMQ\rocketmq-4.5.2 JAVA_HOME → F:\Java_JDK\JDK1.8 Append Maven/bin to Path Note: RocketMQ stores messages under C:\Users\Administrator\store ; delete unnecessary files to save space.

Start the services:

run mqnamesrv.cmd run mqbroker.cmd -n 127.0.0.1:9876 autoCreateTopicEnable=true

Integrating the RocketMQ Console

Clone the console project: git clone https://github.com/apache/rocketmq-externals.git Edit

rocketmq-externals\rocketmq-console\src\main\resources\application.properties

to set the port and NameServer address, e.g.,

server.port=8100

rocketmq.config.namesrvAddr=127.0.0.1:9876

Build the console with Maven: mvn clean package -Dmaven.test.skip=true and run java -jar rocketmq-console-ng-1.0.1.jar Access the console at http://127.0.0.1:8100

SpringBoot Integration

<!-- RocketMQ dependency -->
<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-client</artifactId>
    <version>4.5.2</version>
</dependency>

RocketMQ Basic Concepts

Overview

A RocketMQ cluster consists of four roles: NameServer, Broker, Producer, and Consumer.

NameServer

Provides lightweight service discovery and routing; stores full routing information on each node; supports horizontal scaling.

Broker

Handles topic/queue storage, supports push and pull modes, offers high availability via replication, can store billions of messages, and provides fault recovery, statistics, and alerting.

Producer

Supports distributed deployment and load‑balancing.

Provides fast failure handling.

Offers low latency.

Consumer

Supports both push and pull consumption.

Supports clustering and broadcasting consumption.

Core Modules

Name Server

Acts as a stateless routing service; all producers, consumers, and brokers communicate with every NameServer in a one‑way fashion, simplifying horizontal scaling.

Broker Server

Provides remoting, client management, storage, HA, and indexing services.

Roles and Terminology

Producer : Sends messages to brokers; can send synchronously, asynchronously, or one‑way.

Producer Group : A set of producers that share transaction state.

Consumer : Pulls messages from brokers; can be push or pull type.

Consumer Group : Enables load balancing and fault tolerance; each group consumes a full copy of a topic.

Topic : Logical channel for publishing/subscribing.

Message : Payload with an associated topic, optional tag, and key‑value pairs.

Queue : A partition of a topic; ordering is guaranteed per queue.

Tag : Sub‑topic used for fine‑grained filtering.

Best Practices

Producer

Use one topic per application; differentiate sub‑types with tags.

Set a unique business key in keys for traceability.

Log sendResult and key for every send.

Implement retry mechanisms for failed sends; for fire‑and‑forget use sendOneWay.

Consumer

Ensure idempotent processing to avoid duplicate effects.

Prefer batch consumption to improve throughput.

Optimize the processing logic of each message.

Core MQ Issues

Problems Message Queues Solve

Asynchrony, decoupling, and traffic shaping, while introducing challenges such as duplicate delivery, ordering, loss, and retry handling.

Message Models

Evolution from simple FIFO queues to publish‑subscribe topics. RocketMQ adopts the publish‑subscribe model with queue partitions to achieve parallelism while preserving order per queue.

Reliability Guarantees

RocketMQ uses a request‑acknowledge mechanism at production, storage, and consumption stages. Configure flushDiskType=SYNCHRONOUS_FLUSH and multi‑node replication to avoid loss.

Duplicate Message Handling

Adopt idempotent business logic, database unique constraints, conditional updates, versioning, or token/GUID checks to ensure that repeated deliveries do not corrupt state.

Transactional Messages

Use half‑messages and local transaction checks; RocketMQ provides a transaction‑status‑check callback to resolve uncertain commits.

Ordering Guarantees

Maintain order at three stages: send, store, and consume. Route related messages to the same queue using a MessageQueueSelector (e.g., orderId % mqs.size()) and ensure a single consumer thread processes each queue.

long orderId = ((Order) object).getOrderId();
return mqs.get(orderId % mqs.size());

Both PullConsumer and PushConsumer implementations in RocketMQ preserve order by processing messages from a single ProcessQueue under a lock.

Acknowledgements

Content is based on the "Message Queue Expert" course from GeekTime and various public resources.