org.apache.http.impl.conn.AbstractClientConnAdapter
Abstract adapter from operated to
managed client connections.
Read and write methods are delegated to the wrapped connection.
Operations affecting the connection state have to be implemented
by derived classes. Operations for querying the connection state
are delegated to the wrapped connection if there is one, or
return a default value if there is none.
This adapter tracks the checkpoints for reusable communication states,
as indicated by markReusable and queried by
isMarkedReusable.
All send and receive operations will automatically clear the mark.
Connection release calls are delegated to the connection manager,
if there is one. abortConnection will
clear the reusability mark first. The connection manager is
expected to tolerate multiple calls to the release method.
Known Direct Subclasses
Known Indirect Subclasses
Summary
Fields
Protected Constructors
Public Methods
Protected Methods
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
Details
Fields
The connection manager, if any.
This attribute MUST NOT be final, so the adapter can be detached
from the connection manager without keeping a hard reference there.
protected
boolean
markedReusable
The reusability marker.
Protected Constructors
Creates a new connection adapter.
The adapter is initially
not
marked as reusable.
Parameters
| mgr
| the connection manager, or null |
| conn
| the connection to wrap, or null
|
Public Methods
public
void
abortConnection()
Releases the connection without the option of keep-alive.
This is a "hard" release that implies a shutdown of the connection.
Use
releaseConnection for a graceful release.
public
void
flush()
Writes out all pending buffered data over the open connection.
public
int
getLocalPort()
Returns a collection of connection metrcis
public
int
getRemotePort()
public
SSLSession
getSSLSession()
Obtains the SSL session of the underlying connection, if any.
If this connection is open, and the underlying socket is an
SSLSocket, the SSL session of
that socket is obtained. This is a potentially blocking operation.
Note: Whether the underlying socket is an SSL socket
can not necessarily be determined via
isSecure().
Plain sockets may be considered secure, for example if they are
connected to a known host in the same network segment.
On the other hand, SSL sockets may be considered insecure,
for example depending on the chosen cipher suite.
public
int
getSocketTimeout()
Returns the socket timeout value.
public
boolean
isMarkedReusable()
public
boolean
isOpen()
Checks if this connection is open.
public
boolean
isResponseAvailable(int timeout)
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.
public
boolean
isSecure()
Indicates whether this connection is secure.
The return value is well-defined only while the connection is open.
It may change even while the connection is open.
public
boolean
isStale()
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.
public
void
markReusable()
Marks this connection as being in a reusable communication state.
The checkpoints for reuseable communication states (in the absence
of pipelining) are before sending a request and after receiving
the response in it's entirety.
The connection will automatically clear the checkpoint when
used for communication. A call to this method indicates that
the next checkpoint has been reached.
A reusable communication state is necessary but not sufficient
for the connection to be reused.
A
route mismatch, the connection being closed,
or other circumstances might prevent reuse.
public
void
receiveResponseEntity(HttpResponse response)
Receives the next response entity available from this connection and
attaches it to an existing HttpResponse object.
public
HttpResponse
receiveResponseHeader()
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.
public
void
releaseConnection()
Releases the connection with the option of keep-alive.
This is a "graceful" release and may cause IO operations
for consuming the remainder of a response entity.
Use
abortConnection for a hard release.
Sends the request entity over the connection.
public
void
sendRequestHeader(HttpRequest request)
Sends the request line and all headers over the connection.
public
void
setSocketTimeout(int timeout)
Sets the socket timeout value.
public
void
unmarkReusable()
Marks this connection as not being in a reusable state.
This can be used immediately before releasing this connection
to prevent it's reuse. Reasons for preventing reuse include
error conditions and the evaluation of a
reuse strategy.
Note:
It is
not necessary to call here before writing to
or reading from this connection. Communication attempts will
automatically unmark the state as non-reusable. It can then
be switched back using
markReusable.
Protected Methods
protected
final
void
assertWrappedConn()
Asserts that there is a wrapped connection to delegate to.