io.inversion.utils

Class RestClient.FutureResponse

java.lang.Object

io.inversion.utils.RestClient.FutureResponse

All Implemented Interfaces:

java.lang.Runnable, java.util.concurrent.Future<Response>, java.util.concurrent.RunnableFuture<Response>

Enclosing class:

RestClient

public abstract class RestClient.FutureResponse
extends java.lang.Object
implements java.util.concurrent.RunnableFuture<Response>

A RunnableFuture that blocks on get() until the execution of the Request has returned the Response.

Here are some example uses:

     client.get("/some/relative/path")
          .onSuccess(response -@gt; System.out.println("Success:" + res.toString()))
          .onFailure(response -@gt; System.out.println("Failure:" + res.toString()))
          .onResponse(response -@gt; System.out.println("I get called on success or failure: " + res.getStatus()));


      //-- instead of using the success/failure callbacks as above
      //-- you can wait for the async process to complete by calling 'get()'

      FutureResponse future = client.post("/some/relative/path", new JSNode("hello", "world"));

      //-- request is asynchronously executing now

      //-- the call to get() blocks indefinitely until the async execution completes
      //-- the fact that this method is called 'get()' is not related to HTTP get.

      Response response = future.get();


      //-- if you want to guarantee that your thread will not be indefinitely blocked
      //-- you can use get(long timeout, TimeUnit units) to wait no more than the specified time

      future = client.get("/some/other/path");
      response = future.get(100, TimeUnit.MILLISECONDS);

      if(response == null)
      {
           System.out.println("the http request still has not completed");
      }


 

Method Summary

Modifier and Type	Method and Description
boolean	cancel(boolean arg0) This does nothing.
Response	get() Blocks indefinitely until response is not null.
Response	get(long timeout, java.util.concurrent.TimeUnit unit) Blocks until the arrival of the response just like get() but will return null after the specified timeout if the response has not arrived.
Request	getRequest()
boolean	isCancelled()
boolean	isDone()
boolean	isSuccess()
RestClient.FutureResponse	onFailure(java.util.function.Consumer<Response> handler) Registers a failure callback.
RestClient.FutureResponse	onResponse(java.util.function.Consumer<Response> handler) Registers a listener to be notified regardless of success or failure status.
RestClient.FutureResponse	onSuccess(java.util.function.Consumer<Response> handler) Registers a success callback.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.concurrent.RunnableFuture

run

Method Detail

onSuccess

public RestClient.FutureResponse onSuccess(java.util.function.Consumer<Response> handler)

Registers a success callback.

If the isDone() is already true the handler will be called synchronously right away.

Parameters:

handler - the listener to notify on success

Returns:

this

onFailure

public RestClient.FutureResponse onFailure(java.util.function.Consumer<Response> handler)

Registers a failure callback.

If the isDone() is already true the handler will be called synchronously right away.

Parameters:

handler - the listener to notify on failure

Returns:

this

onResponse

public RestClient.FutureResponse onResponse(java.util.function.Consumer<Response> handler)

Registers a listener to be notified regardless of success or failure status.

If the isDone() is already true the handler will be called synchronously right away.

Parameters:

handler - the listener to notify when the Response has arrived

Returns:

this

get

public Response get()

Blocks indefinitely until response is not null.

Specified by:

get in interface java.util.concurrent.Future<Response>

Returns:

the response

get

public Response get(long timeout,
                    java.util.concurrent.TimeUnit unit)
             throws java.util.concurrent.TimeoutException

Blocks until the arrival of the response just like get() but will return null after the specified timeout if the response has not arrived.

Specified by:

get in interface java.util.concurrent.Future<Response>

Returns:

the response or null if the call has not asynchronously completed

Throws:

java.util.concurrent.TimeoutException

isSuccess

public boolean isSuccess()

Returns:

true if the response is not null and response.isSuccess()

getRequest

public Request getRequest()

Returns:

the Request being run.

isCancelled

public boolean isCancelled()

Specified by:

isCancelled in interface java.util.concurrent.Future<Response>

Returns:

false

cancel

public boolean cancel(boolean arg0)

This does nothing.

Specified by:

cancel in interface java.util.concurrent.Future<Response>

Returns:

false

isDone

public boolean isDone()

Specified by:

isDone in interface java.util.concurrent.Future<Response>

Returns:

true when response is not null.