All Classes and Interfaces
Class
Description
This class is an adaptation of the Apache HttpClient implementation
An abstract base implementation of the listener support provided by
ListenableFuture.An
Appendable customer for ByteBufferAn
AsyncHandler augmented with an AsyncCompletionHandler.onCompleted(Response) convenience method which gets called
when the Response processing is finished.Simple
AsyncHandler of type ResponseAn 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:
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.
This interface hosts new low level callback methods on
AsyncHandler.This class support asynchronous and synchronous HTTP request.
Configuration class to use with a
AsyncHttpClient.Builder for an
AsyncHttpClientSimple JavaBean version of
AsyncHttpClientConfigInterface to be used when implementing custom asynchronous I/O HTTP client.
AsyncHttpProvider proprietary configurable properties.AsyncHttpProvider common utilities.Implements the "base64" binary encoding scheme as defined by
RFC 2045.
A request body.
A simple API to be used with the
SimpleAsyncHttpClient class in order to process response's bytes.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.
A simple helper class that is used to perform automatic "join" for async
download and the error checking of the Future of the request.
Creates a request body.
A
BodyGenerator backed by a byte array.A
ByteBuffer implementation of BodyConsumerValue class for OAuth consumer keys.
Uses the internal HostnameChecker to verify the server's hostname matches with the
certificate.
Default WebSocketListener implementation.
A list of (
Runnable, Executor) pairs that guarantees
that every Runnable that is added using the add method will be
executed in its associated Executor after ExecutionList.run() is called.A Grizzly-specific
BodyGenerator that allows data to be fed to the
connection in blocking or non-blocking fashion via the use of a FeedableBodyGenerator.Feeder.Base class for
FeedableBodyGenerator.Feeder implementations.Specifies the functionality all Feeders must implement.
Implementations of this class provide the framework to read data from
some source and feed data to the
FeedableBodyGenerator
without blocking.Listener to signal that data is available to be fed.
This simple
FeedableBodyGenerator.Feeder implementation allows the implementation to
feed data in whatever fashion is deemed appropriate.A
RandomAccessFile that can be used as a ResumableBodyConsumerCreates a request body from the contents of a file.
An exception that can be thrown by an
AsyncHandler to interrupt invocation of
the RequestFilter and ResponseFilter.An implementation of a
String -> List<String> map that adds a fluent interface, i.e.An implementation of a
String -> List<String> map that adds a fluent interface, i.e.FilterChainEvent to gracefully complete the request-response processing
when Connection is getting closed by the remote host.A Grizzly 2.0-based implementation of
AsyncHttpProvider.AsyncHttpProviderConfig implementation that allows customization
of the Grizzly runtime outside of the scope of what the
AsyncHttpClientConfig offers.Grizzly-specific customization properties.
HttpResponseBodyPart implementation using the Grizzly 2.0 HTTP client
codec.HttpResponseBodyPart implementation using the Grizzly 2.0 HTTP client
codec.HttpResponseHeaders implementation using the Grizzly 2.0 HTTP client
codec.HttpResponseStatus implementation using the Grizzly 2.0 HTTP client
codec.Grizzly AHC
WebSocket adapter.A map containing headers with the sole purpose of being given to
SimpleAHCTransferListener#onHeaders(String, HeaderMap).Hostname checker interface.
A callback class used when an HTTP response body is received.
An
InputStream that reads all the elements in an array of HttpResponseBodyParts.A class that represent the HTTP headers.
A class that represent the HTTP response' status line (code + text)
A
BodyGenerator which use an InputStream for reading bytes, without having to read the entire
stream in memory.This filter is invoked when an
IOException occurs during an http transaction.Extended
FutureThrown when the
AsyncHttpClientConfig.getMaxRedirects() has been reached.Provides an implementation for NTLMv1, NTLMv2, and NTLM2 Session forms of the NTLM
authentication protocol.
Signals NTLM protocol failure.
Simple OAuth signature calculator that can used for constructing client signatures
for accessing services that use OAuth for authorization.
A simple
OutputStream implementation for BodyConsumerA pair of (name, value) String
Handler to pause/resume event processing.
Completion handler wrapper that preserves the construction class loader and MDC on its methods executions.
An extended
AsyncHandler with two extra callback who get invoked during the content upload to a remote server.A
ResumableAsyncHandler.ResumableProcessor which use a properties file
to store the download index information.A HostnameChecker proxy.
Represents a proxy server.
Selector for a proxy server
Utilities for Proxy handling.
A request body which supports random access to its contents.
This class is required when authentication is needed.
A builder for
RealmThe Request class can be used to construct HTTP request:
Builder for a
Request.Builder for
RequestThis class is an adaptation of the Apache HttpClient implementation
A Filter interface that gets invoked before making an actual request.
Value class used for OAuth tokens (request secret, access secret);
simple container with two parts, public id part ("key") and
confidential ("secret") part.
Represents the asynchronous HTTP response callback for an
AsyncCompletionHandlerA Filter interface that gets invoked before making the processing of the response bytes.
An
AsyncHandler which support resumable download, e.g when used with an ResumableIOExceptionFilter,
this handler can resume the download operation at the point it was before the interruption occured.An interface to implement in order to manage the way the incomplete file management are handled.
A listener class that can be used to digest the bytes from an
ResumableAsyncHandlerA
TransferListener which use a RandomAccessFile for storing the received bytes.A parser for RFC2616
Date format.
Interface that allows injecting signature calculator into
RequestBuilder so that signature calculation and inclusion can
be added as a pluggable component.A simple transfer listener for use with the
SimpleAsyncHttpClient.Simple implementation of
AsyncHttpClient and it's related builders (AsyncHttpClientConfig,
Realm, ProxyServer and AsyncHandler.This interface contains possible configuration changes for a derived SimpleAsyncHttpClient.
SPNEGO (Simple and Protected GSSAPI Negotiation Mechanism) authentication
scheme.
Abstract SPNEGO token generator.
Factory that creates an
SSLEngine to be used for a single SSL connection.A CharSequence String wrapper that doesn't copy the char[] (damn new String implementation!!!)
Since cloning (of MAC instances) is not necessarily supported on all platforms
(and specifically seems to fail on MacOS), let's wrap synchronization/reuse details here.
A
RequestFilter throttles requests and block when the number of permits is reached, waiting for
the response to arrives before executing the next request.Simple
Throwable handler to be used with SimpleAsyncHttpClientA
org.asynchttpclient.AsyncHandler that can be used to notify a set of TransferListenerA simple interface an application can implements in order to received byte transfer information.
This class may be provided as an option to the
GrizzlyAsyncHttpProviderConfig
and allows low-level customization of the TCPNIOTransport beyond the
defaults typically used.Invoked when an
AsyncHandler.STATE.UPGRADE is returned.Convenience class that encapsulates details of "percent encoding"
(as per RFC-3986, see [http://www.ietf.org/rfc/rfc3986.txt]).
Simple
AsyncHandler that add support for WebDav's response manipulation.Customized
Response which add support for getting the response's body as an XML document (@link WebDavResponse#getBodyAsXML}A Websocket client
Invoked when WebSocket binary fragments are received.
A
WebSocketListener for bytesExtend the normal close listener with one that support the WebSocket's code and reason.
A generic
WebSocketListener for WebSocket events.A WebSocket's Ping Listener
A WebSocket's Pong Listener
Invoked when WebSocket text fragments are received.
A
WebSocketListener for text messageAn
AsyncHandler which is able to execute WebSocket upgrade.Build a
WebSocketUpgradeHandler