RabbitMQ integration basics in Spring Boot - Mini Project: Build & Apply

RabbitMQ integration basics

📖 Scenario: You are building a simple Spring Boot application that sends and receives messages using RabbitMQ. This is common in real-world apps where different parts communicate asynchronously, like order processing systems.

🎯 Goal: Build a Spring Boot app that defines a RabbitMQ queue, sends a message to it, and listens to receive messages from it.

📋 What You'll Learn

Create a RabbitMQ queue bean named helloQueue with the value hello

Create a configuration property rabbitmqExchange with value helloExchange

Write a method sendMessage in a service to send a message Hello, RabbitMQ! to the queue

Write a listener method receiveMessage that listens to the helloQueue and logs the received message

💡 Why This Matters

🌍 Real World

Many applications use RabbitMQ to decouple components and handle tasks asynchronously, such as sending emails, processing orders, or updating caches.

💼 Career

Understanding RabbitMQ integration with Spring Boot is valuable for backend developers working on scalable, event-driven systems.

1

Define the RabbitMQ queue bean

In your Spring Boot application, create a configuration class called RabbitConfig. Inside it, define a bean method called helloQueue that returns a new Queue with the name "hello".

Spring Boot

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.core.Queue;

@Configuration
public class RabbitConfig {
    // Define the queue bean here
}

Hint

Use @Bean annotation on a method that returns new Queue("hello").

2

Add a configuration property for the exchange

In the RabbitConfig class, add a public static final String variable called rabbitmqExchange and set it to "helloExchange".

Spring Boot

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.core.Queue;

@Configuration
public class RabbitConfig {
    @Bean
    public Queue helloQueue() {
        return new Queue("hello");
    }

    // Define rabbitmqExchange variable here
}

Hint

Declare a public static final String variable with the exact name and value.

3

Create a service method to send a message

Create a Spring service class called MessageSender. Inject AmqpTemplate via constructor. Add a method sendMessage that sends the string "Hello, RabbitMQ!" to the queue named "hello" using convertAndSend.

Spring Boot

import org.springframework.stereotype.Service;
import org.springframework.amqp.core.AmqpTemplate;

@Service
public class MessageSender {
    private final AmqpTemplate amqpTemplate;

    public MessageSender(AmqpTemplate amqpTemplate) {
        this.amqpTemplate = amqpTemplate;
    }

    // Add sendMessage method here
}

Hint

Use amqpTemplate.convertAndSend with the queue name and message string.

4

Add a listener method to receive messages

Create a Spring service class called MessageListener. Add a method receiveMessage annotated with @RabbitListener(queues = "hello"). The method should accept a String message parameter and log it using System.out.println with the prefix "Received:".

Spring Boot

import org.springframework.stereotype.Service;
import org.springframework.amqp.rabbit.annotation.RabbitListener;

@Service
public class MessageListener {
    // Add receiveMessage method here
}

Hint

Use @RabbitListener annotation on the method and print the message with the prefix.

Practice

1. What is the primary role of @RabbitListener annotation in Spring Boot RabbitMQ integration?

easy

A. To configure RabbitMQ connection settings

B. To mark a method that listens for messages from a RabbitMQ queue

C. To send messages to a RabbitMQ queue

D. To declare a RabbitMQ queue

Solution

1. Step 1: Understand the purpose of @RabbitListener

   @RabbitListener is used to mark methods that should receive messages asynchronously from a RabbitMQ queue.

2. Step 2: Differentiate from other RabbitMQ tasks

   Sending messages is done by RabbitTemplate, and queue declaration is done by configuration or annotations like @Queue. Connection settings are configured separately.

3. Final Answer:

   To mark a method that listens for messages from a RabbitMQ queue -> Option B

4. Quick Check:

   @RabbitListener = listens to messages [OK]

Hint: Listener annotation marks methods to receive messages [OK]

Common Mistakes:

• Confusing @RabbitListener with sending messages
• Thinking it configures connection settings
• Assuming it declares queues

2. Which of the following is the correct way to send a message to a RabbitMQ queue named myQueue using RabbitTemplate in Spring Boot?

easy

A. rabbitTemplate.convertAndSend("myQueue", "Hello World")

B. rabbitTemplate.send("myQueue", "Hello World")

C. rabbitTemplate.receive("myQueue", "Hello World")

D. rabbitTemplate.listen("myQueue", "Hello World")

Solution

1. Step 1: Identify the correct RabbitTemplate method for sending messages

   RabbitTemplate uses convertAndSend to send messages converting objects to message format.

2. Step 2: Check other options for correctness

   send requires a Message object, not a String directly. receive and listen are not used for sending messages.

3. Final Answer:

   rabbitTemplate.convertAndSend("myQueue", "Hello World") -> Option A

4. Quick Check:

   Send message = convertAndSend [OK]

Hint: Use convertAndSend to send messages with RabbitTemplate [OK]

Common Mistakes:

• Using send() with a plain string instead of a Message object
• Confusing receive() with sending
• Trying to use listen() method which doesn't exist

3. Given the following Spring Boot RabbitMQ listener method, what will be printed when a message "Test Message" arrives in the queue?

@RabbitListener(queues = "testQueue")
public void receiveMessage(String message) {
    System.out.println("Received: " + message);
}

medium

A. No output, method is not called

B. Test Message

C. Received message

D. Received: Test Message

Solution

1. Step 1: Understand the listener method behavior

   The method receives the message string and prints it prefixed with "Received: ".

2. Step 2: Substitute the message content

   When "Test Message" arrives, the output will be "Received: Test Message".

3. Final Answer:

   Received: Test Message -> Option D

4. Quick Check:

   Prints "Received: " + message [OK]

Hint: Listener prints message with prefix 'Received:' [OK]

Common Mistakes:

• Assuming only message content is printed
• Thinking method won't be called automatically
• Ignoring the print statement prefix

4. Identify the error in the following Spring Boot RabbitMQ listener code snippet:

@RabbitListener(queues = "myQueue")
public void listen() {
    System.out.println("Message received");
}

medium

A. Method must have a parameter to receive the message

B. @RabbitListener annotation is missing queue name

C. Method should return a value

D. System.out.println is not allowed in listener methods

Solution

1. Step 1: Check method signature for message reception

   Listener methods must have a parameter to receive the message payload, usually a String or object.

2. Step 2: Verify other options

   The queue name is present, returning a value is not required, and printing is allowed for debugging.

3. Final Answer:

   Method must have a parameter to receive the message -> Option A

4. Quick Check:

   Listener needs parameter for message [OK]

Hint: Listener methods need a parameter to get messages [OK]

Common Mistakes:

• Omitting the message parameter
• Thinking return value is mandatory
• Assuming printing is disallowed

5. You want to send a Java object User to a RabbitMQ queue and receive it back as the same object type using Spring Boot. Which combination of steps is correct to achieve this?

hard

A. Use RabbitTemplate.convertAndSend() to send, and @RabbitListener with String parameter to receive

B. Use RabbitTemplate.send() with a String message, and @RabbitListener with String parameter

C. Use RabbitTemplate.convertAndSend() to send, and @RabbitListener with a User parameter to receive

D. Use RabbitTemplate.send() with a User object, and @RabbitListener with Object parameter

Solution

1. Step 1: Sending Java objects with RabbitTemplate

   RabbitTemplate.convertAndSend() converts Java objects to messages automatically, suitable for sending User objects.

2. Step 2: Receiving and converting messages back to objects

   @RabbitListener methods can declare a parameter of type User to receive and convert the message back to the User object.

3. Final Answer:

   Use RabbitTemplate.convertAndSend() to send, and @RabbitListener with a User parameter to receive -> Option C

4. Quick Check:

   convertAndSend + typed @RabbitListener = object transfer [OK]

Hint: Use convertAndSend and typed listener parameter for objects [OK]

Common Mistakes:

• Using send() with plain strings for objects
• Receiving as String when sending objects
• Not matching parameter type in listener