序
本文主要研究一下httpclient的ConnectionHolder
ConnectionReleaseTrigger
org/apache/http/conn/ConnectionReleaseTrigger.java
/**
* Interface for releasing a connection. This can be implemented by various
* "trigger" objects which are associated with a connection, for example
* a {@link EofSensorInputStream} or the {@link ManagedHttpClientConnection} itself.
* <p>
* The methods in this interface can safely be called multiple times.
* The first invocation releases the connection, subsequent calls
* are ignored.
*
* @since 4.0
*/
public interface ConnectionReleaseTrigger {
/**
* 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
* {@link #abortConnection abortConnection} for a hard release. The
* connection may be reused as specified by the duration.
*
* @throws IOException
* in case of an IO problem. The connection will be released
* anyway.
*/
void releaseConnection()
throws IOException;
/**
* Releases the connection without the option of keep-alive.
* This is a "hard" release that implies a shutdown of the connection.
* Use {@link #releaseConnection()} for a graceful release.
*
* @throws IOException in case of an IO problem.
* The connection will be released anyway.
*/
void abortConnection()
throws IOException;
}ConnectionReleaseTrigger定義了releaseConnection、abortConnection方法
ConnectionHolder
org/apache/http/impl/execchain/ConnectionHolder.java
@Contract(threading = ThreadingBehavior.SAFE)
class ConnectionHolder implements ConnectionReleaseTrigger, Cancellable, Closeable {
private final Log log;
private final HttpClientConnectionManager manager;
private final HttpClientConnection managedConn;
private final AtomicBoolean released;
private volatile boolean reusable;
private volatile Object state;
private volatile long validDuration;
private volatile TimeUnit timeUnit;
public ConnectionHolder(
final Log log,
final HttpClientConnectionManager manager,
final HttpClientConnection managedConn) {
super();
this.log = log;
this.manager = manager;
this.managedConn = managedConn;
this.released = new AtomicBoolean(false);
}
public boolean isReusable() {
return this.reusable;
}
public void markReusable() {
this.reusable = true;
}
public void markNonReusable() {
this.reusable = false;
}
public void setState(final Object state) {
this.state = state;
}
public void setValidFor(final long duration, final TimeUnit timeUnit) {
synchronized (this.managedConn) {
this.validDuration = duration;
this.timeUnit = timeUnit;
}
}
private void releaseConnection(final boolean reusable) {
if (this.released.compareAndSet(false, true)) {
synchronized (this.managedConn) {
if (reusable) {
this.manager.releaseConnection(this.managedConn,
this.state, this.validDuration, this.timeUnit);
} else {
try {
this.managedConn.close();
log.debug("Connection discarded");
} catch (final IOException ex) {
if (this.log.isDebugEnabled()) {
this.log.debug(ex.getMessage(), ex);
}
} finally {
this.manager.releaseConnection(
this.managedConn, null, 0, TimeUnit.MILLISECONDS);
}
}
}
}
}
@Override
public void releaseConnection() {
releaseConnection(this.reusable);
}
@Override
public void abortConnection() {
if (this.released.compareAndSet(false, true)) {
synchronized (this.managedConn) {
try {
this.managedConn.shutdown();
log.debug("Connection discarded");
} catch (final IOException ex) {
if (this.log.isDebugEnabled()) {
this.log.debug(ex.getMessage(), ex);
}
} finally {
this.manager.releaseConnection(
this.managedConn, null, 0, TimeUnit.MILLISECONDS);
}
}
}
}
@Override
public boolean cancel() {
final boolean alreadyReleased = this.released.get();
log.debug("Cancelling request execution");
abortConnection();
return !alreadyReleased;
}
public boolean isReleased() {
return this.released.get();
}
@Override
public void close() throws IOException {
releaseConnection(false);
}
}ConnectionHolder實現了ConnectionReleaseTrigger接口，它提供了isReusable、markReusable、markNonReusable、setValidFor、releaseConnection、abortConnection、cancel、close等方法，其中releaseConnection是依賴reusable屬性來決定是關閉連接還是歸還連接，而abortConnection方法直接managedConn.shutdown()，然後在執行manager.releaseConnection
releaseConnection在連接複用則執行manager.releaseConnection，連接不復用先執行managedConn.close()再執行manager.releaseConnection(validDuratioin為0);
abortConnection先執行this.managedConn.shutdown()，再執行manager.releaseConnection(validDuratioin為0);
close與shutdown的區別在於close是優雅關閉，會試圖flush內部的output buffer，shutdown是強制關閉，不會試圖去flush內部的buffer
MainClientExec
org/apache/http/impl/execchain/MainClientExec.java
public CloseableHttpResponse execute(
final HttpRoute route,
final HttpRequestWrapper request,
final HttpClientContext context,
final HttpExecutionAware execAware) throws IOException, HttpException {
//......
// The connection is in or can be brought to a re-usable state.
if (reuseStrategy.keepAlive(response, context)) {
// Set the idle duration of this connection
final long duration = keepAliveStrategy.getKeepAliveDuration(response, context);
if (this.log.isDebugEnabled()) {
final String s;
if (duration > 0) {
s = "for " + duration + " " + TimeUnit.MILLISECONDS;
} else {
s = "indefinitely";
}
this.log.debug("Connection can be kept alive " + s);
}
connHolder.setValidFor(duration, TimeUnit.MILLISECONDS);
connHolder.markReusable();
} else {
connHolder.markNonReusable();
}
//......
// check for entity, release connection if possible
final HttpEntity entity = response.getEntity();
if (entity == null || !entity.isStreaming()) {
// connection not needed and (assumed to be) in re-usable state
connHolder.releaseConnection();
return new HttpResponseProxy(response, null);
}
return new HttpResponseProxy(response, connHolder);
//......
} MainClientExec的execute方法在通過requestExecutor.execute(request, managedConn, context)獲取到response的時候，會根據reuseStrategy.keepAlive(response, context)來判斷該conn是reusable還是nonReusable的，最後在成功場景，entity為null或者不是streaming的會執行connHolder.releaseConnection()，異常場景執行connHolder.abortConnection()
DefaultClientConnectionReuseStrategy
org/apache/http/impl/client/DefaultClientConnectionReuseStrategy.java
public class DefaultClientConnectionReuseStrategy extends DefaultConnectionReuseStrategy {
public static final DefaultClientConnectionReuseStrategy INSTANCE = new DefaultClientConnectionReuseStrategy();
@Override
public boolean keepAlive(final HttpResponse response, final HttpContext context) {
final HttpRequest request = (HttpRequest) context.getAttribute(HttpCoreContext.HTTP_REQUEST);
if (request != null) {
final Header[] connHeaders = request.getHeaders(HttpHeaders.CONNECTION);
if (connHeaders.length != 0) {
final TokenIterator ti = new BasicTokenIterator(new BasicHeaderIterator(connHeaders, null));
while (ti.hasNext()) {
final String token = ti.nextToken();
if (HTTP.CONN_CLOSE.equalsIgnoreCase(token)) {
return false;
}
}
}
}
return super.keepAlive(response, context);
}
}
DefaultClientConnectionReuseStrategy繼承了DefaultConnectionReuseStrategy，其keepAlive先判斷response的header有無Connection: close，沒有則返回false，有則調用super.keepAlive進行進一步判斷(`對於http1.0的返回false)
小結
httpclient的ConnectionHolder實現了ConnectionReleaseTrigger接口，它提供了isReusable、markReusable、markNonReusable、setValidFor、releaseConnection、abortConnection、cancel、close等方法；releaseConnection在連接複用則執行manager.releaseConnection(validDuration為response的Keep-Alive返回的timeout參數，若沒有則為-1)，連接不復用先執行managedConn.close()再執行manager.releaseConnection(validDuration為0)；abortConnection先執行this.managedConn.shutdown()，再執行manager.releaseConnection(validDuration為0)；
MainClientExec的execute方法在通過requestExecutor.execute(request, managedConn, context)獲取到response的時候，會根據reuseStrategy.keepAlive(response, context)來判斷該conn是reusable還是nonReusable的，最後在成功場景，entity為null或者不是streaming的會執行connHolder.releaseConnection()，異常場景執行connHolder.abortConnection()
DefaultClientConnectionReuseStrategy繼承了DefaultConnectionReuseStrategy，其keepAlive先判斷response的header有無
Connection: close，沒有則返回false，有則調用super.keepAlive進行進一步判斷(`對於http1.0的返回false)close與shutdown的區別在於close是優雅關閉，會試圖flush內部的output buffer，shutdown是強制關閉，不會試圖去flush內部的buffer
