Don't Use JmsTemplate in Spring!

JmsTemplate is easy for simple message sending. What if we want to add headers, intercept or transform the message? Then we have to write more code. So, how do we solve this common task with more configurability in lieu of more code? First, lets review JMS in Spring.

Spring JMS Options

1. JmsTemplate – either to send and receive messages inline
   1. Use send()/convertAndSend() methods to send messages
   2. Use receive()/receiveAndConvert() methods to receive messages. BEWARE: these are blocking methods! If there is no message on the Destination, it will wait until a message is received or times out.
2. MessageListenerContainer – Async JMS message receipt by polling JMS Destinations and directing messages to service methods or MDBs

Both JmsTemplate and MessageListenerContainer have been successfully implemented in Spring applications, if we have to do something a little different, we introduce new code. What could possibly go wrong?

On many projects new use-cases arise, such as:

• Route messages to different destinations, based on header values or contents?
• Log the message contents?
• Add header values?
• Buffer the messages?
• Improved response and error handling?
• Make configuration changes without having to recompile?
• and more…

Now we have to refactor code and introduce new code and test cases, run it through QA, etc. etc.

A More Configurable Solution!

It is time to graduate Spring JmsTemplate and play with the big kids. We can easily do this with a Spring Integration flow.

Here we have a diagram illustrating the 3 simple components to Spring Integration replacing the JmsTemplate send.

1. Create a Gateway interface – an interface defining method(s) that accept the type of data you wish to send and any optional header values.
2. Define a Channel – the pipe connecting our endpoints
3. Define an Outbound JMS Adapter – sends the message to your JMS provider (ActiveMQ, RabbitMQ, etc.)

Simply inject this into our service classes and invoke the methods.

• Add header & header values via the methods defined in the interface
• Simple invokation of Gateway methods from our service classes
• Multiple Gateway methods
• Configure method level or class level destinations

• Change the JMS Adapter (one-way) to a JMS Gateway (two-way) to processes responses from JMS
• We can change the channel to a queue (buffered) channel
• We can wire in a transformer for message transformation
• We can wire in additional destinations, and wire in a “header (key), header value, or content based” router and add another adapter
• We can wire in other inbound adapters receiving data from another source, such as SMTP, FTP, File, etc.
• Wiretap the channel to send a copy of the message elsewhere
• Change the channel to a logging adapter channel which would provide us with logging of the messages coming through
• Add the “message-history” option to our SI configuration to track the message along its route
• and more…

Optimal JMS Send Solution

Gateway provides a one or two way communication with Spring Integration. If the method returns void, it is inherently one-way.

The interface MyJmsGateway, has one Gateway method declared sendMyMessage(). When this method is invoked by your service class, the first argument will go into a message header field named “myHeaderKey”, the second argument goes into the payload.

package com.gordondickens.sijms;
 
import org.springframework.integration.annotation.Gateway;
import org.springframework.integration.annotation.Header;
 
public interface MyJmsGateway {
    @Gateway
    public void sendMyMessage(@Header("myHeaderKey") String s, Object o);
}

Because the interface is proxied at runtime, we need to configure in the Gateway via XML.

<?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:jms="http://www.springframework.org/schema/integration/jms"
        xmlns:si="http://www.springframework.org/schema/integration"
        xsi:schemaLocation="http://www.springframework.org/schema/integration/jms
 
http://www.springframework.org/schema/integration/jms/spring-integration-jms-2.0.xsd
 
http://www.springframework.org/schema/integration
 
http://www.springframework.org/schema/integration/spring-integration-2.0.xsd
 
http://www.springframework.org/schema/beans
 
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
    <import resource="classpath:META-INF/spring/amq-context.xml"/>
 
    <!-- Pickup the @Gateway annotation -->
    <si:annotation-config/>
 
    <si:poller default="true">
      <si:interval-trigger interval="500"/>
    </si:poller>
 
    <!-- Define the channel (pipe) connecting the endpoints -->
    <si:channel id="myRequestChannel"/>
 
    <!-- Configure the Gateway to Send on the channel -->
    <si:gateway id="myJmsGateway"
        service-interface="com.gordondickens.sijms.MyJmsGateway"
        default-request-channel="myRequestChannel"/>
 
    <!-- Send message to JMS -->
    <jms:outbound-channel-adapter channel="myRequestChannel"
        connection-factory="connectionFactory"
        destination="my.inbound.queue"/>
</beans>

package com.gordondickens.sijms;
 
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
@ContextConfiguration("classpath:/com/gordondickens/sijms/JmsSenderTests-context.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class JmsSenderTests {
 
    @Autowired
    MyJmsGateway myJmsGateway;
 
    @Test
    public void testJmsSend() {
        myJmsGateway.sendMyMessage("myHeaderValue", "MY PayLoad");
    }
}

Summary

• Simple implementation
• Invoke a method to send a message to JMS – Very SOA eh?
• Flexible configuration
• Reconfigure & restart WITHOUT recompiling – SWEET!