Enterprise Messaging With Spring JMS

Enterprise Messaging With
Spring JMS
Bruce Snyder, Senior Software Engineer, SpringSource

Friday, July 8, 2011

Agenda

• Very brief introduction to JMS
• Synchronous JMS With Spring
• Asynchronous JMS With Spring

2


What is JMS?

• JMS is:
– An API for client-side communications with a JMS provider
– Included in Java EE
• Also stand alone

• JMS is not:
– A spec for a message broker implementation

3


JMS is an Abstraction

4


JMS Message

5


Point-to-Point Messaging

6


Publish/Subscribe Messaging

7


Typical JMS Use

8


Raw JMS

9


JMS With Spring

10


Managed vs. Non-Managed JMS

• Managed
– JMS provider in a Java EE container
– JMS resource pooling
– Transaction support
– Support for EJBs

• Non-Managed
– Stand alone JMS provider
– Manual setup of JMS resources
– No guarantee of transactions

• Spring supports both environments

11


JMS With Spring

12


Spring JMS

• JMS Template
– Send and receive messages
synchronously

• Message Listener Container
– Receive messages asynchronously
– Message-Driven POJOs (MDPs)

13


JmsTemplate
Synchronous
• browse()
– Browse messages in a queue
• convertAndSend()
– Send messages synchronously
– Convert a Java object to a JMS message
• send()
– Send a message synchronously using a MessageCreator
• receive() and receiveAndConvert()
– Receive messages synchronously
• execute()
– Provides access to callbacks for more complex scenarios
• receiveSelected() and receiveSelectedAndConvert()
– Receive filtered messages synchronously

14


The Spring JmsTemplate
Synchronous

<bean id="connectionFactory"
class="org.apache.activemq.ActiveMQConnectionFactory"
p:brokerURL="tcp://localhost:61616" />

<bean id="destination" class="org.apache.activemq.command.ActiveMQQueue">
<constructor-arg value="FOO.TEST" />
</bean>

<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"
p:connectionFactory-ref="connectionFactory"
p:defaultDestination-ref="destination" />

<bean id="messageProducer"
class="org.bsnyder.spring.jms.producer.SimpleMessageProducer"
p:jmsTemplate-ref="jmsTemplate" />

15


Synchronous

// Use the default destination
jmsTemplate.convertAndSend("Hello World!");

// Use a different destination
jmsTemplate.convertAndSend(“TEST.BAR”, “Hello World!”);

String textMessage1 = (String) jmsTemplate.receiveAndConvert();

String textMessage2 = (String) jmsTemplate.receiveAndConvert(“TEST.BAR”);

16


Synchronous
• Using send() with a MessageCreator

// Use a MessageCreator callback
jmsTemplate.send(destination, new MessageCreator() {
public Message createMessage(Session session)
throws JMSException {
TextMessage message = session.createTextMessage("Hello World!");
message.setIntProperty("someBusinessId", 22);
return message;
}
});

// Receive raw JMS message
TextMessage message = jmsTemplate.receive();

17


Synchronous
• Using execute() and the SessionCallback

// Use a SessionCallback
jmsTemplate.execute(new SessionCallback() {
public Object doInJms(Session session) throws JMSException {
Queue queue = session.createQueue("MY.TEST.QUEUE");
MessageProducer producer = session.createProducer(queue);
producer.send(message);
}
});

18


Synchronous
• Using execute() with the ProducerCallback

// Use a ProducerCallback
jmsTemplate.execute(new ProducerCallback() {
public Object doInJms(Session session, MessageProducer producer)
throws JMSException {
producer.send(destination, message);
}
return null;
}
});

19


Synchronous
• Using JMS selector expression

// Using a selector expression
String selectorExpression =
“Timestamp BETWEEN 1218048453251 AND 1218048484330”;

jmsTemplate.receiveSelected(destination, selectorExpression);

20


Synchronous
• Resolving JMS destinations
– DynamicDestinationResolver (default)
• Look up destinations via a simple text name
• Just calls session.createQueue() and session.createTopic()
– JndiDestinationResolver
• Option to fall back to DynamicDestinationResolver
– BeanFactoryDestinationResolver
• Look up beans that are javax.jms.Destination objects

21


Synchronous
• MessageConverter
– SimpleMessageConverter
• String <-> javax.jms.TextMessage
• Map <-> javax.jms.MapMessage
• Serializable object <-> javax.jms.ObjectMessage
• byte[] <-> javax.jms.BytesMessage

22


Synchronous
• JmsException hierarchy
– Spring-specific unchecked exceptions
– Corresponds to JMSException

• Advantage
– Automatic clean up of JMS resources

23


Synchronous
• Automatically participates in transactions
• Provides support for:
– Java EE transactions
– Spring local transactions (Spring JmsTransactionManager)
– Spring global transactions (Spring JtaTransactionManager)

• XA requires an XA capable ConnectionFactory
• XA resource enlistment is provider specific

24


Synchronous
• JmsTemplate does not provide resource pooling
– Utilizes fresh connection/session for every invocation

• JMS resource pooling is responsibility of JMS provider

• Spring provides support
– SingleConnectionFactory
• Returns same connection for all calls to createConnection()
• Ignores all calls to close()
– CachingConnectionFactory
• Extends SingleConnectionFactory to add Session caching and
automatic Connection recovery

25


Spring JMS

• JMS Template
– Send and receive messages
synchronously

• Message Listener Container
– Receive messages asynchronously
– Message-Driven POJOs (MDPs)

26


Managed vs. Non-Managed JMS
Asynchronous

• Non-Managed
– JMS MessageConsumer registers a MessageListener
– Manual lifecycle management

• Managed
– EJB Message-Driven Beans

27


JMS Transaction Support
Asynchronous

• Non-Managed XA Transactions
– A JMS MessageConsumer can use various acknowledge
modes
• AUTO_ACKNOWLEDGE
• CLIENT_ACKNOWLEDGE
• DUPS_OK_ACKNOWLEDGE
• local JMS transaction
– Standard JMS does not support asynchronous message
consumption as part of a XA transaction

• Managed XA Transactions
– Officially supported only by EJBs

28


Spring Message-Driven POJOs
Asynchronous

• DefaultMessageListenerContainer
– Most commonly used container
– Allows for dynamic scaling of queue consumers
– Participates in external transactions

• SimpleMessageListenerContainer
– Very basic
– Static configuration
– No external transaction support

29


DefaultMessageListenerContainer
Asynchronous
• Highly configurable
– Dynamic scale up/down of consumers
• Threads managed by the container
– Customizable via the Spring TaskExecutor
• Resource caching
– Connection, Session, MessageConsumer
– Default is to cache nothing so as work in Java EE
environments
– See the setCacheLevel() method for more info
• Works in managed and non-managed environments
• Supports XA message consumption

30


SimpleMessageListenerContainer
Asynchronous
• No dynamic scaling of consumers
• No support for XA transactions

31


Supported Types of Message Listeners
Asynchronous
• javax.jms.MessageListener interface
– Standard Java EE interface
– Threading is up to you
• SessionAwareMessageListener interface
– Spring-specific interface
– Provides access to the Session object
• Very useful for request-response messaging
• MessageListenerAdapter interface
– Spring-specific interface
– Allows for type-specific message handling
– No JMS dependencies whatsoever

32


MessageListener
Asynchronous
• Standard JMS MessageListener
• Uses an onMessage() method

public class MyMessageListener implements MessageListener {
private static Logger LOG = Logger.getLogger(MyMessageListener.class);

public void onMessage(Message message) throws JMSException {
try {
LOG.info("Consumed message: “ + message);
// Do some processing here
} catch (JMSException e) {
LOG.error(e.getMessage(), e);
}
}

33


Asynchronous
• XML configuration


<bean id="messageListener"
class="org.bsnyder.spring.jms.listener.SimpleMessageListener" />

<jms:listener-container concurrency="5-10">
<jms:listener destination="FOO.TEST" ref="messageListener"/>
</jms:listener-container>

34


Asynchronous
• Use more than one listener


<bean id="widgetListener"
class="org.bsnyder.spring.jms.listener.WidgetMessageListener" />

<bean id="gadgetListener"
class="org.bsnyder.spring.jms.listener.GadgetMessageListener" />

<jms:listener destination="PRODUCTS.WIDGETS" ref="widgetListener"/>
<jms:listener destination="PRODUCTS.GADGETS" ref="gadgetListener"/>

35


SessionAwareMessageListener
Asynchronous
• Provides access to the session
• Uses an onMessage() method
public class MySessionAwareMessageListener implements SessionAwareMessageListener {
private static Logger LOG = Logger.getLogger(MySessionAwareMessageListener.class);

public void onMessage(Message message, Session session) throws JMSException {
try {
LOG.info("Consumed message: “ + ((TextMessage)message).getText());
// Send a reply message
TextMessage newMessage = session.createTextMessage(“This is a test”);
MessageProducer producer = session.createProducer(message.getJMSReplyTo());
LOG.info("Sending reply message ");
producer.send(newMessage);
} catch (JMSException e) {
LOG.error(e.getMessage(), e);
}
}
}

36


Asynchronous
• XML configuration


<bean id="messageListener"
class="org.bsnyder.spring.jms.listener.MySessionAwareMessageListener" />

<jms:listener destination="FOO.TEST" ref="messageListener"/>

37


MessageListenerAdapter
Asynchronous
• Handles all message content types
• No reply message is sent (void return)

public interface MessageDelegate {
void processMessage(String text);
void processMessage(Map map);
void processMessage(byte[] bytes);
void processMessage(Serializable obj);
}

38


Asynchronous

<bean id="messageDelegate"
class="org.springframework.jms.listener.adapter.MessageListenerAdapter"
p:defaultListenerMethod="processMessage">
<constructor-arg>
<bean class="org.bsnyder.spring.jms.adapter.MessageDelegateImpl" />
</constructor-arg>
<property name="messageConverter">
<null/>
</property>
</bean>

<jms:listener destination="FOO.TEST" ref="messageDelegate" />

39


Asynchronous
• Handles all raw JMS message types
• No reply message is sent (void return)

public interface MessageDelegate {
void processMessage(TextMessage message);
void processMessage(MapMessage message);
void processMessage(BytesMessage message);
void processMessage(ObjectMessage message);
}

40


Asynchronous

<bean id="messageDelegate2"
<constructor-arg>
<bean class="org.bsnyder.spring.jms.adapter.MessageDelegate2Impl" />
</constructor-arg>
<null/>
</property>
</bean>

<jms:listener destination="FOO.TEST2" ref="messageDelegate2" />

41


Local Transactions
Asynchronous

<constructor-arg>
</constructor-arg>
<null/>
</property>
</bean>

<jms:listener-container concurrency="5-10" acknowledge=”transacted”>

42


Global Transactions
Asynchronous
<bean id="activemqXaConnectionFactory"
class="org.apache.activemq.ActiveMQXAConnectionFactory"

<bean id="atomikosConnectionFactory"
class="com.atomikos.jms.AtomikosConnectionFactoryBean"
init-method="init" destroy-method="close">
<property name="uniqueResourceName" value="simpleTransaction"/>
<property name="xaConnectionFactory" ref="activemqXaConnectionFactory"/>
</bean>

<bean id="atomikosTransactionManager"
class="com.atomikos.icatch.jta.J2eeTransactionManager" />
<bean id="atomikosUserTransaction"
class="com.atomikos.icatch.jta.J2eeUserTransaction" />

<bean id="transactionManager"
class="org.springframework.transaction.jta.JtaTransactionManager"
p:transactionManager-ref="atomikosTransactionManager"
p:userTransaction-ref="atomikosUserTransaction">
</bean>
...

43


Global Transactions
Asynchronous

...

<constructor-arg>
</constructor-arg>
<null/>
</property>
</bean>

<jms:listener-container concurrency="5-10"
connection-factory="atomikosConnectionFactory"
transaction-manager="transactionManager" acknowledge="transacted">

44


Thank You!

Q&A


Enterprise Messaging With Spring JMS

More Related Content

Similar to Enterprise Messaging With Spring JMS (20)

More from Bruce Snyder (12)

Recently uploaded (20)

Enterprise Messaging With Spring JMS