Spring Message Queue using RabbitMQ: An Ultimate Guide 101

on Message Queue, RabbitMQ, Spring • May 19th, 2022 • Write for Hevo

spring message queue - featured image

Organizations today have achieved great heights with microservice-based architectures in modern applications. Spring Boot is one such Open-source framework that allows you to create microservice applications effortlessly. With Spring, you can add several components like Message Broker, Databases, GUI, Configuration Files, Repositories, Containers, API Gateway, and more services. To provide seamless functioning of these applications, communication between such services is essential. You can leverage RabbitMQ Message Broker for obtaining efficient communication between microservice-based applications. 

In this article, you will learn to set up a Spring Message Queue using RabbitMQ.

Table of Contents


Fundamental understanding of microservices

What is RabbitMQ?

spring message queue: rabbit mq logo
Image credit: RabbitMQ

Developed in 2007, RabbitMQ is one of the most popular, lightweight, Open-source Messaging Servers used worldwide by organizations. It is a message broker that accepts and forwards messages among applications. RabbitMQ consists of queues defined for connecting to applications for transferring messages. These messages can be information about a process or task, text messages, and more. Such messages are stored temporarily in RabbitMQ until the applications receive them. Therefore, RabbitMQ enables users to be part of larger applications using devices or data. It is also called Queue Manager.

RabbitMQ supports several messaging protocols like AMQP (Advanced Message Queueing Protocol), STOMP (Simple Text Oriented Messaging Protocol),  MQTT (The standard for IoT Messaging), and more. It also executes on multiple operating systems and provides developer tools for popular languages.

Key Features of RabbitMQ

  • Distributed Deployment: Users can deploy RabbitMQ as clusters for high availability and throughput. These clusters are located across multiple availability zones and regions to be available quickly.
  • Asynchronous Messaging: RabbitMQ supports multiple messaging protocols, message queueing, delivery acknowledgment, and exchange boxes.
  • Lightweight: RabbitMQ is lightweight, as the systems require less than 40 MB to run the core application and plugins. But adding messages to the queue will increase memory usage.
  • Tools and Plugins: RabbitMQ offers a variety of tools and plugins for continuous integration, operational metrics, and integration to other enterprise systems.
  • Flexibility in Controlling Messaging Trade-offs: RabbitMQ enables you to control the trade-offs between message throughput and performance. All the messages in the queue can specify where they should be saved to a disc before delivery. Queue in a cluster can span multiple servers, ensuring that no messages are lost in the event of a server failure.

Simplify ETL Using Hevo’s No-Code Data Pipeline

Hevo Data, a Fully-managed Data Pipeline platform, can help you automate, simplify & enrich your data replication process in a few clicks. With Hevo’s wide variety of connectors and blazing-fast Data Pipelines, you can extract & load data from 100+ Data Sources straight into Data Warehouses, or any Databases. To further streamline and prepare your data for analysis, you can process and enrich raw granular data using Hevo’s robust & built-in Transformation Layer without writing a single line of code!


Hevo is the fastest, easiest, and most reliable data replication platform that will save your engineering bandwidth and time multifold. Try our 14-day full access free trial today to experience an entirely automated hassle-free Data Replication!

Basic Concepts of RabbitMQ

The following are some of the basic terminologies associated with RabbitMQ:

  • Producer (Publisher): It is the one who sends messages to the queue based on the queue name.
  • Queue: It is a sequential data structure that acts as a medium through which messages are transferred and stored.
  • Consumer (Subscriber): It is the one who subscribes to and receives messages from the broker and uses those messages for other operations.
  • Exchange: It is an entry point for the broker because it takes messages from the publisher and routes the messages to appropriate queues.
  • Broker: It is a message broker that provides storage for data produced. The data produced should be consumed or received by another application connected to the broker.

How to Build a Spring Message Queue using RabbitMQ?

AMQP is a message protocol that deals with publishers and consumers. It is used for passing messages between organizations or applications. You will set up the RabbitMQ AMQP server that publishes and subscribes to messages along with the Spring Boot application. 

You will build an application that publishes a message using Spring’s AMQP’s RabbitTemplate and subscribes to the message on POJO by MessageListenerAdapter.


  • A text editor or IDE
  • JDK 11 or later
  • Gradle 4+ or Maven 3.2+

Step 1: Set up the RabbitMQ Broker

Before building your messaging application for the Spring Message Queue, you must set up a RabbitMQ server to handle receiving and sending messages. To set up the RabbitMQ message broker, follow the below steps.

  • Download the RabbitMQ server.
  • To unpack the server and launch the server with default settings, run the below command in a terminal.


spring message queue: rabbit mq broker install
Image credit: Spring

The Docker Compose can also be used to launch a RabbitMQ Server.

Step 2: Starting with Spring Initialzr

Spring Initialzr is a web-based tool that generates the Spring Boot Project structure for the Spring Message Queue.

Follow the below steps to initialize Spring.

  • Go to Spring Initialzr; it will pull all the dependencies required for an application.
  • Choose Gradle or Maven and then the language you want to use. (This article uses Java language.) 
  • Click on Dependencies and select Spring for RabbitMQ to create the Spring Message queue.
  • Click on Generate.
  • Download the resulting zip file that is an archive of a web application configured with your choices.

Step 3: Create a RabbitMQ Message Receiver

You must create a receiver that responds to published messages for any message-based application of the Spring Message Queue. Therefore, include the below code in:


package com.example.messagingrabbitmq;

import java.util.concurrent.CountDownLatch;
import org.springframework.stereotype.Component;

public class Receiver {

  private CountDownLatch latch = new CountDownLatch(1);

  public void receiveMessage(String message) {
    System.out.println("Received <" + message + ">");

  public CountDownLatch getLatch() {
    return latch;


The receiver for the Spring Message Queue is a POJO, which defines a method for receiving messages.

Step 4: Register the Listener and Send a Message

Spring’s AMQP RabbitTemplate provides all the functionalities needed to send and receive messages for Spring Message Queue with RabbitMQ. Although, you need to:

  • Configure a message listener container.
  • Declare the Queue and Exchange. Then declare the binding between Queue and Exchange.
  • Configure a component for sending some messages to test the listener.

Spring Boot will automatically create a connection factory and a RabbitMQ, which will reduce the amount of code. A connection factory encapsulates the set of configuration parameters that the administrator defines.
You can use RabbitTemplate to send messages. You need to register a Receiver for Spring Message queue with the message listener container to receive messages. The connection factory drives Receiver and RabbitTemplate by connecting them to the RabbitMQ server. Therefore, include the below code:


To connect Receiver and RabbitTemplate to the RabbitMQ server for the Spring Message queue:

package com.example.messagingrabbitmq;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.rabbit.listener.adapter.MessageListenerAdapter;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

public class MessagingRabbitmqApplication {

  static final String topicExchangeName = "spring-boot-exchange";

  static final String queueName = "spring-boot";

  Queue queue() {
    return new Queue(queueName, false);

  TopicExchange exchange() {
    return new TopicExchange(topicExchangeName);

  Binding binding(Queue queue, TopicExchange exchange) {
    return BindingBuilder.bind(queue).to(exchange).with("foo.bar.#");

  SimpleMessageListenerContainer container(ConnectionFactory connectionFactory,
      MessageListenerAdapter listenerAdapter) {
    SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
    return container;

  MessageListenerAdapter listenerAdapter(Receiver receiver) {
    return new MessageListenerAdapter(receiver, "receiveMessage");

  public static void main(String[] args) throws InterruptedException {
    SpringApplication.run(MessagingRabbitmqApplication.class, args).close();


From above, 

@SpringBootApplication: It is a convenience annotation that adds all of the following:

  1. @Configuration: It is used to tag the class as a source of bean definitions for the application context. Beans are the objects that construct the backbone of your Spring application. They are managed by Spring IoC Container.
  2. @EnableAutoConfiguration: It tells the Spring Boot to start adding beans based on classpath settings, other beans, and other property settings. 

@ComponentScan: It tells Spring to look for other components, configurations, and services in the com/example package.

The main() method uses Spring Boot’s StringApplication.run() method to launch an application.

The bean that is defined in the listenerAdapter() method is registered as a Message Listener in the container defined in container(). It also listens for messages on the Spring-boot queue. Since the receiver class is a POJO, it needs to be wrapped in MessageListenerAdapter

The message listener container and receiver beans are needed for listening to the messages. You also need a RabbitMQ template to send a message.

  • queue(): It creates an AMQP queue.
  • exchange(): It creates a topic exchange.
  • binding(): It binds queues and exchanges together. It defines the behavior that occurs when RabbitTemplate publishes to an exchange.

In this article, you have used topic exchange and the queue with routing key of foo.bar.#, meaning any messages sent with a routing key that begins with foo.bar is routed to the queue.

Step 5: Send a Test Message

The test messages for verifying the Spring Message queue are sent by a CommandLineRunner. CommandLineRunner waits for the latch in the receiver and closes the application context. Therefore, include the below code to send a test message for the Spring Message queue:

package com.example.messagingrabbitmq;

import java.util.concurrent.TimeUnit;

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

public class Runner implements CommandLineRunner {

  private final RabbitTemplate rabbitTemplate;
  private final Receiver receiver;

  public Runner(Receiver receiver, RabbitTemplate rabbitTemplate) {
    this.receiver = receiver;
    this.rabbitTemplate = rabbitTemplate;

  public void run(String... args) throws Exception {
    System.out.println("Sending message...");
    rabbitTemplate.convertAndSend(MessagingRabbitmqApplication.topicExchangeName, "foo.bar.baz", "Hello from RabbitMQ!");
    receiver.getLatch().await(10000, TimeUnit.MILLISECONDS);

Step 6: Run the Application

The main() method starts the application by starting the message listener container, which starts listening for the messages in the Spring Message queue. There is a Runner Bean that runs automatically after starting the Message Listener container for the Spring Message queue. It retrieves the RabbitTemplate from the application context and sends a ‘Hello from RabbitMQ!’ message on the spring-boot queue. Runner Bean then closes the Spring application context. Therefore, the application ends.

What Makes Hevo’s Data Pipeline Unique?

Providing a high-quality ETL solution can be a difficult task if you have a large volume of data. Hevo’s automated, No-code platform empowers you with everything you need to have for a smooth data replication experience.

Check out what makes Hevo amazing:

  • Fully Managed: Hevo requires no management and maintenance as it is a fully automated platform.
  • Data Transformation: Hevo provides a simple interface to perfect, modify, and enrich the data you want to transfer.
  • Faster Insight Generation: Hevo offers near real-time data replication so you have access to real-time insight generation and faster decision making. 
  • Schema Management: Hevo can automatically detect the schema of the incoming data and map it to the destination schema.
  • Scalable Infrastructure: Hevo has in-built integrations for 100+ sources (with 40+ free sources) that can help you scale your data infrastructure as required.
  • Live Support: Hevo team is available round the clock to extend exceptional support to its customers through chat, email, and support calls.
Sign up here for a 14-day free trial!

Step 7: Build an Executable JAR

You can run the application for the Spring Message Queue using the command line with Gradle or Maven. A single executable JAR can also be built, which contains all the necessary dependencies, classes, and resources and execute them.

If you want to use Gradle, run the application using ./gradlew bootRun. Instead, you can build the JAR file with ./gradlew build and then run the JAR file using the below command.

java -jar build/libs/gs-messaging-rabbitmq-0.1.0.jar

If you want to use Maven, run the application for Spring Message queue using ./mvnw spring-boot:run. Instead, you can build the JAR file with ./mvnw clean package build and then run the JAR file using the below command.

java -jar target/gs-messaging-rabbitmq-0.1.0.jar


spring message queue: rabbitMQ sending message output
Image credit: Spring

Therefore, you have developed a simple publish-and-subscribe application for the Spring Message queue using RabbitMQ.


In this article, you learned about setting up a simple publish-subscribe application for the Spring Message Queue using RabbitMQ. This article also focuses on the features and basic concepts of RabbitMQ. Organizations use RabbitMQ to develop and manage scalable applications. Organizations like JPMorgan Chase, Doordash, FireEye, Radancy, Salesforce, Citi, and more currently use RabbitMQ for their Microservices architecture.

There are various Data Sources that organizations leverage to capture a variety of valuable data points. But, transferring data from these sources into a Data Warehouse for a holistic analysis is a hectic task. It requires you to code and maintains complex functions that can help achieve a smooth flow of data. An Automated Data Pipeline helps in solving this issue and this is where Hevo comes into the picture. Hevo Data is a No-code Data Pipeline and has awesome 100+ pre-built Integrations that you can choose from.

visit our website to explore hevo

Hevo can help you Integrate your data from 100+ data sources and load them into a destination to analyze real-time data at an affordable price. It will make your life easier and Data Migration hassle-free. It is user-friendly, reliable, and secure.

SIGN UP for a 14-day free trial and see the difference!

Share your experience of learning about Spring Message queue in the comments section below.

No-code Data Pipeline For your Data Warehouse