d1. Introduction
RabbitMQ is a powerful open source message middleware, using AMQP (Advanced Message Queuing Protocol) protocol to achieve reliable message delivery. It provides reliability, flexibility, and scalability, and is widely used in scenarios such as distributed systems, microservice architecture, and asynchronous communication. This article will introduce the concepts, features and principles of RabbitMQ to help readers fully understand this powerful message middleware.
Concepts and basic terms:
- Message middleware: explains the concept and role of message middleware, and why message middleware is used in distributed systems.
- Queue: introduces the concept of queues in RabbitMQ, including queue declarations, bindings, and consumer subscriptions.
- Exchange (Exchange): Explains the role and types of exchanges, including direct-connect exchanges, sector exchanges, and topic exchanges.
- Binding: Introduces how to bind queues and switches, and the concept of binding rules.
Basic Features:
- reliability:
- Message persistence: RabbitMQ supports message persistence to disk to ensure that messages will not be lost after server failure or restart.
- Message confirmation mechanism: Producers can obtain consumer confirmation of messages through the message confirmation mechanism to ensure that messages are successfully processed.
- Reliability guarantee: RabbitMQ provides a variety of mechanisms to ensure the reliable delivery of messages, such as publishing confirmation, transaction mechanism, etc.
- flexibility:
- Multiple message modes: RabbitMQ supports multiple message modes, including simple mode, working mode, publish/subscribe mode and topic mode, to meet different business needs.
- Dynamic routing: Through switches and routing rules, RabbitMQ provides a flexible message routing mechanism that allows messages to be sent to different queues based on their content and attributes.
- Multilingual support:
- RabbitMQ provides a wealth of client libraries and APIs, and supports multiple programming languages, such as Java, Python, C#, Ruby, etc., which is convenient for developers to integrate and use.
- Programmability:
- RabbitMQ provides a flexible programming interface and plug-in mechanism, allowing developers to customize and expand according to business needs.
- Scalability:
- High concurrency processing: RabbitMQ can handle a large number of concurrent messages, suitable for high concurrency scenarios and large-scale message processing.
- Horizontal expansion: By clustering multiple RabbitMQ nodes, horizontal expansion and load balancing can be achieved, and the throughput and reliability of message processing can be improved.
2. Architecture
3. Message mode
The following is the message mode on the official website:
- Simple mode Simple: a producer binds a consumer to a queue
- Working mode Work: one producer and multiple consumers consume the same queue
- Point-to-point mode type=Direct: one producer has multiple consumers, and binds a specific queue through exchange and routingkey
- Fan-shaped mode (publish/subscribe mode) type=Fanout: one producer has multiple consumers, and multiple queues are bound through the exchange
- Topic mode type=Topic: bind multiple queues, and add topic wildcard * #
To sum up, it can be divided into producers sending directly to Queue and producers routing to Queue
4. Routing mechanism
In RabbitMQ, there are several different types of exchanges available, including direct exchanges, topic exchanges, and fanout exchanges. Different types of exchanges use different routing rules.
The following are several common routing mechanisms in RabbitMQ:
- Direct Exchange: A direct exchange is the simplest type of exchange and routes messages to queues that exactly match the routing key in the message. When creating a binding, you need to specify the routing key between the queue and the exchange.
- Topic Exchange: A topic exchange routes messages to one or more queues based on wildcard matching rules. Wildcards can use * (match one word) and # (match zero or more words). The producer specifies a routing key when sending a message, and the exchange routes the message to the corresponding queue according to the bound routing key and topic rules.
- Fanout Exchange: A fanout exchange broadcasts messages to all queues bound to the exchange. It ignores routing keys and simply sends messages to all queues bound to the exchange. Fanout Exchange is what we usually call broadcast or publish and subscribe mode.
The choice of routing mechanism depends on the needs of the application and the routing strategy for messages. Through judicious use of exchanges and bindings, message routing and distribution can be done flexibly.
5. Acknowledgment mechanism (ACK)
In RabbitMQ, the message acknowledgment (acknowledgment) mechanism is used to ensure the reliable delivery and processing of messages. The acknowledgment mechanism involves two actors: producer and consumer.
After the producer publishes a message to RabbitMQ, it can choose to wait for the consumer's response to confirm whether the message has been successfully received and processed. After the consumer receives and processes the message, it will send a response to RabbitMQ, informing that the message has been processed.
// 手动发送应答
channel.basicAck(envelope.getDeliveryTag(), false);
System.out.println("Acknowledged message: " + message);6. Orderliness
In RabbitMQ, the order of messages is relative to each queue, not the entire RabbitMQ message flow. RabbitMQ guarantees the order of messages in a single queue, that is, delivery and consumption are performed in the order of messages.
When a producer sends messages to a queue, RabbitMQ arranges them in first-in-first-out (FIFO) order. When consumers get messages from the queue, they also receive messages in the same order.
7. Affairs
In RabbitMQ, transactions can be used to ensure reliable delivery of messages. Transactions provide a mechanism to commit or roll back a set of operations as an atomic unit, guaranteeing message integrity.
The steps to use transactions are as follows:
- Create a channel (Channel) and enable transaction mode: First, create a RabbitMQ connection and create a channel on the connection. Then, enable transaction mode by calling the channel.txSelect() method.
- Publish a message to the queue: In transaction mode, the message is published to the specified queue by calling the channel.basicPublish() method.
- Commit the transaction or roll back: After you finish publishing the message, you can choose to commit the transaction or roll back the transaction. If all operations are completed successfully, the transaction can be committed by calling the channel.txCommit() method. If an error occurs or the transaction needs to be rolled back, the transaction can be rolled back by calling the channel.txRollback() method.
8, endurance
In RabbitMQ, message persistence is a mechanism to ensure that messages will not be lost in the event of an exception or server failure. By setting messages and queues to be persistent, messages can persist across RabbitMQ restarts.
To achieve message persistence, the following two aspects need to be considered:
- Queue persistence: When declaring a queue, set the durable parameter to true to mark the queue as a persistent queue. For example:
channel.queueDeclare("my_queue", true, false, false, null);- Message persistence: When publishing a message, set the deliveryMode attribute of BasicProperties to 2 to mark the message as a persistent message. For example:
AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
.deliveryMode(2) // 持久化消息
.build();
channel.basicPublish("", "my_queue", properties, message.getBytes());9. Multilingual
10. Download and install
Installation Guide:
https://www.rabbitmq.com/download.html
===========================================
If the article is helpful to you, please don't forget to add attention and like it. Must return to close!