Home > Articles > Software Development & Management

  • Print
  • + Share This
This chapter is from the book Request-Reply


When two applications communicate via Messaging (53), the communication is one-way. The applications may want a two-way conversation.

When an application sends a message, how can it get a response from the receiver?

Messaging (53) provides one-way communication between applications. Messages (66) travel on a Message Channel (60) in one direction; they travel from the sender to the receiver. This asynchronous transmission makes the delivery more reliable and decouples the sender from the receiver.

The problem is that communication between components often needs to be two-way. When a program calls a function, it receives a return value. When it executes a query, it receives query results. When one component notifies another of a change, it may want to receive an acknowledgment. How can messaging be two-way?

Perhaps a sender and receiver could share a message simultaneously. Then, each application could add information to the message for the other to consume. But that is not how messaging works. A message is first sent and then received, so the sender and receiver cannot both access the message at the same time.

Perhaps the sender could keep a reference to the message. Then, once the receiver placed its response into the message, the sender could pull the message back. This may work for notes clipped to a clothesline, but it is not how a Message Channel (60) works. A channel transmits messages in one direction. What is needed is a two-way message on a two-way channel.

Figure 5.4 Send a pair of Request-Reply messages, each on its own channel.

Request-Reply has two participants:

  1. Requestor sends a request message and waits for a reply message.
  2. Replier receives the request message and responds with a reply message.

The request channel can be a Point-to-Point Channel (103) or a Publish-Subscribe Channel (106). The difference is whether the request should be broadcasted to all interested parties or should be processed by only a single consumer. The reply channel, on the other hand, is almost always point-to-point, because it usually makes no sense to broadcast replies—they should be returned only to the requestor.

When a caller performs a Remote Procedure Invocation (50), the caller’s thread must block while it waits for the response. With Request-Reply, the requestor has two approaches for receiving the reply.

  1. Synchronous Block—A single thread in the caller sends the request message, blocks (as a Polling Consumer [494]) to wait for the reply message, and then processes the reply. This is simple to implement, but if the requestor crashes, it will have difficulty reestablishing the blocked thread. The request thread awaiting the response implies that there is only one outstanding request or that the reply channel for this request is private for this thread.
  2. Asynchronous Callback—One thread in the caller sends the request message and sets up a callback for the reply. A separate thread listens for reply messages. When a reply message arrives, the reply thread invokes the appropriate callback, which reestablishes the caller’s context and processes the reply. This approach enables multiple outstanding requests to share a single reply channel and a single reply thread to process replies for multiple request threads. If the requestor crashes, it can recover by simply restarting the reply thread. An added complexity, however, is the callback mechanism that must reestablish the caller’s context.

Two applications sending requests and replies to each other are not very helpful. What is interesting is what the two messages represent.

  1. Messaging RPC—This is how to implement Remote Procedure Invocation (50) using messaging. The request is a Command Message (145) that describes the function the replier should invoke. The reply is a Document Message (147) that contains the function’s return value or exception.
  2. Messaging Query—This is how to perform a remote query using messaging. The request is a Command Message (145) containing the query, and the reply is the results of the query, perhaps a Message Sequence (170).
  3. Notify/Acknowledge—This provides for event notification with acknowledgment, using messaging. The request is an Event Message (151) that provides notification, and the reply is a Document Message (147) acknowledging the notification. The acknowledgment may itself be another request, one seeking details about the event.

The request is like a method call. As such, the reply is one of three possibilities:

  1. Void—Simply notifies the caller that the method has finished so that the caller can proceed.
  2. Result value—A single object that is the method’s return value.
  3. Exception—A single exception object indicating that the method aborted before completing successfully, and indicating why.

The request should contain a Return Address (159) to tell the replier where to send the reply. The reply should contain a Correlation Identifier (163) that specifies which request this reply is for.

Example: SOAP 1.1 Messages

SOAP messages come in Request-Reply pairs. A SOAP request message indicates a service the sender wants to invoke on the receiver, whereas a SOAP response message contains the result of the service invocation. The response message contains either a result value or a fault—the SOAP equivalent of an exception [SOAP 1.1].

Example: SOAP 1.2 Response Message Exchange Pattern

Whereas SOAP 1.1 has loosely described response messages, SOAP 1.2 introduces an explicit Request-Response Message Exchange pattern [SOAP 1.2 Part 2]. This pattern describes a separate, potentially asynchronous response to a SOAP request.

Example: JMS Requestor Objects

JMS includes a couple of features that can be used to implement Request-Reply.

A TemporaryQueue is a Queue that can be created programmatically and that lasts only as long as the Connection used to create it. Only MessageConsumers created by the same connection can read from the queue, so it is effectively private to the connection [JMS 1.1].

How do MessageProducers know about this newly created, private queue? A requestor creates a temporary queue and specifies it in the reply-to property of a request message (see Return Address [159]). A well-behaved replier will send the reply back on the specified queue, one that the replier wouldn’t even know about if it weren’t a property of the request message. This is a simple approach the requestor can use to make sure that the replies always come back to it.

The downside with temporary queues is that when their Connection closes, the queue and any messages in it are deleted. Likewise, temporary queues cannot provide Guaranteed Delivery (122); if the messaging system crashes, then the connection is lost, so the queue and its messages are lost.

JMS also provides QueueRequestor, a simple class for sending requests and receiving replies. A requestor contains a QueueSender for sending requests and a QueueReceiver for receiving replies. Each requestor creates its own temporary queue for receiving replies and specifies that in the request’s reply-to property [JMS 1.1]. A requestor makes sending a request and receiving a reply very simple:

QueueConnection connection = // obtain the connection
Queue requestQueue = // obtain the queue
Message request = // create the request message
QueueSession session = connection.createQueueSession(false, Session.AUTO_ACKNOWLEDGE);
QueueRequestor requestor = new QueueRequestor(session, requestQueue );
Message reply = requestor.request(request);

One method—request—sends the request message and blocks until it receives the reply message.

TemporaryQueue, used by QueueRequestor, is a Point-to-Point Channel (103). Its Publish-Subscribe Channel (106) equivalents are TemporaryTopic and TopicRequestor.

  • + Share This
  • 🔖 Save To Your Account