Many messaging system vendors have implemented JMS for their products, allowing Java access to the functionality of their systems.

JMS Clients Can Use Java Facilities

JMS clients, since they are based on Java, can make use of existing Java APIs such as JDBC^TM for database access, the JavaBeans^TM components model, JNDI for naming services, JTA for client transaction control, or any of the J2SE^TM and J2EE^TM APIs for enterprise application services.

JMS Details

We now look at the details of building a messaging system client using JMS, starting with messages.

What is a Message?

In messaging systems the point of communication between applications is the message itself, so a developer using JMS must understand messages..

Although the definition of a message varies greatly between messaging systems, JMS provides a unified means of describing and accessing messages. A JMS message consists of three parts:

Message header

For message identification. For example, the header is used to determine if a given message is appropriate for a "subscriber"

Properties

For application-specific, provider-specific, and optional header fields

Body

Holds the content of the message. Several formats are supported, including TextMessages, which wrap a simple String; and ObjectMessages, that wrap arbitrary Java objects (which must be serializable). Other formats are supported as well.

TextMessages

A TextMessage wraps a simple String object. This is useful in situations where only strings are being passed. It is expected that many messaging systems will be based on XML, and TextMessages are a natural container for these.

Creation of a TextMessage object is simple, as these two lines of code indicate:

       TextMessage message = 
              session.createMessage();
       message.setText("hello world");
    

(We'll see the "session" object in the next section.)

A TextMessage created in this way is ready to be published to a messaging system.

ObjectMessages

An ObjectMessage, as its name implies, is a message wrapping a Java object. Any serializable Java object can be used as an ObjectMessage. If multiple objects must be transmitted in a single message, then a Collection object (such as a List or a Set) containing several serializable objects can be used.

This is how an Object message is created:

       ObjectMessage message = session.createObjectMessage();
       message.setObject(myObject);
    

Note on JNDI

JMS, like many of the J2EE APIs, makes use of JNDI (Java Naming and Directory Interface) to discover needed resources. A detailed discussion of JNDI is beyond the scope of this article, but more information can be found at Java Naming and Directory Interface^TM (JNDI)

Building a JMS Client

A typical JMS client can be built following these basic steps:

1. Create a connection to the messaging system provider
2. Create sessions, for sending and receiving messages
3. Create MessageProducers and MessageConsumers to create or receive messages

Once these steps have been performed, a message-producing client will create messages and publish them to topics, while a message-consuming client will listen for messages associated with a topic, and consume them as they arrive.

To illustrate in detail how this works, we examine a typical message producer, used to publish messages to a topic in a pub/sub messaging system. Note that all exception handing code has been omitted for clarity.

Create a Connection

A Connection provides the client access to the underlying messaging system, and performs resource allocation and management. Connections are created using a ConnectionFactory, which is typically located using JNDI.

This code illustrates the steps involved in creating a connection:

    Context messaging = new InitialContext();  
    // get JNDI context
    TopicConnectionFactory topicConnectionFactory = 
       (TopicConnectionFactory) 
          messaging.lookup("TopicConnectionFactory");
    TopicConnection topicConnection =
      topicConnectionFactory.createTopicConnection();
        

Create Sessions

Sessions are lightweight JMS objects which provide a context for producing and consuming messages. Sessions are used to build message producers and message consumers, as well as to build the messages themselves.

       TopicSession session = 
          topicConnection.createTopicSession(false,
                          Session.CLIENT_ACKNOWLEDGE);
        

Locate a Topic

A topic (also known as a subject, group, or channel) is located through JNDI. The topic identifies the messages being sent or received. In pub/sub systems, the subscribers subscribe to a given topic, while the publishers associate topics with the messages they publish.

Here we create a topic called "WeatherData."

     Topic weatherTopic = messaging.lookup("WeatherData");
        

Start the Connection

During the above initialization steps, message flow is inhibited to prevent unpredictable behavior during initialization. Once initialization is complete, the connection must be told to initiate the message flow.

        topicConnection.start();
        

Create a Message Producer

In the publish/subscribe domain, a producer publishes messages to a given topic. This code shows the creation of a publisher and the subsequent building and publishing of a simple text message.

      TopicPublisher publisher = 
            session.createPublisher(weatherData);
      TextMessage message = session.createMessage();
      message.setText("temperature: 35 degrees");

      publisher.publish(message);
        

A similar process is followed to create subscribers, as well as JMS clients for point-to-point systems. Complete details of this process can be found in [1].

Conclusion

We have seen the basic concepts involved in using JMS to build a messaging based application. Before writing JMS code, you will need access to a JMS compliant messaging system. A list of JMS compliant vendors is available at:

   JMS^TM Vendors

Creating and building a JMS based application is simple, yet provides the basis for building powerful, scalable, and highly reliable distributed systems.

Note that JMS is far more complex than is discussed in this article and provides support for administration, security, error handling and recovery, optimization, distributed transactions, message ordering, message acknowledgment, and more. For more information and documentation on the Java Message Service, see:

   Java^TM Message Service Documentation

References

Much of this article is based on the Java^TM Message Service Documentation

Reprinted with permission of SunServer.

About the Author

Reader Feedback