Sending JMS message to ActiveMQ using Spring 2.5 from a web application

Last Updated 04/16/2017

In this post, I will show how you can send JMS message to ActiveMQ from your Spring web application. I have a Spring 2.5 + JBOSS Richfaces based web application that runs on Tomcat 6 running on JDK 5. Figure 1. depicts what I intend to do.

Figure - 1 Send JMS Message to ActiveMQ using Spring from a web application

Step 1: Drop in the following jars to WEB-INF/lib

• activemq-core-5.2.0.jar
• jms.jar
• geronimo-j2ee-management_1.0_spec-1.0.jar

Step 2: Create the destination/Queue using the ActiveMQ admin web application.

Launch your browser and point it to - http://localhost:8161/admin/

Figure 2 - ActiveMQ Admin Console

Click on 'Queues' to navigate to queue list and create screen. You will need to supply the queue name and click on 'Create' to create a new queue destination on ActiveMQ server. This is shown in Figure 3.

Figure 3 - Create a new Queue

Step 3. Create a message producer interface.

	/**
	*
	*/
	package org.opengarage.pingscape.mq.producer;
	/**
	* @author dhrubo
	*
	*/
	public interface MessageProducer {
	public void send(Object message);
	}

view raw MessageProducer.java hosted with ❤ by GitHub

This may not be necessary, but since I prefer to implement Program to Interface in my application I define a message producer interface.

This interface defines a single method(can have more, but for now this will suffice) which accepts an object (Java bean) which will be passed to the Queue.

Step 4. An implementation of the MessageProducer interface
This class is responsible for sending a particular JavaBean object to the queue (your goal may be different / may want to send something different).

	/**
	*
	*/
	package org.opengarage.pingscape.mq.producer;
	import javax.jms.Queue;
	import org.opengarage.pingscape.bean.Event;
	import org.springframework.jms.core.JmsTemplate;
	/**
	* @author dhrubo
	*
	*/
	public class EventInvitationMessageProducer implements MessageProducer{
	private JmsTemplate jmsTemplate;
	private Queue queue;
	private EventMessageCreator messageCreator;
	/**
	* @param jmsTemplate the jmsTemplate to set
	*/
	public void setJmsTemplate(JmsTemplate jmsTemplate) {
	this.jmsTemplate = jmsTemplate;
	}
	/**
	* @param queue the queue to set
	*/
	public void setQueue(Queue queue) {
	this.queue = queue;
	}
	/**
	* @param messageCreator the messageCreator to set
	*/
	public void setMessageCreator(EventMessageCreator messageCreator) {
	this.messageCreator = messageCreator;
	}
	public void send(Object message) {
	this.messageCreator.setEvent((Event)message);
	this.jmsTemplate.send(this.queue, this.messageCreator);
	}
	}

view raw EventInvitationMessageProducer.java hosted with ❤ by GitHub

The key is the send method. It uses a MessageCreator to consume the supplied Event object. It then uses the JmsTemplate to send this message to the destination.
Step 5. Provide the message creator implementation

	/**
	*
	*/
	package org.opengarage.pingscape.mq.producer;
	import javax.jms.JMSException;
	import javax.jms.Message;
	import javax.jms.ObjectMessage;
	import javax.jms.Session;
	import org.opengarage.pingscape.bean.Event;
	import org.springframework.jms.core.MessageCreator;
	/**
	* @author dhrubo
	*
	*/
	public class EventMessageCreator implements MessageCreator {
	private Event event;
	/* (non-Javadoc)
	* @see org.springframework.jms.core.MessageCreator#createMessage(javax.jms.Session)
	*/
	public Message createMessage(Session session) throws JMSException {
	ObjectMessage objectMsg = session.createObjectMessage();
	objectMsg.setObject(event);
	return objectMsg;
	}
	/**
	* @param event the event to set
	*/
	public void setEvent(Event event) {
	this.event = event;
	}
	}

view raw EventMessageCreator.java hosted with ❤ by GitHub

Step 6 - Wire up in Spring configuration

	<?xml version="1.0" encoding="UTF-8"?>
	<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
	http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
	<bean id="jmsFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
	<property name="brokerURL">
	<value>tcp://localhost:61616</value>
	</property>
	</bean>
	<bean id="queue" class="org.apache.activemq.command.ActiveMQQueue">
	<constructor-arg>
	<value>queue.opengarage</value>
	</constructor-arg>
	</bean>
	<!-- Spring JMS Template -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
	<property name="connectionFactory">
	<!-- lets wrap in a pool to avoid creating a connection per send -->
	<bean class="org.springframework.jms.connection.SingleConnectionFactory">
	<property name="targetConnectionFactory">
	<ref local="jmsFactory" />
	</property>
	</bean>
	</property>
	</bean>
	<!-- a sample POJO message producer which uses a Spring JmsTemplate -->
	<bean id="messageProducer" class="org.opengarage.pingscape.mq.producer.EventInvitationMessageProducer">
	<property name="jmsTemplate" ref="jmsTemplate"/>
	<property name="queue" ref="queue"/>
	<property name="messageCreator">
	<bean class="org.opengarage.pingscape.mq.producer.EventMessageCreator"/>
	</property>
	</bean>
	</beans>

view raw spring-activemq-config.xml hosted with ❤ by GitHub

Step 7 - Client of the message producer
Now we need a client to use the message producer. The Event business service class will use this message producer.

	package org.opengarage.pingscape.service.impl;
	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;
	import org.opengarage.pingscape.bean.Event;
	import org.opengarage.pingscape.business.api.EventService;
	import org.opengarage.pingscape.mq.producer.MessageProducer;
	/**
	* @author dhrubo
	*
	*/
	public class EventServiceImpl implements EventService {
	private static final Log _LOG = LogFactory.getLog(EventServiceImpl.class);
	private MessageProducer messageProducer;
	/* (non-Javadoc)
	* @see org.opengarage.pingscape.business.api.EventService#saveEvent(org.opengarage.pingscape.bean.Event)
	*/
	public void saveEvent(Event event) {
	messageProducer.send(event);
	}
	/**
	* @param messageProducer the messageProducer to set
	*/
	public void setMessageProducer(MessageProducer messageProducer) {
	this.messageProducer = messageProducer;
	}
	}

view raw EventServiceImpl.java hosted with ❤ by GitHub

Step 8 - Configure in Spring application context.
The message producer is injected by the Spring framework. Here is the configuration snippet from the service configuration.

	<bean name="eventService"
	class="org.opengarage.pingscape.business.impl.EventServiceImpl">
	<property name="messageProducer" ref="messageProducer" />
	</bean>

view raw spring-service-config.xml hosted with ❤ by GitHub

Step 9 - Test for message
Finally I restart my Tomcat when everything is ready, launch the event entry form, fill in data and click on Send button in the screen. The event details are now in the queue. You can test this in the ActiveMQ admin web console as shown in the Figure - 4 below.

Figure 4 - New message now in the Queue.