Using Spring to Send JMS Messages

Recently I stumbled upon a number of places in the some docs and mailing lists where claims are made that the Spring JmsTemplate is full of anti-patterns, is horribly inefficient and shouldn't be used. Well I'm here to debunk these erroneous claims by pointing out a class in the Spring Framework that was overlooked entirely.

The Spring JmsTemplate is a convenience class for sending and receiving JMS messages in a synchronous manner. The JmsTemplate was originally designed to be used with a J2EE container where the container provides the necessary pooling of the JMS resources (i.e., connections, consumers and producers). Such requirements came from the EJB spec. But when developers began using the JmsTemplate outside of J2EE containers, and because some JMS providers do not offer caching/pooling of JMS resources, a different solution was necessary. Enter the Spring CachingConnectionFactory.

The CachingConnectionFactory is meant to wrap a JMS provider's connection to provide caching of sessions, connections and producers as well as automatic connection recovery. By default, it uses a single session to create many connections and this model works very well with most MOMs. But if you need to scale further, you can also specify the number of sessions to cache using the sessionCacheSize property.

Below is a snippet from a Spring app context that demonstrates the configuration for the CachingConnectionFactory

...

<!-- A connection to ActiveMQ --> 

<bean id="amqConnectionFactory" 

    class="org.apache.activemq.ActiveMQConnectionFactory" 

    p:brokerURL='tcp://localhost:61616" />



<!-- A cached connection to wrap the ActiveMQ connection --> 

<bean id="cachedConnectionFactory" 

    class="org.springframework.jms.connection.CachingConnectionFactory"

    p:targetConnectionFactory-ref="amqConnectionFactory" 

    p:sessionCacheSize="10" />



<!-- A destination in ActiveMQ --> 

<bean id="destination" 

    class="org.apache.activemq.command.ActiveMQQueue">

<constructor-arg value="FOO.TEST" />

</bean>



<!-- A JmsTemplate instance that uses the cached connection and destination --> 

<bean id="producerTemplate" 

    class="org.springframework.jms.core.JmsTemplate"

    p:connectionFactory-ref="cachedConnectionFactory"

    p:defaultDestination-ref="destination" /> 

...

As you can see, the configuration for the CachingConnectionFactory along with the JmsTemplate is quite simple. Furthermore, these two classes are also both in the org.springframework.jms package path so they're both included in the spring-jms jar file making their use even easier.

The only thing left to do is utilize the jmsTemplate bean in your Java code to actually send a message. This is shown below:

public class SimpleMessageProducer {

    

    private static final Logger LOG = Logger.getLogger(SimpleMessageProducer.class);

    

    @Autowired

    protected JmsTemplate jmsTemplate; 

    

    protected int numberOfMessages = 100; 

    

    public void sendMessages() throws JMSException {

        StringBuilder payload = null;

        

        for (int i = 0; i < numberOfMessages; ++i) {

            

            payload = new StringBuilder(); 

            payload.append("Message [").append(i).append("] sent at: ").append(new Date());

            

            jmsTemplate.send(new MessageCreator() {

                public Message createMessage(Session session) throws JMSException {

                    TextMessage message = session.createTextMessage(payload.toString()); 

                    message.setIntProperty("messageCount", i);

                    LOG.info("Sending message number [" + i + "]");

                    return message;

                }

            });

        }

    }

}

The SimpleMessageProducer class above demonstrates the use of Spring autowiring to resolve the relationship between the jmsTemplate property and the producerTemplate in the app context further above. Then an anonymous MessageCreator instance is used to actually create a message for the jmsTemplate to send.

The JmsTemplate and the CachingConnectionFactory are both very widely used in businesses of all sizes throughout the world. Coupled with one of the Spring message listener containers, they provide an ideal solution.

I'll elaborate on message consumption using the Spring DefaultMessageListenerContainer and the SimpleMessageListenerContainer in a future blog post.