Use this task to develop a J2EE application to use the JMS API directly for asynchronous messaging.
Why and when to perform this task
This topic gives an overview of the steps needed to develop a J2EE application (servlet or enterprise bean) to use the JMS API directly for asynchronous messaging.
This topic only describes the JMS-related
considerations; it does not describe general J2EE application programming,
which you should already be familiar with. For detailed information about
these steps, and for examples of developing a J2EE application to use JMS,
see the
Java Message Service Documentation
and
the WebSphere MQ Using Java book, SC34-5456.
Details of JMS resources that are used by J2EE applications are defined to WebSphere Application Server and bound into the JNDI namespace by the WebSphere administrative support.
To use JMS, a J2EE application completes the following general steps:
Steps for this task
import javax.jms.*; //JMS interfaces import javax.naming.*; //Used for JNDI lookup of administered objects
try { ctx = new InitialContext(env); ...
qcf = (QueueConnectionFactory)ctx.lookup( qcfName ); ... inQueue = (Queue)ctx.lookup( qnameIn ); ...
connection = qcf.createQueueConnection();
The JMS specification defines that connections should be created in the stopped state. Until the connection starts, MessageConsumers that are associated with the connection cannot receive any messages. To start the connection, issue the following command:
connection.start();
boolean transacted = false; session = connection.createQueueSession( transacted, Session.AUTO_ACKNOWLEDGE);
In this example, the session is not transacted, and it should automatically acknowledge received messages. With these settings, a message is backed out only after a system error or if the application terminates unexpectedly.
The following points, as defined in the EJB specification, apply to these flags:
QueueSender queueSender = session.createSender(inQueue);
JMS provides several message types, each of which embodies some knowledge of its content. To avoid referencing the vendor-specific class names for the message types, methods are provided on the Session object for message creation.
In this example, a text message is created from the outString property:
TextMessage outMessage = session.createTextMessage(outString);
To send the message, the message is passed to the send method on the QueueSender:
queueSender.send(outMessage);
messageID = outMessage.getJMSMessageID();
The correlation ID is then used in a message selector, to select only messages that have that ID:
String selector = "JMSCorrelationID = '"+messageID+"'";
QueueReceiver queueReceiver = session.createReceiver(outQueue, selector);
Message inMessage = queueReceiver.receive(2000);
The parameter in the receive call is a timeout in milliseconds. This parameter defines how long the method should wait if there is no message available immediately. If you omit this parameter, the call blocks indefinitely. If you do not want any delay, use the receiveNoWait()method. In this example, the receive call returns when the message arrives, or after 2000ms, whichever is sooner.
In this example, the instanceof operator is used to check that the message received is of the TextMessage type. The message content is then extracted by casting ti the TextMessage subclass.
if ( inMessage instanceof TextMessage ) ... String replyString = ((TextMessage) inMessage).getText();
queueReceiver.close(); ... queueSender.close(); ... session.close(); session = null; ... connection.close(); connection = null;
// Creating a TopicPublisher TopicPublisher pub = session.createPublisher(topic); ... pub.publish(outMessage); ... // Closing TopicPublisher pub.close();
Unlike normal Java exceptions, a JMSException can contain another exception embedded in it. The implementation of JMSException does not include the embedded exception in the output of its toString()method. Therefore, you need to check explicitly for an embedded exception and print it out, as shown in the following example:
catch (JMSException je) { System.out.println("JMS failed with "+je); Exception le = je.getLinkedException(); if (le != null) { System.out.println("linked exception "+le); } }
What to do next
After you have packaged your application, you can next deploy the application into WebSphere Application Server, as described in Deploying a J2EE application to use JMS.