Table of Contents

Transactions

Message Distribution 

Use Cases

 1. Rate Limiting

2. Load Balancing 

Transactions

RabbitMQ is implemented based on the AMQP protocol, which realizes transaction mechanisms. Therefore, RabbitMQ also supports transaction mechanisms. SpringAMQP also provides operations related to transactions. RabbitMQ transactions allow developers to ensure that message sending and receiving are atomic, either all successful or all failed.

What is Atomicity (Key Point in Interview)?

For example: When A transfers 1000 yuan to B, it involves two steps:

1.A transfers 1000 yuan to B, which will deduct 1000 yuan from A’s account.

2.B receives 1000 yuan, and B’s account will be increased by 1000 yuan.

However, in extreme cases, if A transfers 1000 yuan to B, and the deduction from A is completed (A-1000), but due to system failure, B does not receive the money. This would result in the disappearance of 1000 yuan without a trace, which is unacceptable as no one would dare to make transfers under such circumstances.

At this point, both operations 1 and 2 are bound together; they must either be completed simultaneously or not executed at all.

If operation 1 fails, it will be “rolled back” to its original state, as if nothing ever happened.

Next, implement RabbitMQ transactions:

Declare queue:

Configure transaction manager:

Producer code writing:

1）Without @Transactional and with exception, what happens during message sending?

 

At this point, only the first message was sent, and then an exception occurred, preventing the second message from being sent successfully.

 

2) Sending with <@Transactional> and exceptions: What happens?

 

At this point, an exception occurred. Although one message was sent, the presence of the exception caused a rollback, effectively undoing the operation.

This demonstrates the reliability of our transaction handling.

 3) Sending with <@Transactional> and without exceptions: What happens?

 All results are normal

---

Message Distribution

When RabbitMQ queues have multiple consumers, the queue will distribute received messages to different consumers. Each message is only sent to one consumer in the subscription list. This approach is very suitable for scaling; if the load increases, simply create more consumers to handle messages.

By default, RabbitMQ distributes messages using a round-robin method, regardless of whether consumers have already consumed and confirmed the message. This approach is not very reasonable. Imagine if some consumers have slower consumption speeds while others are faster, which could lead to message accumulation for slow consumers and idle time for fast ones, thereby reducing the overall throughput of the application.

After completing all 10 tasks, A finds that B is still working on the first task. This will significantly reduce efficiency and lead to a overall decline in performance.

To address this issue, we can utilize the channel.basicQos(intprefetchCount) method discussed earlier. This limits the maximum number of unacknowledged messages that consumers can hold on a channel.

For example: When the consumer calls channelbasicQos(1),

A receives one message and processes it, while B also receives one message but works at a slower pace. Since A finishes processing the first message, it proceeds to handle the second message. This way, efficiency is maintained as A can work on multiple tasks without being held back by B’s slower processing.

Use Cases

 1. Flow Control

In the following scenario:
An order system can handle up to 5,000 requests per second under normal circumstances.
However, during a flash sale, requests surge to 10,000 per second, which could overwhelm the order system if all are sent via MQ.

RabbitMQ provides flow control mechanisms. It limits the number of requests a consumer pulls at once by setting prefetchCount. Additionally, message acknowledgment must be set to manual.
prefetchCount: Controls how many messages a consumer can prefetch from the queue. This helps achieve flow control and load balancing.

1) Configure the prefetch parameter and set the response method to manual acknowledgment

 2) Configure switch and queue

package com.bite.extensions.config; import com.bite.extensions.constant.Constants; import org.springframework.amqp.core.*; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class QosConfig { @Bean(“qosQueue”) public Queue qosQueue() { return QueueBuilder.durable(Constants.QOS_QUEUE).build(); } @Bean(“qosExchange”) public DirectExchange qosExchange() { return ExchangeBuilder.directExchange(Constants.QOS_EXCHANGE).build(); } @Bean(“qosBinding”) public Binding qosBinding(@Qualifier(“qosQueue”) Queue queue, @Qualifier(“qosExchange”) DirectExchange directExchange) { return BindingBuilder.bind(queue).to(directExchange).with(“qos”); } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

package com.bite.extensions.config; import com.bite.extensions.constant.Constants; import org.springframework.amqp.core.*; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class QosConfig { @Bean(“qosQueue”) public Queue qosQueue() { return QueueBuilder.durable(Constants.QOS_QUEUE).build(); } @Bean(“qosExchange”) public DirectExchange qosExchange() { return  ExchangeBuilder.directExchange(Constants.QOS_EXCHANGE).build(); } @Bean(“qosBinding”) public Binding qosBinding(@Qualifier(“qosQueue”) Queue queue, @Qualifier(“qosExchange”) DirectExchange directExchange) { return BindingBuilder.bind(queue).to(directExchange).with(“qos”); } }

3) Producer

4）Consumer

 

 Result:

Here, it can be observed that each consumer completes a task at different speeds to prevent one consumer from waiting too long if another has not finished their part.

---

Conclusion: Blogging is not only about sharing learning experiences but also helps in reinforcing knowledge and summarizing key points. Due to the author’s limited proficiency, any issues or errors in the article are welcome for critique, as it aids in improvement. Additionally, the author greatly appreciates your encouragement through likes, collections, and follows; these actions are the primary motivation behind the creation of this content.