| Class and Description | 
|---|
| AsyncCompletionHandler
 An  
AsyncHandler augmented with an AsyncCompletionHandler.onCompleted(Response) convenience method which gets called
 when the Response processing is finished. | 
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHandler.STATE | 
| AsyncHttpClient
 This class support asynchronous and synchronous HTTP request. 
 | 
| AsyncHttpClient.BoundRequestBuilder | 
| AsyncHttpClientConfig
 Configuration class to use with a  
AsyncHttpClient. | 
| AsyncHttpClientConfig.Builder
 Builder for an  
AsyncHttpClient | 
| AsyncHttpClientConfigBean
 Simple JavaBean version of   
AsyncHttpClientConfig | 
| AsyncHttpProvider
 Interface to be used when implementing custom asynchronous I/O HTTP client. 
 | 
AsyncHttpProviderConfig
AsyncHttpProvider proprietary configurable properties. | 
| Body
 A request body. 
 | 
| BodyConsumer
 A simple API to be used with the  
SimpleAsyncHttpClient class in order to process response's bytes. | 
| BodyDeferringAsyncHandler
 An AsyncHandler that returns Response (without body, so status code and
 headers only) as fast as possible for inspection, but leaves you the option
 to defer body consumption. 
 | 
| BodyGenerator
 Creates a request body. 
 | 
| ConnectionsPool
 An interface used by an  
AsyncHttpProvider for caching http connections. | 
| Cookie | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| FluentStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpContent
 Base class for callback class used by  
AsyncHandler | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| ListenableFuture
 Extended  
Future | 
| Part
 Interface for the parts in a multipart request. 
 | 
| PerRequestConfig
 Per request configuration. 
 | 
| ProgressAsyncHandler
 An extended  
AsyncHandler with two extra callback who get invoked during the content upload to a remote server. | 
| ProxyServer
 Represents a proxy server. 
 | 
| ProxyServer.Protocol | 
| Realm
 This class is required when authentication is needed. 
 | 
| Realm.AuthScheme | 
| Realm.RealmBuilder
 A builder for  
Realm | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Request.EntityWriter
 An entity that can be used to manipulate the Request's body output before it get sent. 
 | 
| RequestBuilder
 Builder for a  
Request. | 
| RequestBuilderBase
 Builder for  
Request | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Response.ResponseBuilder | 
| SignatureCalculator
 Interface that allows injecting signature calculator into
  
RequestBuilder so that signature calculation and inclusion can
 be added as a pluggable component. | 
| SimpleAsyncHttpClient
 Simple implementation of  
AsyncHttpClient and it's related builders (AsyncHttpClientConfig,
 Realm, ProxyServer and AsyncHandler. | 
| SimpleAsyncHttpClient.Builder | 
| SimpleAsyncHttpClient.DerivedBuilder
 This interface contains possible configuration changes for a derived SimpleAsyncHttpClient. 
 | 
| SimpleAsyncHttpClient.ErrorDocumentBehaviour | 
| SSLEngineFactory
 Factory that creates an  
SSLEngine to be used for a single SSL connection. | 
| ThrowableHandler
 Simple  
Throwable handler to be used with SimpleAsyncHttpClient | 
| Class and Description | 
|---|
| BodyConsumer
 A simple API to be used with the  
SimpleAsyncHttpClient class in order to process response's bytes. | 
| ResumableBodyConsumer | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Class and Description | 
|---|
| Body
 A request body. 
 | 
| BodyGenerator
 Creates a request body. 
 | 
| RandomAccessBody
 A request body which supports random access to its contents. 
 | 
| Class and Description | 
|---|
| ListenableFuture
 Extended  
Future | 
| Class and Description | 
|---|
| AsyncCompletionHandler
 An  
AsyncHandler augmented with an AsyncCompletionHandler.onCompleted(Response) convenience method which gets called
 when the Response processing is finished. | 
| AsyncCompletionHandlerBase
 Simple  
AsyncHandler of type Response | 
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHandler.STATE | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| ProgressAsyncHandler
 An extended  
AsyncHandler with two extra callback who get invoked during the content upload to a remote server. | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Class and Description | 
|---|
| FluentStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| RequestBuilderBase
 Builder for  
Request | 
| SignatureCalculator
 Interface that allows injecting signature calculator into
  
RequestBuilder so that signature calculation and inclusion can
 be added as a pluggable component. | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHttpClientConfig
 Configuration class to use with a  
AsyncHttpClient. | 
| AsyncHttpProvider
 Interface to be used when implementing custom asynchronous I/O HTTP client. 
 | 
AsyncHttpProviderConfig
AsyncHttpProvider proprietary configurable properties. | 
| Cookie | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpContent
 Base class for callback class used by  
AsyncHandler | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| ListenableFuture
 Extended  
Future | 
| PerRequestConfig
 Per request configuration. 
 | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Request.EntityWriter
 An entity that can be used to manipulate the Request's body output before it get sent. 
 | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHttpClientConfig
 Configuration class to use with a  
AsyncHttpClient. | 
| AsyncHttpProvider
 Interface to be used when implementing custom asynchronous I/O HTTP client. 
 | 
AsyncHttpProviderConfig
AsyncHttpProvider proprietary configurable properties. | 
| Cookie | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpContent
 Base class for callback class used by  
AsyncHandler | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| ListenableFuture
 Extended  
Future | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHttpClientConfig
 Configuration class to use with a  
AsyncHttpClient. | 
| AsyncHttpProvider
 Interface to be used when implementing custom asynchronous I/O HTTP client. 
 | 
AsyncHttpProviderConfig
AsyncHttpProvider proprietary configurable properties. | 
| ConnectionsPool
 An interface used by an  
AsyncHttpProvider for caching http connections. | 
| Cookie | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| ListenableFuture
 Extended  
Future | 
| PerRequestConfig
 Per request configuration. 
 | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHandler.STATE | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
| Class and Description | 
|---|
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| Class and Description | 
|---|
| AsyncHandler
 An asynchronous handler or callback which gets invoked as soon as some data is available when
 processing an asynchronous response. 
Callback methods get invoked in the following order: AsyncHandler.onStatusReceived(HttpResponseStatus),
 AsyncHandler.onHeadersReceived(HttpResponseHeaders),
 AsyncHandler.onBodyPartReceived(HttpResponseBodyPart), which could be invoked multiple times,
 AsyncHandler.onCompleted(), once the response has been fully read.
 
 Returning a AsyncHandler.STATE.ABORT from any of those callback methods will interrupt asynchronous response
 processing, after that only AsyncHandler.onCompleted() is going to be called. | 
| AsyncHandler.STATE | 
| Cookie | 
| FluentCaseInsensitiveStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| HttpResponseHeaders
 A class that represent the HTTP headers. 
 | 
| HttpResponseStatus
 A class that represent the HTTP response' status line (code + text) 
 | 
| Response
 Represents the asynchronous HTTP response callback for an  
AsyncCompletionHandler | 
| Class and Description | 
|---|
| Body
 A request body. 
 | 
| FluentStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| Part
 Interface for the parts in a multipart request. 
 | 
| RandomAccessBody
 A request body which supports random access to its contents. 
 | 
| Class and Description | 
|---|
| AsyncHttpProvider
 Interface to be used when implementing custom asynchronous I/O HTTP client. 
 | 
| Cookie | 
| FluentStringsMap
 An implementation of a  
String -> List<String> map that adds a fluent interface, i.e. | 
| HttpResponseBodyPart
 A callback class used when an HTTP response body is received. 
 | 
| Part
 Interface for the parts in a multipart request. 
 | 
| ProxyServer
 Represents a proxy server. 
 | 
| Realm
 This class is required when authentication is needed. 
 | 
| Request
 The Request class can be used to construct HTTP request:
  
Request r = new RequestBuilder().setUrl("url")
                      .setRealm((new Realm.RealmBuilder()).setPrincipal(user)
                      .setPassword(admin)
                      .setRealmName("MyRealm")
                      .setScheme(Realm.AuthScheme.DIGEST).build());
   r.execute();
  | 
Copyright © 2015. All rights reserved.