Find this tutorial in: /usr/local/resin/webapps/resin-doc/jms/tutorial/listener
Try the Tutorial
Introduces the JMS message listener configured with JCA.
Messaging lets a servlet delegate processing to a batch process either
on the same machine or on a separate machine. The servlet creates a message
and sends it to a queue. The servlet immediately completes and when the
batch process is ready, it processes the message.
Messaging is therefore comprised of three main components:
- A Producer creates messages and sends them to
a Queue. The Producer could be something like a Servlet.
- A Queue stores the messages from the Produces and provides
them to a Consumer when ready. The Queue is implemented by the
messaging provider.
- A Consumer processes messages as they become
available in the Queue. The Consumer is typically a bean
implementing the MessageListener interface.
In this example, the Producer is a Servlet which sends a simple message.
The Producer uses a MessageSender configured in the web.xml
to send the message.
MessageServlet
String message = "sample message";
MessageSender sender = ...; // JNDI lookup
sender.send(null, message);
|
In this configuration, the MessageSender is a
com.caucho.services.message.MessageSender. It's also possible
to use the full JMS MessageProducer which is more verbose.
The MessageSender is an interface available in the open
source Hessian distribution,
so it can be used in other application servers as a convenient facade.
The send method completes as soon as
the message is stored in the queue. Laster, when a thread is available, the
Queue will send the message to the Consumer.
The Queue delivers message to the Consumer one by one. When the
Consumer finishes processing a message the Queue will deliver the next
available message.
The Consumer implements javax.jms.MessageListener, and
will therefore be identical code in any application server. The
Consumer might even be on a different server or use a different
application server.
In this example, the Consumer just logs the message.
MyListener
package example;
import java.util.logging.Logger;
import java.util.logging.Level;
import javax.jms.Message;
import javax.jms.TextMessage;
import javax.jms.MessageListener;
public class MyListener implements MessageListener {
private static final Logger log =
Logger.getLogger(MyListener.class.getName());
public void onMessage(Message message)
{
try {
TextMessage textMessage = (TextMessage) message;
log.info("received: " + textMessage.getText());
_lastMessage = textMessage.getText();
} catch (Throwable e) {
log.log(Level.WARNING, e.toString(), e);
}
}
}
|
The configuration is responsible for three things:
- Configuring the Queue
- Configuring the MessageSender
- Configuring the MessageListener
The JMS Queue and its ConnectionFactory
are configured in the <resource-adapter> section. Any JMS 1.1
implementation may be used for the <connection-factory> and
<destination>.
The <connection-factory> configures the MessageSender and saves
it in JNDI.
The <message-listener> and <endpoint-factory> configures
the MessageListener.
web.xml
<web-app xmlns="http://caucho.com/ns/resin">
<connector>
<type>com.caucho.jms.jca.ResourceAdapterImpl</type>
<resource-adapter>
<init>
<connection-factory resin:type="com.caucho.jms.ConnectionFactoryImpl"/>
<destination resin:type="com.caucho.jms.memory.MemoryQueue"/>
</init>
</resource-adapter>
<connection-factory jndi-name="jms/sender"
type="com.caucho.jms.jca.MessageSenderManager"/>
<message-listener type="com.caucho.jms.jca.MessageListenerSpec">
<endpoint-factory type="com.caucho.jms.jca.ListenerEndpointFactory">
<init>
<listener resin:type="example.MyListener"/>
</init>
</endpoint-factory>
</message-listener>
</connector>
</web-app>
|
tag | meaning
|
connector | top-level configuration for the JCA connector
|
type | The type of the connector.
|
resource-adapter | configures the connector/queue as a whole
|
init | Bean-style initialization for each resource
|
connection-factory | The JMS ConnectionFactory class
|
resin:type | The class name
|
destination | The JMS Queue or Topic
|
connection-factory | Configures a Producer
|
jndi-name | The JNDI name where the resource is stored
|
message-listener | Configures a Consumer
|
endpoint-factory | consumer-specific endpoint type
|
listener | configures the user's listener
|
class | meaning
|
com.caucho.jms.jca.ResourceAdapterImpl | Resin's JCA adapter
for the MessageSender and MessageListener
|
com.caucho.jms.ConnectionFactoryImpl | Resin's JMS ConnectionFactory
|
com.caucho.jms.memory.MemoryQueue | Resin's in-memory JMS Queue
|
com.caucho.jms.jca.MessageListenerSpec | Configuration for
the JCA adapter's Consumer
|
com.caucho.jms.jca.ListenerEndpointFactory | Specifies the
configuration for a MessageListener
|
example.MyListener | Example application code
|
Try the Tutorial
Copyright © 1998-2006 Caucho Technology, Inc. All rights reserved.
Resin® is a registered trademark,
and HardCoretm and Quercustm are trademarks of Caucho Technology, Inc. | |
|