Spring Boot ActiveMQ In Memory Example - Publisher Consumer

1. Introduction

In this article, You will learn how to Create an ActiveMQ Inmemory publisher and consumer model example in Spring Boot.

All the messages that are pushed to the queue will be stored in the memory rather than storing into the database. In the next article,  you can find out "Spring Boot with Standalone ActiveMQ Example"

For today's example, you are not required to have active MQ in your local machine. Because we are storing the messages in memory with spring boot in-memory Active MQ.

2. Spring Boot ActiveMQ In memory Application Creation

First, let us create a spring boot application along with the required dependencies. Spring Boot application can be created from spring boot init link.

Add Spring Web and Apache ActiveMQ 5 dependencies in the dependency section then it generates the application with all needed structure.

Now, the spring boot Active MQ demo project is created and now open from IDE.

3. Spring Boot ActiveMQ In memory Maven Set Up

Next, Verify the all jars are added to the pom.xml file.

These two dependent jars should be present in the pom.xml file

spring-boot-starter-activemq and spring-boot-starter-web

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.2.6.RELEASE</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.javaprogramto.spring.boot</groupId>
 <artifactId>activemq-demo</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>activemq-demo</name>
 <description>Demo project for Spring Boot</description>

 <properties>
  <java.version>1.8</java.version>
 </properties>

 <dependencies>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-activemq</artifactId>
  </dependency>
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
  </dependency>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
   <exclusions>
    <exclusion>
     <groupId>org.junit.vintage</groupId>
     <artifactId>junit-vintage-engine</artifactId>
    </exclusion>
   </exclusions>
  </dependency>
 </dependencies>

 <build>
  <plugins>
   <plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
   </plugin>
  </plugins>
 </build>

</project>

Internally,  spring-boot-starter-activemq dependency is dependent on spring-jms and activemq-broker jars.

4. Spring Boot ActiveMQ In memory Configurations

Another main configuration is about creating Inmemory Queue and register with the application context.

The queue is created with the name of "local.inmemory.queue" and also you must add @EnableJMS annotation on the configuration class or spring boot main application.

ActiveMQQueue class will create a new queue if does not exist with the name given.

[package com.javaprogramto.spring.boot.activemqdemo.config;

import org.apache.activemq.command.ActiveMQQueue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jms.annotation.EnableJms;

import javax.jms.Queue;

@EnableJms@Configurationpublic class ActiveMQConfiguration {

    @Bean    public Queue createQueue(){

        return new ActiveMQQueue("local.inmemory.queue");

    }
}]

5. Creating Publisher Implementation for In memory ActiveMQ

[package com.javaprogramto.spring.boot.activemqdemo.publisher;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.jms.Queue;

@RequestMapping("/api/publish")
@RestControllerpublic class PublisherImpl {

Logger logger = LoggerFactory.getLogger(getClass());

@Autowired private JmsTemplate jmsTemplate;

@Autowired private Queue queue;

@GetMapping("/{msg}")
public String publishMessage(@PathVariable("msg") String content ){
jmsTemplate.convertAndSend(queue, content);
logger.info("Message published : "+content);
return "Success";
}
}]

6. Creating Consumer Implementation for In memory ActiveMQ

[package com.javaprogramto.spring.boot.activemqdemo.consumer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jms.annotation.JmsListener;
import org.springframework.stereotype.Component;

@Componentpublic class ConsumerImpl {

Logger logger = LoggerFactory.getLogger(getClass());

@JmsListener(destination = "local.inmemory.queue")
public void onMessage(String content){

logger.info("Message received : "+content);

}
}]

7. Spring Boot In memory ActiveMQ application.properties

Explicitly, you need to tell to spring to use the in-memory active MQ instead of using locally installed one. To enable, inbuild active MQ set the property value spring.activemq.in-memory to true.

8. Run & Test Application 

Just run the main application of spring boot.

spring.activemq.in-memory=true
spring.activemq.pool.enabled=false
server.port=8082

[package com.javaprogramto.spring.boot.activemqdemo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplicationpublic class ActivemqDemoApplication {
public static void main(String[] args) {

SpringApplication.run(ActivemqDemoApplication.class, args);

}
}]

Hit the endpoint after successfully starting the application.

http://localhost:8082/api/publish/message1
http://localhost:8082/api/publish/message2
http://localhost:8082/api/publish/message3
http://localhost:8082/api/publish/message4
http://localhost:8082/api/publish/message5

Here, we've hit the service 5 times sending the different messages.

[2020-04-29 22:14:02.100  INFO 25369 --- [           main] c.j.s.b.a.ActivemqDemoApplication        : Started ActivemqDemoApplication in 1.992 seconds (JVM running for 2.626)
2020-04-29 22:14:04.989  INFO 25369 ---  : Initializing Spring DispatcherServlet 'dispatcherServlet'
2020-04-29 22:14:04.990  INFO 25369 ---  : Initializing Servlet 'dispatcherServlet'
2020-04-29 22:14:04.998  INFO 25369 ---  : Completed initialization in 8 ms
2020-04-29 22:14:05.039  INFO 25369 ---  : Message published : message1
2020-04-29 22:14:05.045  INFO 25369 ---  : Message received : message1
2020-04-29 22:14:12.682  INFO 25369 ---  : Message published : message2
2020-04-29 22:14:12.683  INFO 25369 ---  : Message received : message2
2020-04-29 22:14:16.536  INFO 25369 ---  : Message published : message3
2020-04-29 22:14:16.536  INFO 25369 ---  : Message received : message3
2020-04-29 22:14:19.098  INFO 25369 ---  : Message published : message4
2020-04-29 22:14:19.098  INFO 25369 ---  : Message received : message4
2020-04-29 22:14:21.386  INFO 25369 ---  : Message published : message5
2020-04-29 22:14:21.386  INFO 25369 ---  : Message received : message5]

You can see all the messages published and consumed from the queue.

9. Conclusion

In conclusion, You've seen how to send and received the messages from Spring Boot Active MQ in-memory queue.

All the code is shown in this article is over GitHub.

You can download the project directly and can run in your local without any errors.

[View on GitHub ##eye##]

[Download ##file-download##]



If you have any queries in building this application please post in the comment section.

Spring Boot ActiveMQ InMemory Example