The time for the send() method reflects the two-second delay introduced into the Web service. This is because the SOAP Message.send() method used in the proxy send() method called by the client is synchronous.

Creating an Asynchronous Message Client Proxy
To introduce asynchrony, we must introduce a "proxy" thread that makes the synchronous call to the Web service so that the proxy send() method, running in the "client" thread, can operate asynchronously with respect to the Web service. The approach shown in Listing 3 introduces a wrapper for the proxy from Part 1. The wrapper has the same signature as the proxy, so the client doesn't have to change. This approach reuses the proxy from Part 1 unmodified.

First, we create a class that will be used to synchronize the client and proxy threads. The class shown in Listing 3 implements a rather standard pattern for synchronizing threads, using synchronized get() and put() methods.

Listing 4 shows the implementation of the proxy thread. It implements methods needed to set the URL for the endpoint of the Web service, set the input to the Web service, and set the synchronizing object. Of course, it also has a run() method, which calls setURL(), send(), and receive() methods in the original proxy (from Part 1) to invoke the Web service and get the response. It then puts the response in the synchronizing object.

Listing 5 shows the proxy wrapper, which has the same signature as the original proxy in Part 1. The new send() method creates an instance of the synchronizing class and an instance of the new thread object and starts the thread. This causes invocation of the proxy thread's run() method, which in turn calls the Web service. The new receive() method calls the get() method of the synchronizing object to retrieve the response.

Since the revised proxy has the same signature as the proxy in Part 1, we need to make only a small change in the client to use the new threaded proxy. Simply change "Message ServiceProxy" to "ProxyWrapper" and save the revised client. Now run client. You'll see something similar to the following results in the Console view:

The two-second delay in the Web service is now reflected in the receive() method. This is exactly the asynchronous behavior desired.

Summary
This article walked you through the steps necessary to introduce asynchrony into SOAP message-based Web services. The solution shown isn't the most complete or efficient - exceptions aren't really handled correctly, and it features reuse of both client code and proxy code from Part 1. However, it's a good start that can be customized.

References