Package org.eclipse.jetty.client

Jetty Client : Implementation and Core Classes This package provides APIs, utility classes and an implementation of an asynchronous HTTP client.

See: Description

Interface Summary

Interface	Description
AsyncContentProvider	A ContentProvider that notifies listeners that content is available.
AsyncContentProvider.Listener	A listener that is notified of content availability
ContentDecoder	ContentDecoder decodes content bytes of a response.
HttpClientTransport	HttpClientTransport represents what transport implementations should provide in order to plug-in a different transport for HttpClient.
ProtocolHandler

Class Summary

Class	Description
AbstractHttpClientTransport
AuthenticationProtocolHandler
ConnectionPool
ContentDecoder.Factory	Factory for ContentDecoders; subclasses must implement ContentDecoder.Factory.newContentDecoder().
ContinueProtocolHandler
GZIPContentDecoder	ContentDecoder for the "gzip" encoding.
GZIPContentDecoder.Factory	Specialized ContentDecoder.Factory for the "gzip" encoding.
HttpAuthenticationStore
HttpChannel
HttpClient	HttpClient provides an efficient, asynchronous, non-blocking implementation to perform HTTP requests to a server through a simple API that offers also blocking semantic.
HttpConnection
HttpContent	HttpContent is a stateful, linear representation of the request content provided by a ContentProvider that can be traversed one-way to obtain content buffers to send to a HTTP server.
HttpContentResponse
HttpConversation
HttpDestination
HttpExchange
HttpProxy
HttpProxy.HttpProxyClientConnectionFactory
HttpReceiver	HttpReceiver provides the abstract code to implement the various steps of the receive of HTTP responses.
HttpRedirector	Utility class that handles HTTP redirects.
HttpRequest
HttpRequestException
HttpResponse
HttpSender	HttpSender abstracts the algorithm to send HTTP requests, so that subclasses only implement the transport-specific code to send requests over the wire, implementing HttpSender.sendHeaders(HttpExchange, HttpContent, Callback) and HttpSender.sendContent(HttpExchange, HttpContent, Callback).
LeakTrackingConnectionPool
MultiplexHttpDestination<C extends Connection>
Origin
Origin.Address
PoolingHttpDestination<C extends Connection>
ProxyAuthenticationProtocolHandler
ProxyConfiguration	The configuration of the forward proxy to use with HttpClient.
ProxyConfiguration.Proxy
RedirectProtocolHandler
RequestNotifier
ResponseNotifier
Socks4Proxy
Socks4Proxy.Socks4ProxyClientConnectionFactory
TimeoutCompleteListener
WWWAuthenticationProtocolHandler

Exception Summary

Exception	Description
HttpResponseException

Package org.eclipse.jetty.client Description

Jetty Client : Implementation and Core Classes This package provides APIs, utility classes and an implementation of an asynchronous HTTP client.

The core class is HttpClient, which acts as a central configuration object (for example for idle timeouts, max connections per destination, etc.) and as a factory for Request objects.

The HTTP protocol is based on the request/response paradigm, a unit that in this implementation is called exchange and is represented by HttpExchange. An initial request may trigger a sequence of exchanges with one or more servers, called a conversation and represented by HttpConversation. A typical example of a conversation is a redirect, where upon a request for a resource URI, the server replies with a redirect (for example with the 303 status code) to another URI. This conversation is made of a first exchange made of the original request and its 303 response, and of a second exchange made of the request for the new URI and its 200 response.

HttpClient holds a number of destinations, which in turn hold a number of pooled connections.

When a request is sent, its exchange is associated to a connection, either taken from an idle queue or created anew, and when both the request and response are completed, the exchange is disassociated from the connection. Conversations may span multiple connections on different destinations, and therefore are maintained at the HttpClient level.

Applications may decide to send the request and wait for the response in a blocking way, using Request.send(). Alternatively, application may ask to be notified of response events asynchronously, using org.eclipse.jetty.client.api.Request#send(Response.Listener).