RabbitMQ with Spring Boot - Complete Reference Guide

What is RabbitMQ?

RabbitMQ is an open-source message broker that enables asynchronous communication between applications, microservices, and distributed systems using the AMQP (Advanced Message Queuing Protocol).

RabbitMQ helps decouple services, improve scalability, and ensure reliable message delivery.

RabbitMQ Architecture

Component Description
Producer Sends messages to an Exchange.
Exchange Routes messages to one or more queues.
Queue Stores messages until consumed.
Consumer Receives and processes messages from the queue.
Binding Connects Exchange and Queue using routing rules.

Maven Dependency

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

RabbitMQ Configuration

@Configuration
public class RabbitMQConfig {

    public static final String QUEUE = "test_queue";
    public static final String EXCHANGE = "test_exchange";
    public static final String ROUTING_KEY = "test_routing_key";

    @Bean
    public Queue queue() {
        return new Queue(QUEUE, false);
    }

    @Bean
    public TopicExchange exchange() {
        return new TopicExchange(EXCHANGE);
    }

    @Bean
    public Binding binding(
            Queue queue,
            TopicExchange exchange) {

        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with(ROUTING_KEY);
    }
}

Message Producer

@Service
public class RabbitMQProducer {

    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendMessage(String message) {

        amqpTemplate.convertAndSend(
                RabbitMQConfig.EXCHANGE,
                RabbitMQConfig.ROUTING_KEY,
                message);

        System.out.println(
                "Sent message = " + message);
    }
}

Message Consumer

@Service
public class RabbitMQConsumer {

    @RabbitListener(
            queues = RabbitMQConfig.QUEUE)
    public void receiveMessage(String message) {

        System.out.println(
                "Received message = " + message);
    }
}

REST Controller

@RestController
@RequestMapping("/rabbitmq")
public class MessageController {

    @Autowired
    private RabbitMQProducer producer;

    @GetMapping("/send")
    public ResponseEntity<String> send(
            @RequestParam String msg) {

        producer.sendMessage(msg);

        return ResponseEntity.ok(
                "Message sent to RabbitMQ");
    }
}

Test API

GET
http://localhost:8080/rabbitmq/send?msg=HelloRabbitMQ
Producer ? Exchange ? Queue ? Consumer

Clean Shutdown

docker stop some-rabbit

Exchange Types

Exchange Type Description
Direct Routes messages using exact routing key match.
Topic Routes messages using wildcard patterns.
Fanout Sends messages to all bound queues.
Headers Routes messages based on message headers.

Message Flow Example

Producer
   |
   v
Exchange
   |
   v
Routing Key
   |
   v
Queue
   |
   v
Consumer

Real-Time Use Cases

Advantages of RabbitMQ

Spring Boot Properties

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

Interview Questions

  1. What is RabbitMQ and why is it used?
  2. Difference between Queue and Exchange?
  3. Difference between Direct, Topic, Fanout and Headers Exchange?
  4. What is a Dead Letter Queue (DLQ)?
  5. How does RabbitMQ guarantee message delivery?
  6. What is Publisher Confirm?
  7. What is Consumer Acknowledgement?
  8. How do you handle failed messages?
  9. Difference between Kafka and RabbitMQ?
  10. How do you scale RabbitMQ consumers?

RabbitMQ Interview Quick Reference

1. What is RabbitMQ and Why is it Used?

RabbitMQ is a message broker used for asynchronous communication between applications.

Uses: Decoupling services, scalability, reliability, event-driven architecture.

Order Service --> RabbitMQ --> Email Service
    

2. Difference Between Queue and Exchange?

Queue Exchange
Stores messages Routes messages
Consumer reads from queue Producer sends to exchange
Producer -> Exchange -> Queue -> Consumer
    

3. Direct vs Topic vs Fanout vs Headers Exchange

Exchange Routing Logic
Direct Exact routing key match
Topic Pattern matching (*, #)
Fanout Broadcast to all queues
Headers Uses message headers
Direct : order.created

Topic : order.*

Fanout : Send to all queues

Headers : department=finance
    

4. What is a Dead Letter Queue (DLQ)?

Failed or rejected messages are moved to DLQ for later analysis.

Main Queue --> DLQ
    

5. How Does RabbitMQ Guarantee Message Delivery?

channel.basicPublish(...,
MessageProperties.PERSISTENT_TEXT_PLAIN);
    

6. What is Publisher Confirm?

RabbitMQ sends confirmation to publisher after storing the message successfully.

channel.confirmSelect();
channel.waitForConfirms();
    

7. What is Consumer Acknowledgement?

Consumer informs RabbitMQ that message processing completed successfully.

channel.basicAck(
deliveryTag,
false
);
    

8. How Do You Handle Failed Messages?

try{
   process();
}catch(Exception e){
   sendToDLQ();
}
    

9. Difference Between Kafka and RabbitMQ?

Kafka RabbitMQ
Distributed Event Streaming Message Broker
Very High Throughput Low Latency Messaging
Stores Events for Long Time Deletes After Consumption
Best for Event Streaming Best for Task Queues

10. How Do You Scale RabbitMQ Consumers?

Add multiple consumers to the same queue.

Queue
  |
  +-- Consumer 1
  +-- Consumer 2
  +-- Consumer 3
  +-- Consumer 4
    

RabbitMQ distributes messages using round-robin load balancing.

Quick Interview One-Liners

Question One-Line Answer
RabbitMQ Message broker used for asynchronous communication between applications.
Queue Stores messages until they are consumed.
Exchange Routes messages to one or more queues.
Direct Exchange Routes messages based on exact routing key match.
Topic Exchange Routes messages using wildcard routing patterns.
Fanout Exchange Broadcasts messages to all bound queues.
Headers Exchange Routes messages based on message headers.
Dead Letter Queue (DLQ) Stores failed, expired, or rejected messages.
Message Delivery Guarantee Achieved using durable queues, persistent messages, confirms, and acknowledgements.
Publisher Confirm Broker confirms that a published message was received successfully.
Consumer Acknowledgement Consumer confirms successful message processing.
Failed Message Handling Use retries, DLQ, logging, and monitoring.
Kafka vs RabbitMQ Kafka is event streaming; RabbitMQ is message queuing.
Scaling Consumers Add multiple consumers to the same queue for parallel processing.
Round Robin RabbitMQ distributes messages evenly across active consumers.
Durable Queue Queue survives RabbitMQ server restarts.
Persistent Message Message is stored on disk to avoid loss during crashes.
Binding Connects an exchange to a queue using routing rules.
Routing Key Used by exchanges to determine message destination.
Virtual Host (vHost) Logical isolation of RabbitMQ resources and users.
Prefetch Count Limits the number of unacknowledged messages per consumer.