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();

• A boolean that determines whether or not the session is transacted.

• A parameter that determines the acknowledge mode.

       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:

• The transacted flag passed on createQueueSession is ignored inside a global transaction and all work is performed as part of the transaction. Outside of a transaction the transacted flag is used and, if set to true, the application should use session.commit() and session.rollback() to control the completion of the work. In an EJB2.0 module, if the transacted flag is set to true and outside of an XA transaction, then the session is involved in the WebSphere local transaction and the unresolved action attribute of the method applies to the JMS work if it is not committed or rolled back by the application.

• Clients cannot use Message.acknowledge() to acknowledge messages. If a value of CLIENT_ACKNOWLEDGE is passed on the createxxxSession call, then messages are automatically acknowledged by the application server and Message.acknowledge() is not used.

1. Create MessageProducers to create messages. For point-to-point messaging the MessageProducer is a QueueSender that is created by passing an output queue object (retrieved earlier) into the createSender method on the session. A QueueSender is normally created for a specific queue, so that all messages sent using that sender are sent to the same destination

          QueueSender queueSender = session.createSender(inQueue);
   
   

2. Create the message. Use the session to create an empty message and add the data passed.

   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);
   
   

3. Send the message.

   To send the message, the message is passed to the send method on the QueueSender

          queueSender.send(outMessage);
   
   

1. Create a correlation ID to link the message sent with any replies. In this example, the client receives reply messages that are related to the message that it has sent, by using a provider-specific message ID in a JMSCorrelationID

          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+"'";
   

2. Create a MessageReceiver to receive messages. For point-to-point the MessageReceiver is a QueueReceiver that is created by passing an input queue object (retrieved earlier) and the message selector into the createReceiver method on the session

          QueueReceiver queueReceiver = session.createReceiver(outQueue, selector);
   
   

3. Retrieve the reply message. To retrieve a reply message, the receive method on the QueueReceiver is used

          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.

4. Act on the message received. When a message is received, one can act on it as needed by the business logic of the client. Some general JMS actions are to check that the message is of the correct type and extract the content of the message. To extract the content from the body of the message, it is necessary to cast from the generic Message class (which is the declared return type of the receive methods) to the more specific subclass, such as TextMessage. It is good practice always to test the message class before casting, so that unexpected errors can be handled gracefully.

   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 to 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, we 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

Related Tasks

See Also