## org.apache.http.impl
Class AbstractHttpClientConnection

    java.lang.Object
      org.apache.http.impl.AbstractHttpClientConnection

All Implemented Interfaces:
  Closeable, HttpClientConnection, HttpConnection

Direct Known Subclasses:
  SocketHttpClientConnection

    @NotThreadSafe
    public abstract class AbstractHttpClientConnection

extends Object
implements HttpClientConnection

Abstract client-side HTTP connection capable of transmitting and receiving data using arbitrary `SessionInputBuffer` and `SessionOutputBuffer` implementations.

The following parameters can be used to customize the behavior of this class:

- `CoreProtocolPNames.STRICT_TRANSFER_ENCODING`
- `CoreConnectionPNames.MAX_HEADER_COUNT`
- `CoreConnectionPNames.MAX_LINE_LENGTH`

Since:
  4.0

Constructor Summary
`AbstractHttpClientConnection()` Creates an instance of this class.

Method Summary
`protected abstract void` `assertOpen()` Asserts if the connection is open.
`protected HttpConnectionMetricsImpl` `createConnectionMetrics(HttpTransportMetrics inTransportMetric, HttpTransportMetrics outTransportMetric)`
`protected EntityDeserializer` `createEntityDeserializer()` Creates an instance of `EntityDeserializer` with the `LaxContentLengthStrategy` implementation to be used for de-serializing entities received over this connection.
`protected EntitySerializer` `createEntitySerializer()` Creates an instance of `EntitySerializer` with the `StrictContentLengthStrategy` implementation to be used for serializing HTTP entities sent over this connection.
`protected HttpResponseFactory` `createHttpResponseFactory()` Creates an instance of `DefaultHttpResponseFactory` to be used for creating `HttpResponse` objects received by over this connection.
`protected HttpMessageWriter<HttpRequest>` `createRequestWriter(SessionOutputBuffer buffer, HttpParams params)` Creates an instance of `HttpMessageWriter` to be used for writing out HTTP requests sent over this connection.
`protected HttpMessageParser<HttpResponse>` `createResponseParser(SessionInputBuffer buffer, HttpResponseFactory responseFactory, HttpParams params)` Creates an instance of `HttpMessageParser` to be used for parsing HTTP responses received over this connection.
`protected void` `doFlush()`
`void` `flush()` Writes out all pending buffered data over the open connection.
`HttpConnectionMetrics` `getMetrics()` Returns a collection of connection metrics.
`protected void` `init(SessionInputBuffer inbuffer, SessionOutputBuffer outbuffer, HttpParams params)` Initializes this connection object with `SessionInputBuffer` and `SessionOutputBuffer` instances to be used for sending and receiving data.
`protected boolean` `isEof()`
`boolean` `isResponseAvailable(int timeout)` Checks if response data is available from the connection.
`boolean` `isStale()` Checks whether this connection has gone down.
`void` `receiveResponseEntity(HttpResponse response)` Receives the next response entity available from this connection and attaches it to an existing HttpResponse object.
`HttpResponse` `receiveResponseHeader()` Receives the request line and headers of the next response available from this connection.
`void` `sendRequestEntity(HttpEntityEnclosingRequest request)` Sends the request entity over the connection.
`void` `sendRequestHeader(HttpRequest request)` Sends the request line and all headers over the connection.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Methods inherited from interface org.apache.http.HttpConnection
`close, getSocketTimeout, isOpen, setSocketTimeout, shutdown`

Constructor Detail

### AbstractHttpClientConnection

    public AbstractHttpClientConnection()

  Creates an instance of this class.

  This constructor will invoke `createEntityDeserializer()` and `createEntitySerializer()` methods in order to initialize HTTP entity serializer and deserializer implementations for this connection.

Method Detail

### assertOpen

    protected abstract void assertOpen()
                                throws IllegalStateException

  Asserts if the connection is open.

  Throws:
    `IllegalStateException` - if the connection is not open.

### createEntityDeserializer

    protected EntityDeserializer createEntityDeserializer()

  Creates an instance of `EntityDeserializer` with the `LaxContentLengthStrategy` implementation to be used for de-serializing entities received over this connection.

  This method can be overridden in a super class in order to create instances of `EntityDeserializer` using a custom `ContentLengthStrategy`.

  Returns:
    HTTP entity deserializer

### createEntitySerializer

    protected EntitySerializer createEntitySerializer()

  Creates an instance of `EntitySerializer` with the `StrictContentLengthStrategy` implementation to be used for serializing HTTP entities sent over this connection.

  This method can be overridden in a super class in order to create instances of `EntitySerializer` using a custom `ContentLengthStrategy`.

  Returns:
    HTTP entity serialzier.

### createHttpResponseFactory

    protected HttpResponseFactory createHttpResponseFactory()

  Creates an instance of `DefaultHttpResponseFactory` to be used for creating `HttpResponse` objects received by over this connection.

  This method can be overridden in a super class in order to provide a different implementation of the `HttpResponseFactory` interface.

  Returns:
    HTTP response factory.

### createResponseParser

    protected HttpMessageParser<HttpResponse> createResponseParser(SessionInputBuffer buffer,
                                                                   HttpResponseFactory responseFactory,
                                                                   HttpParams params)

  Creates an instance of `HttpMessageParser` to be used for parsing HTTP responses received over this connection.

  This method can be overridden in a super class in order to provide a different implementation of the `HttpMessageParser` interface or to pass a different implementation of the `LineParser` to the the `DefaultHttpResponseParser` constructor.

  Parameters:
    `buffer` - the session input buffer.
    `responseFactory` - the HTTP response factory.
    `params` - HTTP parameters.
  Returns:
    HTTP message parser.

### createRequestWriter

    protected HttpMessageWriter<HttpRequest> createRequestWriter(SessionOutputBuffer buffer,
                                                                 HttpParams params)

  Creates an instance of `HttpMessageWriter` to be used for writing out HTTP requests sent over this connection.

  This method can be overridden in a super class in order to provide a different implementation of the `HttpMessageWriter` interface or to pass a different implementation of `LineFormatter` to the the default implementation `HttpRequestWriter`.

  Parameters:
    `buffer` - the session output buffer
    `params` - HTTP parameters
  Returns:
    HTTP message writer

### createConnectionMetrics

    protected HttpConnectionMetricsImpl createConnectionMetrics(HttpTransportMetrics inTransportMetric,
                                                                HttpTransportMetrics outTransportMetric)

  Since:
    4.1

### init

    protected void init(SessionInputBuffer inbuffer,
                        SessionOutputBuffer outbuffer,
                        HttpParams params)

  Initializes this connection object with `SessionInputBuffer` and `SessionOutputBuffer` instances to be used for sending and receiving data. These session buffers can be bound to any arbitrary physical output medium.

  This method will invoke `createHttpResponseFactory()`, `createRequestWriter(SessionOutputBuffer, HttpParams)` and `createResponseParser(SessionInputBuffer, HttpResponseFactory, HttpParams)` methods to initialize HTTP request writer and response parser for this connection.

  Parameters:
    `inbuffer` - the session input buffer.
    `outbuffer` - the session output buffer.
    `params` - HTTP parameters.

### isResponseAvailable

    public boolean isResponseAvailable(int timeout)
                                throws IOException

  Description copied from interface: `HttpClientConnection`
  Checks if response data is available from the connection. May wait for the specified time until some data becomes available. Note that some implementations may completely ignore the timeout parameter.

  Specified by:
    `isResponseAvailable` in interface `HttpClientConnection`
  Parameters:
    `timeout` - the maximum time in milliseconds to wait for data
  Returns:
    true if data is available; false if there was no data available even after waiting for `timeout` milliseconds.
  Throws:
    `IOException` - if an error happens on the connection

### sendRequestHeader

    public void sendRequestHeader(HttpRequest request)
                           throws HttpException,
                                  IOException

  Description copied from interface: `HttpClientConnection`
  Sends the request line and all headers over the connection.

  Specified by:
    `sendRequestHeader` in interface `HttpClientConnection`
  Parameters:
    `request` - the request whose headers to send.
  Throws:
    `HttpException` - in case of HTTP protocol violation
    `IOException` - in case of an I/O error

### sendRequestEntity

    public void sendRequestEntity(HttpEntityEnclosingRequest request)
                           throws HttpException,
                                  IOException

  Description copied from interface: `HttpClientConnection`
  Sends the request entity over the connection.

  Specified by:
    `sendRequestEntity` in interface `HttpClientConnection`
  Parameters:
    `request` - the request whose entity to send.
  Throws:
    `HttpException` - in case of HTTP protocol violation
    `IOException` - in case of an I/O error

### doFlush

    protected void doFlush()
                    throws IOException

  Throws:
    `IOException`

### flush

    public void flush()
               throws IOException

  Description copied from interface: `HttpClientConnection`
  Writes out all pending buffered data over the open connection.

  Specified by:
    `flush` in interface `HttpClientConnection`
  Throws:
    `IOException` - in case of an I/O error

### receiveResponseHeader

    public HttpResponse receiveResponseHeader()
                                       throws HttpException,
                                              IOException

  Description copied from interface: `HttpClientConnection`
  Receives the request line and headers of the next response available from this connection. The caller should examine the HttpResponse object to find out if it should try to receive a response entity as well.

  Specified by:
    `receiveResponseHeader` in interface `HttpClientConnection`
  Returns:
    a new HttpResponse object with status line and headers initialized.
  Throws:
    `HttpException` - in case of HTTP protocol violation
    `IOException` - in case of an I/O error

### receiveResponseEntity

    public void receiveResponseEntity(HttpResponse response)
                               throws HttpException,
                                      IOException

  Description copied from interface: `HttpClientConnection`
  Receives the next response entity available from this connection and attaches it to an existing HttpResponse object.

  Specified by:
    `receiveResponseEntity` in interface `HttpClientConnection`
  Parameters:
    `response` - the response to attach the entity to
  Throws:
    `HttpException` - in case of HTTP protocol violation
    `IOException` - in case of an I/O error

### isEof

    protected boolean isEof()

### isStale

    public boolean isStale()

  Description copied from interface: `HttpConnection`
  Checks whether this connection has gone down. Network connections may get closed during some time of inactivity for several reasons. The next time a read is attempted on such a connection it will throw an IOException. This method tries to alleviate this inconvenience by trying to find out if a connection is still usable. Implementations may do that by attempting a read with a very small timeout. Thus this method may block for a small amount of time before returning a result. It is therefore an expensive operation.

  Specified by:
    `isStale` in interface `HttpConnection`
  Returns:
    `true` if attempts to use this connection are likely to succeed, or `false` if they are likely to fail and this connection should be closed

### getMetrics

    public HttpConnectionMetrics getMetrics()

  Description copied from interface: `HttpConnection`
  Returns a collection of connection metrics.

  Specified by:
    `getMetrics` in interface `HttpConnection`
  Returns:
    HttpConnectionMetrics

Copyright © 2005-2013 The Apache Software Foundation. All Rights Reserved.