Fuse MQ Enterprise - Product Introduction

JMS Development

Overview

Developing applications using the JMS APIs is a straightforward process. The APIs facilitate the creation of objects that mitigate the interface between client applications and the message broker. Once connected to a broker, clients can create, send and receive messages.

Basic application components

A JMS application typically consist of these basic interfaces and classes:

Connection factory

Connection factories are administered objects that clients use to create connections to a message broker. You can optimize some messaging characteristics by enabling, disabling, or otherwise modifying the values of certain connection factory properties.

Connection

Connections are the objects clients use to specify a transport protocol and credentials for sustained interaction with a broker.

Session

Sessions are created by a client on a connection established with a broker. They define whether its messages will be transacted and the acknowledgement mode when they are not. Clients can create multiple sessions on a single connection.

Destinations

Destinations are created by a client on a per-session basis. They are client-side representations of the queue or topic to which messages are sent. The message broker maintains its own representations of the destinations as well.

Producer

Producers are client-side objects that create and send messages to a broker. They are instances the MessageProducer interface and are created on a per-session basis.

The MessageProducer interface provides methods not only for sending messages, but also for setting various message headers, including JMSDeliveryMode which controls message persistence, JMSPriority which controls message priority, and JMSExpiration which controls a message's lifespan.

Consumer

Consumers are client-side objects that process messages retrieved from a broker. They are instances of the MessageConsumer interface and are created on a per-session basis.

The MessageConsumer interface can consume messages synchronously by using one of the MessageConsumer.receive() methods, or asynchronously by registering a MessageListener with the MessageConsumer.setMessageListener() method. With a MessageListener registered on a destination, messages arriving at the destination invoke the consumer's MessageListener.onMessage() method, freeing the consumer from having to repeatedly poll the destination for messages.

Messages

Messages are the backbone of a messaging system. They are objects that contain not only the data payload, but also the required header and optional properties needed to transfer them from one client application to another. See JMS Message Basics.

Development steps

Figure 2 shows the typical sequence of events involved in sending or receiving messages in a Fuse MQ Enterprise client application.

Figure 2. Messaging sequence

flow chart of steps in developing a messaging application

The following procedure shows how to implement the sequence of events shown in Figure 2:

Get a connection factory.
The process for getting a connection factory depends on your environment. It is typical to use JNDI to obtain the connection factory. Fuse MQ Enterprise allows you to instantiate connection factories directly in consumer code or obtain connection factories using Spring in addition to using JNDI.
Create a connection from the connection factory as shown in Example 1.
Example 1. Getting a Connection
```
connection=connectionFactory.createConnection();
```
Start the connection using the connection's start() method.

Create a session from the connection.

Example 2. Creating a Session

session=connection.createSession(false,
                                 Session.AUTO_ACKNOWLEDGE);

Create a destination from the session.
Example 3 shows code for createing a queue called foo.
Example 3. Creating a Queue
```
destination=session.createQueue("FOO.QUEUE");
```
Create objects for producing and consuming messages.
1. Create a producer as shown in Example 4.
  Example 4. Creating a Message Producer
```
producer=session.createProducer(destination);
```
2. Create a consumer as shown in Example 5.
  Example 5. Creating a Consumer
```
consumer=session.createConsumer(destination);
```
Create a message from the session object.
Example 6 shows code for creating a text message.
Example 6. Creating a Text Message
```
message=session.createTextMessage("This is a foo test.");
```
Send and receive messages.
1. Send messages from the producer as shown in Example 7.
  Example 7. Sending a Message
```
producer.send(message);
```
2. Receive messages from the consumer.
  Example 8 shows code for synchronously receiving a text message.
  Example 8. Receiving a Message
```
message = (TextMessage)consumer.receive();
```
Close all JMS resources.

Comments powered by Disqus