Reactive microservices using Spring Boot and RabbitMQ

In an ideal case, all microservice interactions are expected to happen asynchronously using publish subscribe semantics. Spring Boot provides a hassle-free mechanism to configure messaging solutions:

In this next example, we will create a Spring Boot application with a sender and receiver, both connected through an external queue.

Let us follow these steps to create a string boot reactive microservice using RabbitMQ:

1. Create a new project using STS to demonstrate this capability. In this example, instead of selecting Web, select AMQP under I/O:

1. RabbitMQ will also be needed for this example. Download and install the latest version of RabbitMQ from https://www.rabbitmq.com/download.html. RabbitMQ 3.5.6 is used in this book.
2. Follow the installation steps documented on the site. Once ready, start the RabbitMQ server like this:

      $./rabbitmq-server

1. Make the configuration changes to the application.properties file to reflect the RabbitMQ configuration. The following configuration uses the default port, username, and password of RabbitMQ:

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

1. Add a message sender component and a queue named TestQ of the type org.springframework.amqp.core.Queue to Application.java under src/main/java. The RabbitMessagingTemplate template is a convenient way to send messages, and abstracts all the messaging semantics. Spring Boot provides all boilerplate configurations for sending messages:

        @Component 
        class Sender {
          @Autowired
          RabbitMessagingTemplate template;
    
          @Bean
          Queue queue() {
            return new Queue("TestQ", false);
          }
          public void send(String message){
            template.convertAndSend("TestQ", message);
          }
        }

1. For receiving a message, all that is needed is a @RabbitListener annotation. Spring Boot auto-configures all required boilerplate configurations:

        @Component
        class Receiver {
          @RabbitListener(queues = "TestQ")
          public void processMessage(String content) {
            System.out.println(content);
          }
        }

1. The last piece of this exercise is to wire the sender to our main application, and implement the CommandLineRunner interface's run method to initiate the message sending. When the application is initialized, it invokes the run method of the CommandLineRunner:

        @SpringBootApplication
        public class Application implements CommandLineRunner{
          @Autowired
          Sender sender;
   
          public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
          }
   
          @Override
          public void run(String... args) throws Exception {
            sender.send("Hello Messaging..!!!");
          }
        }

1. Run the application as a Spring Boot application, and verify the output. The following message will be printed on the console:

      Hello Messaging..!!!