O'Reilly - Java Message Service

Java Message Service
avoids processing the first message if the second message fails to be delivered. If the
messages were to be separately acknowledged, the client could fail after the first message
was acknowledged, but before the second message was fully processed. If this occurred,
the first message would be considered delivered by the JMS provider, yet not fully
processed by the client. It would be effectively lost. Delaying acknowledgment provides a
way to write the application so that it behaves correctly when failures occur. If you still
have your B2B application up and running, try typing the request for surfboards in the
command window for the QWholesaler application:
Surfboards, 999.99, 499.99
Notice that some output appears in the QRetailer window to indicate that the message was
received. Kill the QRetailer application by hitting Ctrl-C in its command window. Next,
type in the second line item in the QWholesaler application:
Wetsuits, 299.99, 149.99
Now restart the QRetailer application. You should see output in the QRetailer window
indicating that both the Surfboard message and the Wetsuits message have been received.
This new instance of the QRetailer receives both messages because the earlier instance of
QRetailer never sent an acknowledgment for the first message. Therefore, when we
restarted the QRetailer, the JMS provider redelivered the Surfboard message, and then
sent the Wetsuits message. A single acknowledgment is now sent, acknowledging both
messages. The JMS provider has now fullfilled its part of the contract with the receiving
application, and can remove the messages from its persistent store.
6.3.2.1 Compensating transactions
In the code that deals with the redelivered flag, we introduced a call to
processCompensatingTransaction( ):
private void autoBuy (javax.jms.Message message){
int count = 1000;
try {
...
if ( saveDesc == null )
{
if ( message.getJMSRedelivered( ) )
processCompensatingTransaction( );
processInterimMessages( itemDesc );
return;
}
...
}
}
This code is executed when the client restarts and receives redelivered messages, as was
the case in the client failure exercise we just went through. The first message of the
sequence will have the redelivered flag set on the message, causing the
processCompensatingTransactions( ) method to be invoked:
private void processCompensatingTransaction( )
{
saveDesc = null; // null out "saved" work
}
94