Processing a message after you have received it may entail examining its header fields, properties, and body. The following sections describe how this is done.
The standard JMS message header fields are described in Table 2–4. Table 2–18 shows the methods provided by the JMS Message interface for retrieving the values of these fields: for instance, you can obtain a message’s reply destination with the statement
Destination replyDest = inMsg.getJMSReplyTo();Table 2–18 Message Header Retrieval Methods
Name |
Description |
---|---|
Get message identifier |
|
Get destination |
|
Get reply destination |
|
Get correlation identifier as string |
|
Get correlation identifier as byte array |
|
Get delivery mode |
|
Get priority level |
|
Get time stamp |
|
Get expiration time |
|
Get message type |
|
Get redelivered flag |
Table 2–19 lists the methods defined in the JMS Message interface for retrieving the values of a message’s properties (see Message Properties). There is a retrieval method for each of the possible primitive types that a property value can assume: for instance, you can obtain a message’s time stamp with the statement
long timeStamp = inMsg.getLongProperty("JMSXRcvTimestamp");Table 2–19 Message Property Retrieval Methods
Name |
Description |
---|---|
Get integer property |
|
Get byte property |
|
Get short integer property |
|
Get long integer property |
|
Get floating-point property |
|
Get double-precision property |
|
Get boolean property |
|
Get string property |
|
Get property as object |
|
Get property names |
|
Does property exist? |
There is also a generic getObjectProperty method that returns a property value in objectified form, as a Java object of class Integer, Byte, Short, Long, Float , Double, Boolean, or String . For example, another way to obtain a message’s time stamp, equivalent to that shown above, would be
Long timeStampObject = (Long)inMsg.getObjectProperty("JMSXRcvTimestamp"); long timeStamp = timeStampObject.longValue();
If the message has no property with the requested name, getObjectProperty will return null; the message method propertyExists tests whether this is the case.
The getPropertyNames method returns a Java enumeration object for iterating through all of the property names associated with a given message; you can then use the retrieval methods shown in the table to retrieve each of the properties by name, as shown in Example 2–5.
Enumeration propNames = inMsg.getPropertyNames(); String eachName; Object eachValue; while ( propNames.hasMoreElements() ) { eachName = propNames.nextElement(); eachValue = inMsg.getObjectProperty(eachName); /* Do something with the value */ } |
The methods for retrieving the contents of a message’s body essentially parallel those for composing the body, as described earlier under Composing Messages. The following sections describe these methods for each of the possible message types (text, stream, map, object, and bytes).
The text message method getText (Table 2–20 ) retrieves the contents of a text message’s body in the form of a string:
String textBody = inMsg.getText();Table 2–20 Text Message Access Method
Name |
Description |
---|---|
Get content string |
Reading the contents of a stream message is similar to reading from a data stream, using the access methods shown in Table 2–21: for example, the statement
int intVal = inMsg.readInt();
retrieves an integer value from the message stream.
Table 2–21 Stream Message Access Methods
Name |
Description |
---|---|
Read integer from message stream |
|
Read byte value from message stream |
|
Read byte array from message stream |
|
Read short integer from message stream |
|
Read long integer from message stream |
|
Read floating-point value from message stream |
|
Read double-precision value from message stream |
|
Read boolean value from message stream |
|
Read character from message stream |
|
Read string from message stream |
|
Read value from message stream as object |
The readObject method returns the next value from the message stream in objectified form, as a Java object of the class corresponding to the value’s primitive data type: for instance, if the value is of type int, readObject returns an object of class Integer. The following statements are equivalent to the one shown above:
Integer intObject = (Integer) inMsg.readObject(); int intVal = intObject.intValue();
The MapMessage interface provides the methods shown in Table 2–22 for reading the body of a map message. Each access method takes a name string as an argument and returns the value to which that name is mapped: for instance, under the example shown in Composing Map Messages, the statement
int meaningOfLife = inMsg.getInt("The Meaning of Life");
would set the variable meaningOfLife to the value 42.
Table 2–22 Map Message Access Methods
Name |
Description |
---|---|
Get integer from message map by name |
|
Get byte value from message map by name |
|
Get byte array from message map by name |
|
Get short integer from message map by name |
|
Get long integer from message map by name |
|
Get floating-point value from message map by name |
|
Get double-precision value from message map by name |
|
Get boolean value from message map by name |
|
Get character from message map by name |
|
Get string from message map by name |
|
Get object from message map by name |
|
Does map contain an item with specified name? |
|
Get enumeration of all names in map |
Like stream messages, map messages provide an access method, getObject, that returns a value from the map in objectified form, as a Java object of the class corresponding to the value’s primitive data type: for instance, if the value is of type int, getObject returns an object of class Integer. The following statements are equivalent to the one shown above:
Integer meaningObject = (Integer) inMsg.getObject("The Meaning of Life"); int meaningOfLife = meaningObject.intValue();
The itemExists method returns a boolean value indicating whether the message map contains an association for a given name string:
if ( inMsg.itemExists("The Meaning of Life") ) { /* Life is meaningful */ } else { /* Life is meaningless */ }
The getMapNames method returns a Java enumeration object for iterating through all of the names defined in the map; you can then use getObject to retrieve the corresponding values, as shown in Example 2–6.
Enumeration mapNames = inMsg.getMapNames(); String eachName; Object eachValue; while ( mapNames.hasMoreElements() ) { eachName = mapNames.nextElement(); eachValue = inMsg.getObject(eachName); /* Do something with the value */ } |
The ObjectMessage interface provides just one method, getObject (Table 2–23 ), for retrieving the serialized object that is the body of an object message:
Object messageBody = inMsg.getObject();
You can then typecast the result to a more specific class and process it in whatever way is appropriate.
Table 2–23 Object Message Access Method
Name |
Description |
---|---|
Get serialized object from message body |
The body of a bytes message simply consists of a stream of uninterpreted bytes; its interpretation is entirely a matter of agreement between sender and receiver. This type of message is intended primarily for decoding message formats used by other existing message systems; Message Queue clients should generally use one of the other, more specific message types instead.
Reading the body of a bytes message is similar to reading a stream message (see Processing Stream Messages): you use the methods shown in Table 2–24 to decode primitive values from the message’s byte stream. For example, the statement
int intVal = inMsg.readInt();
retrieves an integer value from the byte stream. The getBodyLength method returns the length of the entire message body in bytes:
int bodyLength = inMsg.getBodyLength();Table 2–24 Bytes Message Access Methods
Name |
Description |
---|---|
Get length of message body in bytes |
|
Read integer from message stream |
|
Read signed byte value from message stream |
|
Read unsigned byte value from message stream |
|
Read byte array from message stream |
|
Read signed short integer from message stream |
|
Read unsigned short integer from message stream |
|
Read long integer from message stream |
|
Read floating-point value from message stream |
|
Read double-precision value from message stream |
|
Read boolean value from message stream |
|
Read character from message stream |
|
Read UTF-8 string from message stream |