Using Spring JMS

package net.pascalalma.jms;
 
import javax.jms.JMSException;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Queue;
import javax.jms.QueueBrowser;
import javax.jms.QueueConnection;
import javax.jms.QueueConnectionFactory;
import javax.jms.QueueReceiver;
import javax.jms.QueueSession;
import javax.naming.InitialContext;
import javax.naming.NamingException;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
 
public class QueueBase {
 
   private static final Log LOG = LogFactory.getLog(QueueBase.class);
 
   private static InitialContext context = null;
   private static QueueConnectionFactory qcf = null;
   private boolean transacted;
   private int ackMode;
   private String queueName;
   private boolean init = false;
   protected QueueConnection qc;
   protected QueueSession qs;
   protected Queue queue;
   protected QueueReceiver qr;
 
   protected MessageProducer mp;
 
   protected void init() throws QueueException {
      LOG.info("Queue init started");
      if (context == null) {
 
         try {
            LOG.info("QueueBase: creating InitialContext for queues (see jndi.properties)");
            context = new InitialContext();
            qcf = (QueueConnectionFactory) context.lookup("/ConnectionFactory");
         } catch (Exception e) {
            throw new QueueException(e);
         }
      }
 
      try {
         queue = (Queue) context.lookup(queueName);
         qc = qcf.createQueueConnection();
         qs = qc.createQueueSession(transacted, ackMode);
 
         assert (queue != null) : "queue is null";
         assert (qc != null) : "qc is null";
         assert (qs != null) : "qs is null";
 
         init = true;
      } catch (Exception e) {
         throw new QueueException(e);
      }
   }
 
   public QueueBase() {
      this.init = false;
   }
 
   public QueueBase(String queueName) {
      this.queueName = queueName;
      this.init = false;
   }
 
   /**
    * Constructor
    */
   public QueueBase(String queueName, boolean transacted, int ackMode) throws QueueException {
      this.queueName = queueName;
      this.transacted = transacted;
      this.ackMode = ackMode;
      this.init = false;
   }
 
   /**
    * Sends a message to the queue..
    *
    * @param msg
    * @throws QueueException
    */
   public void send(BulkMessage msg) throws QueueException {
      try {
         if ((qs != null) && (mp != null)) {
            ObjectMessage om = qs.createObjectMessage(msg);
            mp.send(om);
         } else {
            LOG.error("Queue is not running / mp==null ....");
         }
      } catch (JMSException e) {
         throw new QueueException(e);
      }
   }
 
   /*
    * Get / Receive a message from the queue The receive block at most
    * <timeoutInMilisecs> miliseconds (0=block)
    */
   public ObjectMessage receive(long timeoutInMilisecs) throws QueueException {
 
      BulkMessage m = null;
      ObjectMessage om = null;
      try {
         if (qr != null) {
            om = (ObjectMessage) qr.receive(timeoutInMilisecs);
            if (om != null) {
               m = (BulkMessage) om.getObject();
            }
         } else {
            throw new QueueException("Queue receiver is null");
         }
      } catch (JMSException e) {
         throw new QueueException(e);
      }
      return om;
   }
 
   public QueueBrowser getBrowser() throws JMSException, QueueException {
      return qs.createBrowser(queue);
   }
 
   /**
    *
    */
   public void destroy() {
      try {
         if (qs != null) {
            qs.close();
            qs = null;
         }
         if (qc != null) {
            qc.stop();
            qc.close();
            qc = null;
         }
      } catch (Exception e) {
         LOG.error(e);
      }
   }
 
   public String getQueueName() {
      return queueName;
   }
 
   public void setQueueName(String queueName) {
      this.queueName = queueName;
   }
 
   public int getAckMode() {
      return ackMode;
   }
 
   public void setAckMode(int ackMode) {
      this.ackMode = ackMode;
   }
 
   public Queue getQueue() {
      return queue;
   }
 
   public void setQueue(Queue queue) {
      this.queue = queue;
   }
 
   public boolean isTransacted() {
      return transacted;
   }
 
   public void setTransacted(boolean transacted) {
      this.transacted = transacted;
   }
 
}

package nnet.pascalalma.jms;
 
import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.ObjectMessage;
import javax.jms.Session;
 
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
 
public class QueueBaseService {
 
   private static final Log LOG = LogFactory.getLog(QueueBaseService.class);
 
   private JmsTemplate jmsTemplate = null;
 
   public void setJmsTemplate(JmsTemplate jmsTemplate) {
      this.jmsTemplate = jmsTemplate;
   }
 
   public JmsTemplate getJmsTemplate() {
      return jmsTemplate;
   }
 
   public void sendMessage(final BulkMessage bm) {
      LOG.debug("sendMessage(final BulkMessage bm)");
 
      jmsTemplate.send( new MessageCreator() {
         public Message createMessage(Session session) throws JMSException {
            ObjectMessage om = session.createObjectMessage();
            om.setObject(bm);
            return om;
         }
      });
   }
 
   public ObjectMessage receiveMessage() {
      return (ObjectMessage)jmsTemplate.receive();
 
   }
 
   public String getQueueName() {
      return jmsTemplate.getDefaultDestinationName();
   }
 
   public void setAcknowledgeMode(int mode){
      jmsTemplate.setSessionAcknowledgeMode( mode);
   }
 
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans SYSTEM "../dtd/spring-beans.dtd">
<beans>
 
  <!--  JNDI properties -->
  <bean id="jndiTemplate" class="org.springframework.jndi.JndiTemplate">
    <property name="environment">
      <props>
        <prop key="java.naming.factory.initial">
           org.jnp.interfaces.NamingContextFactory
        </prop>
        <prop key="java.naming.provider.url">
           jnp://localhost:1099
        </prop>
        <prop key="java.naming.factory.url.pkgs">
           org.jboss.naming:org.jnp.interfaces
        </prop>
      </props>
    </property>
  </bean>
 
  <!--  JNDI Connection Factory -->
  <bean id="jmsConnectionFactory" class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
      <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
      <value>ConnectionFactory</value>
    </property>
  </bean>
 
   <!-- The default queue, for incoming bulk messages-->
  <bean id="destination"  class="org.springframework.jndi.JndiObjectFactoryBean">
    <property name="jndiTemplate">
      <ref bean="jndiTemplate"/>
    </property>
    <property name="jndiName">
      <value>${queue.in}</value>
    </property>
  </bean>
 
  <!-- Queue Access Object, for the default queue -->
  <bean id="jmsTemplateQueue" class="org.springframework.jms.core.JmsTemplate102">
    <property name="connectionFactory">
      <ref bean="jmsConnectionFactory"/>
    </property>
    <property name="defaultDestination">
      <ref bean="destination"/>
    </property>
    <property name="receiveTimeout">
       <value>60000</value>
    </property>
    <!--  this value can be overwritten by setting this parameter at business level-->
    <property name="sessionAcknowledgeModeName">
       <value>AUTO_ACKNOWLEDGE</value>
    </property>
    <property name="sessionTransacted">
      <value>false</value>
    </property>
  </bean>
 
  <!-- Queue service for the default queue -->
  <bean id="queueService" class="net.pascalalma.jms.QueueBaseService" >
    <property name="jmsTemplate">
      <ref bean="jmsTemplateQueue" />
    </property>
  </bean>
</beans>