Mario-Leander Reimer [Mario-Leander Reimer] - Building RESTful Web Services with Java EE 8

In this section, we're going to take a look at the basic usage of asynchronous JAX-RS client APIs. We're using InvocationCallback instances to react to completed and failed calls. We'll also see how to do invocation-chaining of asynchronous client requests with CompletableFuture.

Let's get started and switch to code. As usual, we prepared a small template project to get started. We'll be using a JUnit test to showcase the JAX-RS client APIs. We're going to set up the JAX-RS client instance and the JAX-RS webTarget instance for the previously implemented asynchronous service API. As you might remember, in the previous section, we used Fibonacci number calculations asynchronously. We'll rewrite the test using the asynchronous JAX-RS client APIs against our REST API.

Let's open the AsyncWebServiceClientIntegrationTest class and start our tests; the first test should be pretty easy. We want to construct an asynchronous request and we do this the way we did it before. We use webTarget.path and we request TEXT_PLAIN_TYPE. Now comes the real difference: we call the .async() method and then call .get(Long.class). As you can see, the return type of this call is Future. Let's rename it from longFuture to fibonacci and call the assertEquals method on that one:

This is pretty much all there is to using asynchronous APIs, though there is slightly more. You can register an invocation callback with get to be notified on completed and failed events. Then, we'll see how we implement those callbacks. As you can see, instead of calling get for the actual (Long.class) type, as we did previously, we call the get of InvocationCallback. We can implement the completed method for a successful execution and the failed method for a failure. Again, we'll return Future for a Fibonacci number and we can then call the get method on this Future:

Finally, we'll see how to do invocation-chaining using CompletableFuture. This is quite interesting because we can chain several JAX-RS client calls using a CompletableFuture fluent API. Imagine we want to calculate the Fibonacci numbers 3, 4, 5, 6, 8, and 21 and do all that in one chain call. This is what it could look like:

As you can see, we do the first call and we use the .async() method, which returns Future. We'll convert this Future to a CompletableFuture, and then for the next calls, we use thenApply and we'll do that for the next one and so on and so forth. This will ultimately make seven calls.

Let's run this test to make sure everything's ready and it'll compile our tests. We can see that the first three are already successful; the Fibonacci49WithCallback should result in a 202, and then we're done.

That's all the magic behind the JAX-RS asynchronous line API, as shown in the following screenshot:

You can download the example code files for this book from your account at www.packtpub.com. If you purchased this book elsewhere, you can visit www.packtpub.com/support and register to have the files emailed directly to you.

You can download the code files by following these steps:

1. Log in or register at www.packtpub.com.
2. Select the SUPPORT tab.
3. Click on Code Downloads & Errata .
4. Enter the name of the book in the Search box and follow the onscreen instructions.

Once the file is downloaded, please make sure that you unzip or extract the folder using the latest version of:

• WinRAR/7-Zip for Windows
• Zipeg/iZip/UnRarX for Mac
• 7-Zip/PeaZip for Linux

The code bundle for the book is also hosted on GitHub at https://github.com/PacktPublishing/Building-RESTful-Web-Services-with-Java-EE-8 . In case there's an update to the code, it will be updated on the existing GitHub repository.

We also have other code bundles from our rich catalog of books and videos available at https://github.com/PacktPublishing/ . Check them out!