public interface AsyncInvoker
Modifier and Type | Method and Description |
---|---|
Future<Response> |
delete()
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> Future<T> |
delete(Class<T> responseType)
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> Future<T> |
delete(GenericType<T> responseType)
Invoke HTTP DELETE method for the current request asynchronously.
|
<T> Future<T> |
delete(InvocationCallback<T> callback)
Invoke HTTP DELETE method for the current request asynchronously.
|
Future<Response> |
get()
Invoke HTTP GET method for the current request asynchronously.
|
<T> Future<T> |
get(Class<T> responseType)
Invoke HTTP GET method for the current request asynchronously.
|
<T> Future<T> |
get(GenericType<T> responseType)
Invoke HTTP GET method for the current request asynchronously.
|
<T> Future<T> |
get(InvocationCallback<T> callback)
Invoke HTTP GET method for the current request asynchronously.
|
Future<Response> |
head()
Invoke HTTP HEAD method for the current request asynchronously.
|
Future<Response> |
head(InvocationCallback<Response> callback)
Invoke HTTP HEAD method for the current request asynchronously.
|
Future<Response> |
method(String name)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
Class<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
Future<Response> |
method(String name,
Entity<?> entity)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
Entity<?> entity,
Class<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
Entity<?> entity,
GenericType<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
Entity<?> entity,
InvocationCallback<T> callback)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
GenericType<T> responseType)
Invoke an arbitrary method for the current request asynchronously.
|
<T> Future<T> |
method(String name,
InvocationCallback<T> callback)
Invoke an arbitrary method for the current request asynchronously.
|
Future<Response> |
options()
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> Future<T> |
options(Class<T> responseType)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> Future<T> |
options(GenericType<T> responseType)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
<T> Future<T> |
options(InvocationCallback<T> callback)
Invoke HTTP OPTIONS method for the current request asynchronously.
|
Future<Response> |
post(Entity<?> entity)
Invoke HTTP POST method for the current request asynchronously.
|
<T> Future<T> |
post(Entity<?> entity,
Class<T> responseType)
Invoke HTTP POST method for the current request asynchronously.
|
<T> Future<T> |
post(Entity<?> entity,
GenericType<T> responseType)
Invoke HTTP POST method for the current request asynchronously.
|
<T> Future<T> |
post(Entity<?> entity,
InvocationCallback<T> callback)
Invoke HTTP POST method for the current request asynchronously.
|
Future<Response> |
put(Entity<?> entity)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> Future<T> |
put(Entity<?> entity,
Class<T> responseType)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> Future<T> |
put(Entity<?> entity,
GenericType<T> responseType)
Invoke HTTP PUT method for the current request asynchronously.
|
<T> Future<T> |
put(Entity<?> entity,
InvocationCallback<T> callback)
Invoke HTTP PUT method for the current request asynchronously.
|
Future<Response> |
trace()
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> Future<T> |
trace(Class<T> responseType)
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> Future<T> |
trace(GenericType<T> responseType)
Invoke HTTP TRACE method for the current request asynchronously.
|
<T> Future<T> |
trace(InvocationCallback<T> callback)
Invoke HTTP TRACE method for the current request asynchronously.
|
Future<Response> get()
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
Note that in case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> Future<T> get(Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> get(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> get(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.Future<Response> put(Entity<?> entity)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
<T> Future<T> put(Entity<?> entity, Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> put(Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> put(Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.callback
- asynchronous invocation callback.future
.Future<Response> post(Entity<?> entity)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.future
.ProcessingException
- in case the invocation processing has failed.<T> Future<T> post(Entity<?> entity, Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> post(Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> post(Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.callback
- asynchronous invocation callback.future
.Future<Response> delete()
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> Future<T> delete(Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> delete(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> delete(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.Future<Response> head()
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.Future<Response> head(InvocationCallback<Response> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
callback
- asynchronous invocation callback.future
.Future<Response> options()
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> Future<T> options(Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> options(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> options(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.Future<Response> trace()
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
future
.<T> Future<T> trace(Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> trace(GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> trace(InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.callback
- asynchronous invocation callback.future
.Future<Response> method(String name)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
name
- method name.future
.<T> Future<T> method(String name, Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.name
- method name.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> method(String name, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> method(String name, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.callback
- asynchronous invocation callback.future
.Future<Response> method(String name, Entity<?> entity)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps a ProcessingException
thrown in case of an invocation processing
failure.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
name
- method name.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.future
.<T> Future<T> method(String name, Entity<?> entity, Class<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- response entity type.name
- method name.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- Java type the response entity will be converted to.future
.<T> Future<T> method(String name, Entity<?> entity, GenericType<T> responseType)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the specified response type is not Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.responseType
- representation of a generic Java type the response
entity will be converted to.future
.<T> Future<T> method(String name, Entity<?> entity, InvocationCallback<T> callback)
Note that calling the Future.get()
method on the returned
Future
instance may throw an ExecutionException
that wraps either a ProcessingException
thrown in case of an invocation processing
failure or a WebApplicationException
or one of its subclasses thrown in case the
received response status code is not successful
and the generic type of the supplied response callback is not
Response
.
In case a processing of a properly received response fails, the wrapped processing exception
will be of ResponseProcessingException
type and will contain the Response
instance whose processing has failed.
T
- generic response entity type.name
- method name.entity
- request entity, including it's full Variant
information.
Any variant-related HTTP headers previously set (namely Content-Type
,
Content-Language
and Content-Encoding
) will be overwritten using
the entity variant information.callback
- asynchronous invocation callback.future
.Copyright © 1996-2017, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.