SpringJMS - Step by Step Guide to create Consumer (Super Simple)

Step 1 - You will need same Jar files which we discussed in Producer Example

Spring Core
Spring Context
Spring JMS
activemq-all
commons-logging
slf4j

Step 2: Create applicationContext.xml in classpath

<?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:p="http://www.springframework.org/schema/p"

       xmlns:context="http://www.springframework.org/schema/context"

       xmlns:jms="http://www.springframework.org/schema/jms"

       xmlns:amq="http://activemq.apache.org/schema/core"

       xsi:schemaLocation="http://www.springframework.org/schema/beans 

                           http://www.springframework.org/schema/beans/spring-beans.xsd

                           http://www.springframework.org/schema/context 

                           http://www.springframework.org/schema/context/spring-context.xsd

                           http://www.springframework.org/schema/jms 

                           http://www.springframework.org/schema/jms/spring-jms.xsd

                           http://activemq.apache.org/schema/core 

                           http://activemq.apache.org/schema/core/activemq-core.xsd">

<context:component-scan base-package="com.itech" />

<context:annotation-config/>

<!-- JMS ConnectionFactory to use, configuring the embedded broker using XML -->

<bean id="activemqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">

    <!-- brokerURL, You may have different IP or port -->

    <constructor-arg name="brokerURL" value="vm://localhost:61616" />

  </bean>  

<!-- Pooled Spring connection factory -->

 <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">

    <constructor-arg ref="activemqConnectionFactory" />

 </bean>

<!--  Queue Destination  -->

    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">

    <!-- name of the queue -->

    <constructor-arg index="0" value="THIS.IS.TEST.QUEUE" />

  </bean>

 

  <!-- Listeners   -->

<jms:listener-container connection-factory="connectionFactory"> 

               <jms:listener destination="THIS.IS.TEST.QUEUE" ref="messageListenerTest" /> 

 </jms:listener-container>

</beans>

Step 3:

You need a Consumer Class which implements MessageListener interface:

import javax.jms.JMSException;

import javax.jms.Message;

import javax.jms.MessageListener;

import javax.jms.TextMessage;

import org.springframework.stereotype.Component;

@Component("messageListenerTest")

public class MessageListenerTest implements MessageListener {

@Override

public void onMessage(Message message) {

TextMessage textMessage = (TextMessage) message;

try {

System.out.println(textMessage.getText());

} catch (JMSException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

That's it, Now try sending a message with Producer example, and message will be listened by this MessageListener implementation. 

Super Simple Example of Spring JMS - Producer

Step 1: You need Jar files:

A. Spring core, spring-context
B. Spring JMS
C. activemq-all 
D. slf4j , log4j etc.


Step 2: Create a Java Project in Eclipse and add "applicationContext.xml" File directly under "src" folder:

applicationContext.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jms="http://www.springframework.org/schema/jms"
       xmlns:amq="http://activemq.apache.org/schema/core"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/jms 
                           http://www.springframework.org/schema/jms/spring-jms.xsd
                           http://activemq.apache.org/schema/core 
                           http://activemq.apache.org/schema/core/activemq-core.xsd">

<context:component-scan base-package="com.itech" />
<context:annotation-config/>

<!-- JMS ConnectionFactory to use, configuring the embedded broker using XML -->
<bean id="activemqConnectionFactory" class="org.apache.activemq.ActiveMQConnectionFactory">
    <!-- brokerURL, You may have different IP or port -->
    <constructor-arg name="brokerURL" value="vm://localhost:61616" />
  </bean>  

<!-- Pooled Spring connection factory -->
 <bean id="connectionFactory" class="org.springframework.jms.connection.CachingConnectionFactory">
    <constructor-arg ref="activemqConnectionFactory" />
 </bean>

<!--  Queue Destination  -->
    <bean id="queueDestination" class="org.apache.activemq.command.ActiveMQQueue">
    <!-- name of the queue -->
    <constructor-arg index="0" value="THIS.IS.TEST.QUEUE" />
  </bean>

  <!-- JmsTemplate Definition -->
  <bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
    <property name="connectionFactory" ref="connectionFactory" />
    <property name="defaultDestination" ref="queueDestination" />
  </bean>

</beans>


Have a look at XML, it has almost everything you need to start with: - ConnectionFactory, Destination and Spring Provides JmsTemplate which we will be using to send the message.

Step 3: Create Test Class:

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.Session;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;

public class ProducerTest {

public static void main(String[] args) {
// Load Application Context 
   ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
  
            // Get JmsTemplate Bean from context     
   JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
 
           // Create Message 
   MessageCreator message = new MessageCreator() {
@Override
public Message createMessage(Session session) throws JMSException {
return session.createTextMessage("This is test message");
}
};

              // Send the message
template.send(message);

              // Close the context
((ClassPathXmlApplicationContext)ctx).close();
// You are Done!!
}

}

That's it. You are Done! You have written  a complete code in SpringJMS for sending a message.

Thanks!

MDB (Message Driven Beans) Vs. SpringJMS - Point by Point Comparison

EJB’s Message Driven Beans (MDB) Vs. SpringJMS

MDB and SpringJMS can be compared with multiple features:

1.       Learning Curve

Most important feature of SpringJMS is, object can be easily configured in XML format making is extra easy to manage.  Some features like concurrentConsumer can be managed with XML without touching Java code.

MDB on the other hand involves expert level understanding of EJB and has more LOC to write for same operation.  So Overall learning Curve for SpringJMS is less.

2.       Development Time

Spring implementation uses the JmsTemplate helper class to simplify working with the JMS API to send the message. Also, auto starting consumers with application context and ease of handling properties with xml configuration, reduces development time, in turn production cost of application.

MDB though robust, needs good amount of efforts in comparison.

3.       Container Dependency

MDB requires EJB container. Container is mainly responsible for instantiation and handling other life cycle events for MDB. EJB 3.0 also has additional packaging and deployment requirements that
Spring does not. Also message listeners must be EJB components.

Spring is container of its own. SpringJMS do not require any external container to execute. Any POJO can potentially be activated in response to incoming messages

4.       Multi-Queue Configuration:

MDBs are static for one queue. One MDB cannot be used for consuming from two or multiple queues. On the contrary, Spring provides the flexibility to customize the number of queues to listen to and dynamically configure the destinations as well.

5.       Security

For MDB, security is managed by the EJB container by configuring a security identity for the MBM

Spring UserCredentialsConnectionFactoryAdapter provides a mechanism to specify user credentials for every JMS connection to secure the JMS connection.

6.       Dependency management/configurability/intermediation

Spring offers much more mature and configurable support for dependency management than EJB 3.0 with its dependency injection and IOC framework

7.       Availability

The Enterprise server controls JMS connection pooling and failover and reconnecting to the message broker when the connection is lost has to be supported and configured at the enterprise server level .

Individual applications and modules cannot control or override JMS availability

Spring DMLC automatically re-establishes connections if the message broker becomes unavailable

8.       Performance

The EJB MDB container manages the JMS Connection Pool and needs to be configured to optimize the concurrent processing of messages

Spring DMLC allows you to scale the number message consumers using the concurrentConsumers property and the maxConcurrentConsumers property. It provides various levels of caching of the JMS resources (connections and sessions) and JMS consumers for increased performance

9.       Transaction

Can use the default container managed transaction to allow the EJB container to handle transaction demarcation or specify local transactions to group message sends and receives

Spring DMLC provides support for local JMS transactions as well as an external transaction manager around message reception and listener execution

10.   Message Convertors

Spring provides message converters which can automate the conversion of Java objects to message content

MDB provides no such features.

11.   Future Orientation

Spring has vibrant open source community and considered as very stable but futuristic design. Many newer MOMs and EIPs (Enterprise Integration Pattern) like Camel directly uses Spring for messaging implementation.

EJBs on the contrary and seen lesser in market.

Summary:

                Considering current era of IT development, adopting SpringJMS over MDB is always a better choice.