Redstream Blog » JMS http://blog.redstream.nl Pragmatic Integrators Mon, 26 Jul 2010 06:09:45 +0000 en hourly 1 http://wordpress.org/?v=1950 Configuring durable messages with SpringFramework http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/ http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/#comments Thu, 28 Jun 2007 04:26:27 +0000 Pascal Alma http://www.pascalalma.net/?p=41 In our project we have a webservice that receives a message, processes it and sends a response back. Very common for a webservice I think :-)
Now there was an extra request: log all messages in a database so we could get management info out of it, like in which hour of the day are we receiving the most messages, who is sending the most messages that are leading to errors, etc. In this post I will show you how I implemented this request. To have it working with the least impact on our 'production' system I chose to put the incoming message in a queue (actually it is a Topic). Then register a MessageListener that will pick up the posted message and log it in a separate database, along with some metadata. The reason I chose a Topic is that I expect to have more requests in the future to do something with the incoming message. By using a Topic I can just add a receiver and have that handle the new request.

We have the following Application Server setup:

  • JBoss 4.0.5GA
  • JBoss Messaging 1.2SP1

To define the Topic in JBoss Messaging I added the following section to 'destinations-service.xml':

PLAIN TEXT
XML:
  1. <mbean code="org.jboss.jms.server.destination.TopicService"
  2.            name="jboss.messaging.destination:service=Topic,name=myMessageTopic"
  3.            xmbean-dd="xmdesc/Topic-xmbean.xml">
  4.     <depends optional-attribute-name="ServerPeer">jboss.messaging:service=ServerPeer</depends>
  5.     <depends>jboss.messaging:service=PostOffice</depends>
  6.     <attribute name="DLQ">jboss.messaging.destination:service=Queue,name=DLQ</attribute>
  7.     <attribute name="ExpiryQueue">jboss.messaging.destination:service=Queue,name=ExpiryQueue</attribute>
  8. </mbean>

(To see more details about installing JBoss Messaging see this post).
Since sending a message to a Topic is pretty straightforward I will only show how to configure the receiver. I first made the Java class which acts as receiver:

PLAIN TEXT
JAVA:
  1. package net.pascalalma.logger;
  2.  
  3. import javax.jms.JMSException;
  4. import javax.jms.Message;
  5. import javax.jms.MessageListener;
  6. import javax.jms.ObjectMessage;
  7.  
  8. import net.pascalalma.model.LogMelding;
  9. import net.pascalalma.exceptions.StatisticsException;
  10.  
  11. import org.apache.commons.logging.Log;
  12. import org.apache.commons.logging.LogFactory;
  13.  
  14. public class LoggerBean implements MessageListener {
  15.  
  16.    private static final Log LOG = LogFactory.getLog(LoggerBean.class);
  17.  
  18.    public void onMessage(Message msg) {
  19.  
  20.       LOG.info("onMessage(Message msg)");
  21.  
  22.       if (msg instanceof ObjectMessage) {
  23.  
  24.          ObjectMessage om = (ObjectMessage)msg;
  25.          try {
  26.             if ( om.getObject() instanceof LogMelding) {
  27.                LogMelding lm = (LogMelding)((ObjectMessage)msg).getObject();
  28.  
  29.                LOG.info("LogMelding in Topic = " + lm);
  30.             } else {
  31.                throw new IllegalArgumentException("Only instances of LogMelding may be put in this Topic.");
  32.             }
  33.          } catch (JMSException je) {
  34.             throw new StatisticsException(je);
  35.          }
  36.       } else {
  37.          throw new IllegalArgumentException("Only ObjectMessages may be put in this Topic.");
  38.       }
  39.    }
  40. }

Next we have to configure this MessageListener implementation in Spring. Here is my application-context:

PLAIN TEXT
XML:
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans SYSTEM "../dtd/spring-beans.dtd">
  3. <beans>
  4.   <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  5.     <property name="locations">
  6.       <list>
  7.         <value>classpath:statistics.properties</value>
  8.       </list>
  9.     </property>
  10.   </bean>
  11.  
  12.   <!--  JNDI properties -->
  13.   <bean id="jndiTemplate"
  14.     class="org.springframework.jndi.JndiTemplate">
  15.     <property name="environment">
  16.       <props>
  17.         <prop key="java.naming.factory.initial">
  18.           org.jnp.interfaces.NamingContextFactory
  19.         </prop>
  20.         <prop key="java.naming.provider.url">
  21.           jnp://localhost:1099
  22.         </prop>
  23.         <prop key="java.naming.factory.url.pkgs">
  24.           org.jboss.naming:org.jnp.interfaces
  25.         </prop>
  26.       </props>
  27.     </property>
  28.   </bean>
  29.  
  30.   <!--  JNDI Connection Factory -->
  31.   <bean id="jmsConnectionFactory"
  32.     class="org.springframework.jms.connection.SingleConnectionFactory">
  33.     <property name="targetConnectionFactory">
  34.       <bean
  35.         class="org.springframework.jndi.JndiObjectFactoryBean">
  36.         <property name="jndiTemplate" ref="jndiTemplate" />
  37.         <property name="jndiName" value="myConnectionFactory" />
  38.       </bean>
  39.     </property>
  40.     <property name="clientId" value="clientID"/>
  41.   </bean>
  42.   <!--  Destination for the incoming messages -->
  43.   <bean id="myMessageTopic"
  44.     class="org.springframework.jndi.JndiObjectFactoryBean">
  45.     <property name="jndiTemplate">
  46.       <ref bean="jndiTemplate" />
  47.     </property>
  48.     <property name="jndiName" value="${queue.log}" />
  49.   </bean>
  50.  
  51.   <!-- The messageListenerContainer -->
  52.   <bean id="myMsgTopiclistener"
  53.     class="org.springframework.jms.listener.DefaultMessageListenerContainer">
  54.     <property name="concurrentConsumers" value="1" />
  55.     <property name="maxConcurrentConsumers" value="1" />
  56.     <property name="connectionFactory" ref="jmsConnectionFactory" />
  57.     <property name="sessionTransacted" value="true" />
  58.     <property name="destination" ref="myMessageTopic" />
  59.     <property name="messageListener" ref="loggerBean" />
  60.     <property name="subscriptionDurable" value="true"/>
  61.     <property name="durableSubscriptionName" value="myMsgTopiclistener"/>
  62.   </bean>
  63.  
  64.    <!-- === Business Layer === -->
  65.    <bean id="loggerBeanOriginal" class="net.pascalalma.logger.LoggerBean" />
  66.  
  67.    <!--  Business Layer Service is transactional -->
  68.    <bean id="loggerBean" parent="txProxyParent">
  69.       <property name="target" ref="loggerBeanOriginal" />
  70.    </bean>
  71. </beans>

The difference with the non-durable configuration is the property ClientId at the jmsConnectionFactory bean:

PLAIN TEXT
XML:
  1. <property name="clientId" value="clientID"/>

And the following properties at the myMsgTopiclistener bean:

PLAIN TEXT
XML:
  1. <property name="subscriptionDurable" value="true"/>
  2.   <property name="durableSubscriptionName" value="myMsgTopiclistener"/>

If you leave these properties out you will have the non-durable variant of the message listener.

So here is another proof that Spring can make your life as developer a lot easier :-)

]]> http://blog.redstream.nl/2007/06/28/configuring-durable-messages-with-springframework/feed/ 0