RabbitMQ is a message broker implementing the AMQP protocol. It routes messages from producers to consumers through exchanges and queues with flexible routing patterns.

Core Concepts 

  Producer → Exchange → Binding → Queue → Consumer
Component Role
Producer Sends messages
Exchange Routes messages to queues
Binding Link between exchange and queue
Queue Stores messages until consumed
Consumer Receives and processes messages

Exchange Types

Type Routing Use case
Direct Exact routing key match Point-to-point
Fanout Broadcast to all bound queues Pub/sub
Topic Pattern matching on routing key Selective routing
Headers Match on message headers Complex routing

Java Client Setup 

  <dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.20.0</version>
</dependency>

Basic Producer 

  ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost");
factory.setUsername("guest");
factory.setPassword("guest");

try (Connection connection = factory.newConnection();
     Channel channel = connection.createChannel()) {

    channel.queueDeclare("task_queue", true, false, false, null);
    String message = "Process order #12345";
    channel.basicPublish("", "task_queue",
        MessageProperties.PERSISTENT_TEXT_PLAIN,
        message.getBytes(StandardCharsets.UTF_8));
}

Basic Consumer 

  channel.basicQos(1);  // one message at a time
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
    String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
    processTask(message);
    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
};
channel.basicConsume("task_queue", false, deliverCallback, consumerTag -> {});

Spring AMQP 

  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
  
  spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
  
  @Service
public class OrderProducer {
    private final RabbitTemplate rabbitTemplate;

    public void sendOrder(OrderEvent event) {
        rabbitTemplate.convertAndSend("orders.exchange", "order.created", event);
    }
}

@Component
public class OrderConsumer {
    @RabbitListener(queues = "orders.queue")
    public void handleOrder(OrderEvent event) {
        processOrder(event);
    }
}

Message Acknowledgment

Mode Behavior
Auto ack Acknowledged on delivery (may lose messages)
Manual ack Consumer explicitly acks after processing
Nack + requeue Return message to queue for retry
Nack + reject Send to dead letter queue

Best Practices

  • Use durable queues and persistent messages in production
  • Enable manual acknowledgment for reliable processing
  • Configure dead letter exchanges for failed messages
  • Set prefetch count (basicQos) to prevent consumer overload
  • Use Spring AMQP for Spring Boot applications