Event-driven communication with messaging queues is like having a virtual post office where system components can send and receive messages without waiting for each other. It's a pattern that allows different parts of a system to talk to each other asynchronously, which means they don't have to be in sync all the time. This setup is super useful for building systems that can handle lots of events happening at once, and it makes the whole microservices architecture more flexible and scalable.
Key Terminologies:
- Message Queue: It's like a virtual mailbox where components can send and receive messages without having to wait for each other. It's a buffer between senders and receivers.
- Producer: This is like the sender at the mailbox. It creates and sends messages to the mailbox based on certain events or triggers.
- Consumer: Think of this as the person who checks their mailbox. They subscribe to specific mailboxes and collect messages as they arrive.
- Queue: It's like a waiting area in the mailbox. Messages wait here until someone comes to pick them up.
- Topic: It's like a bulletin board where different topics are posted. Publishers post messages about specific topics, and subscribers choose which topics they're interested in.
- Exchange: This is like the mail sorting room at the post office. It receives messages from publishers and decides where to send them based on predefined rules.
- Binding: It's like a connection between the sorting room and the waiting area. It tells the sorting room where to send messages based on their content or topic.
Step-by-step Implementation of Event-Driven Communication with Messaging Queues
To demonstrate event-driven communication, we'll develop a simple Spring Boot application that publishes messages to the RabbitMQ message broker, and consumers process those messages.
Step 1: Setup the RabbitMQ
We can install and run the RabbitMQ locally of the computer system.
Run the RabbitMQ:
rabbitmq-plugins.bat enable rabbitmq_managementRefer the image:
Once run the above command then the rabbitMQ runs on the localsystem at port number 15672. Default username and password are guest.
Step 2: Create the Spring Boot Project
Create the new Spring Boot project using Spring initializer on creating the project including the below dependencies into the project.
- Spring Web
- Spring for RabbitMQ
- Lombok
Once create the project then the file structure looks like the below image.
Step 3: Configure the RabbitMQ Connection
Open the application.properties file then add the RabbitMQ connection properties into the project.
spring.application.name=event-communication-rabbitMQ
# RabbitMQ connection properties
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
# Queue name
spring.rabbitmq.queue=myQueue
Step 4: Create the Message Producer
We will create the component class to send the message to RabbitMQ
Go to src > org.example.eventcommunicationrabbitmq > producer > MessageProducer and put the below code.
package org.example.eventcommunicationrabbitmq.producer;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class MessageProducer {
@Autowired
private RabbitTemplate rabbitTemplate;
@Autowired
private Queue queue;
public void sendMessage(String message) {
rabbitTemplate.convertAndSend(queue.getName(), message);
System.out.println("Message sent: " + message);
}
}
Step 5: Create the Message Consumer
We will create the component class to consume the message to RabbitMQ
Go to src > org.example.eventcommunicationrabbitmq > consumer > MessageConsumer and put the below code.
package org.example.eventcommunicationrabbitmq.consumer;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
@Component
public class MessageConsumer {
@RabbitListener(queues = "${spring.rabbitmq.queue}")
public void receiveMessage(String message) {
System.out.println("Message received: " + message);
// Process the message
}
}
Step: 6 Configure the RabbitMQ Queue
We will define the queue in the Spring application and we can use the @Configuration class of the project.
Go to src > org.example.eventcommunicationrabbitmq > config > RabbitMQConfig and put the below code.
package org.example.eventcommunicationrabbitmq.config;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitMQConfig {
@Bean
public Queue queue() {
return new Queue("myQueue", false);
}
}
Step 7: Test the Communication
Open the main class and inject the MessageProducer and send the message.
Go to src > org.example.eventcommunicationrabbitmq > EventCommunicationRabbitMqApplication and put the below code.
package org.example.eventcommunicationrabbitmq;
import org.example.eventcommunicationrabbitmq.producer.MessageProducer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class EventCommunicationRabbitMqApplication implements CommandLineRunner {
@Autowired
private MessageProducer producer;
public static void main(String[] args) {
SpringApplication.run(EventCommunicationRabbitMqApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
producer.sendMessage("Hello RabbitMQ!");
}
}
Step 8: Run the Application
Once we run the application, then the project will run at port 8080. We can see the messages being sent and received in the console.
RabbitMQ Dashboard:
Output:
Below in the console, we can see the Message is successfully sent and received.
This project demonstrates a basic Spring Boot application that sends messages to RabbitMQ using a producer component and consumes them using a consumer component.