Apache ActiveMQ is the most popular open source JMS server. ActiveMQ supports Spring for configuration of the JMS client side as well as for configuring the JMS Message Broker.

In this post, let’s integrate an embedded ActiveMQ JMS 5 broker (Classic version as they call it) with a simple Spring Boot application which sends/recieves data from the embedded ActiveMQ broker.

Table of contents

  1. Create spring boot starter application
  2. Configure additional project dependencies in pom.xml
  3. Configure Embedded ActiveMQ Broker
  4. Configure JMS Producer
  5. Configure JMS Consumer
  6. Test JMS producer and consumer

Create spring boot starter application

Building the bare bone Spring Boot Service is simple when Spring Initializr is used. Spring Initializr generates spring boot project with just what you need to start quickly! Let’s start off with one.

Create a Spring Boot starter project using Spring Initializr

Let’s utilize the pre-configured Spring Initializr which is available here to create embedded-activemq-5-jms-broker starter project.

Click on Generate Project. This downloads a zip file containing embedded-activemq-5-jms-broker project. Import the project to your IDE.

Configure additional project dependencies in pom.xml

We need an additional activemq-broker dependency which will give all the classed needed for setting up an embedded ActiveMQ JMS 5 broker.

Uptate pom.xml with below dependencies. Here we are adding activemq-pool dependency as well to create a pooled connection factory.




Let’s add broker URL in application.properties. In this guide, we shall embed an active mq broker to run on port 61616. We also need a queue to send/recieve messages. We shall configure this queue name as well here.



Configure Embedded ActiveMQ Broker

Create an Active MQ embedded broker as shown below. This broker will be started when the application starts up.


public class JmsConfig {

  String brokerUrl;

  public BrokerService broker() throws Exception {

    BrokerService broker = new BrokerService();
    return broker;

Configure JMS Producer

Let’s use Spring’s JmsTemplate to send messages to the embedded broker. We shall also use a pooled connection factory for our JmsTemplate as shown below.

Update JmsConfig.java with JmsTemplate bean.


  public JmsTemplate jmsTemplate() {
    return new JmsTemplate(new PooledConnectionFactory(brokerUrl));

Create a producer class which uses the above created JmsTemplate to send the data to embedded Active MQ server.


public class JmsProducer {

  Logger log = LoggerFactory.getLogger(JmsProducer.class);

  private JmsTemplate jmsTemplate;

  String destination;

  public void send(String message) {
    jmsTemplate.convertAndSend(destination, message);
    log.info("Sent message='{}'", message);

Configure JMS Consumer

Let’s use Spring’s JmsListener to read the messages from the JMS. JmsListener needs a connection factory. We shall use pooled connection factory in the consumer as well.

Update JmsConfig.java with DefaultJmsListenerContainerFactory bean.


  public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {

    DefaultJmsListenerContainerFactory factory = new DefaultJmsListenerContainerFactory();
    factory.setConnectionFactory(new PooledConnectionFactory(brokerUrl));
    return factory;

Create a consumer class which uses Spring’s JmsListener to recieve the data from embedded Active MQ server.


public class JmsConsumer {

  Logger log = LoggerFactory.getLogger(JmsConsumer.class);

  @JmsListener(destination = "${activemq.queue.name}")
  public void receive(String message) {
    log.info("Received message='{}'", message);

Now that we have both producer and consumer, let’s build a simple webservice method which uses earlier created JMS producer to send data to the queue my-queue-1 as shown below.

Here, the sendDataToJms(message) webservice method forwards the message sent by the caller to JMS queue.


public class MyRestController {

  JmsProducer jmsProducer;

  public void sendDataToJms(@RequestParam String message) {

Start the application

Tomcat console log:

JMX consoles can connect to service:jmx:rmi:///jndi/rmi://localhost:1099/jmxrmi
Using Persistence Adapter: MemoryPersistenceAdapter
Apache ActiveMQ 5.15.10 (localhost, ID:DESKTOP-MYPCNAME-53882-1325267078594-0:1) is starting
Listening for connections at: tcp://DESKTOP-MYPCNAME:61616
Connector tcp://DESKTOP-MYPCNAME:61616 started
Apache ActiveMQ 5.15.10 (localhost, ID:DESKTOP-MYPCNAME-53882-1325267078594-0:1) started
For help or more information please see: http://activemq.apache.org
Initializing ExecutorService 'applicationTaskExecutor'
Tomcat started on port(s): 8080 (http) with context path ''
Started EmbeddedJmsBrokerApplication in 2.17 seconds (JVM running for 3.17)

Test JMS producer and consumer

Let’s invoke the webservice by sending a hello message. JmsProducer would send the message and JmsConsumer will consume the hello message.

curl -i -X POST http://localhost:8080/send?message=hello

Tomcat Log

INFO com.codeaches.activmq.embedded.JmsProducer   : Sent message='hello'
INFO com.codeaches.activmq.embedded.JmsConsumer   : Received message='hello'


This concludes our guide to integrating an embedded Apache ActiveMQ JMS with a simple Spring Boot application.

Your feedback is always appreciated. Happy coding!