MainClientExec是HTTP请求处理链中最后一个请求执行环节，负责与另一终端的请求/响应交互，也是很重要的类。
源码版本是4.5.2，主要看execute方法，并在里面添加注释。接着详细说下获取连接的过程。
execute方法
@Override
public CloseableHttpResponse execute(
final HttpRoute route,
final HttpRequestWrapper request,
final HttpClientContext context,
final HttpExecutionAware execAware) throws IOException, HttpException {
Args.notNull(route, "HTTP route");
Args.notNull(request, "HTTP request");
Args.notNull(context, "HTTP context");
//Auth相关，这里没关注
AuthState targetAuthState = context.getTargetAuthState();
if (targetAuthState == null) {
targetAuthState = new AuthState();
context.setAttribute(HttpClientContext.TARGET_AUTH_STATE, targetAuthState);
}
AuthState proxyAuthState = context.getProxyAuthState();
if (proxyAuthState == null) {
proxyAuthState = new AuthState();
context.setAttribute(HttpClientContext.PROXY_AUTH_STATE, proxyAuthState);
}
if (request instanceof HttpEntityEnclosingRequest) {
RequestEntityProxy.enhance((HttpEntityEnclosingRequest) request);
}
//userToken后面作为state，用来从连接池中获取连接的时候使用，默认是null。
//如果设置了值，会设置到连接中，再次获取的时候，则优先取status相等的连接
Object userToken = context.getUserToken();
//ConnectionRequest用来获取HttpClientConnection
//为每一个route设置一个连接池，大小可以配置，默认为2
//从route连接池获取一个连接，优先取status等于userToken的。
//这里没有实质的操作，只是创建一个ConnectionRequest，并将获取连接的操作封装在ConnectionRequest中。
final ConnectionRequest connRequest = connManager.requestConnection(route, userToken);
if (execAware != null) {
if (execAware.isAborted()) {
connRequest.cancel();
throw new RequestAbortedException("Request aborted");
} else {
execAware.setCancellable(connRequest);
}
}
final RequestConfig config = context.getRequestConfig();
final HttpClientConnection managedConn;
try {
final int timeout = config.getConnectionRequestTimeout();
//获取连接，这里才执行从连接池中阻塞获取连接的操作，并设置超时时间。
//这里返回的connection，不一定是有效的socket连接，长短连接处理方式不同。
//如果连接没有打开或者不可用，后面会重新建立socket连接。
managedConn = connRequest.get(timeout > 0 ? timeout : 0, TimeUnit.MILLISECONDS);
} catch(final InterruptedException interrupted) {
Thread.currentThread().interrupt();
throw new RequestAbortedException("Request aborted", interrupted);
} catch(final ExecutionException ex) {
Throwable cause = ex.getCause();
if (cause == null) {
cause = ex;
}
throw new RequestAbortedException("Request execution failed", cause);
}
//将连接加入上下文中，暴露连接。
//context就是一个大容器，收藏各种东西，如果觉得有什么资源是需要在别的地方用到的，那就放入context吧。
context.setAttribute(HttpCoreContext.HTTP_CONNECTION, managedConn);
//是否检查连接的有效性。如果检查不可用，就关闭连接。对于关闭的连接，后面会从三次握手开始，重新建立socket连接。
//如果配置检查，就相当于一个悲观锁，每次请求都会消耗最多30ms来检测，影响性能。4.4版本开始就过时了。
if (config.isStaleConnectionCheckEnabled()) {
// validate connection，首先判断连接是否是打开的
if (managedConn.isOpen()) {
this.log.debug("Stale connection check");
//如果是打开的，进一步判断是否可用
if (managedConn.isStale()) {
this.log.debug("Stale connection detected");
//不可用的时候，需要关闭连接，后面再重新建立连接
managedConn.close();
}
}
}
final ConnectionHolder connHolder = new ConnectionHolder(this.log, this.connManager, managedConn);
try {
if (execAware != null) {
execAware.setCancellable(connHolder);
}
HttpResponse response;
for (int execCount = 1;; execCount++) {
//请求是否幂等的，如果不是，则不能retry，抛异常
if (execCount > 1 && !RequestEntityProxy.isRepeatable(request)) {
throw new NonRepeatableRequestException("Cannot retry request " +
"with a non-repeatable request entity.");
}
if (execAware != null && execAware.isAborted()) {
throw new RequestAbortedException("Request aborted");
}
//如果连接没有打开，即连接使用的socket为null，则重新建立连接。
if (!managedConn.isOpen()) {
this.log.debug("Opening connection " + route);
try {
//建立socket连接。
//遍历地址集，成功建立socket连接，就返回，封装在connection中
establishRoute(proxyAuthState, managedConn, route, request, context);
} catch (final TunnelRefusedException ex) {
if (this.log.isDebugEnabled()) {
this.log.debug(ex.getMessage());
}
response = ex.getResponse();
break;
}
}
final int timeout = config.getSocketTimeout();
if (timeout >= 0) {
//设置socketTimeout
managedConn.setSocketTimeout(timeout);
}
if (execAware != null && execAware.isAborted()) {
throw new RequestAbortedException("Request aborted");
}
if (this.log.isDebugEnabled()) {
this.log.debug("Executing request " + request.getRequestLine());
}
if (!request.containsHeader(AUTH.WWW_AUTH_RESP)) {
if (this.log.isDebugEnabled()) {
this.log.debug("Target auth state: " + targetAuthState.getState());
}
this.authenticator.generateAuthResponse(request, targetAuthState, context);
}
if (!request.containsHeader(AUTH.PROXY_AUTH_RESP) && !route.isTunnelled()) {
if (this.log.isDebugEnabled()) {
this.log.debug("Proxy auth state: " + proxyAuthState.getState());
}
this.authenticator.generateAuthResponse(request, proxyAuthState, context);
}
//和服务器具体交互，发送请求头，如果有响应，再接收响应。
response = requestExecutor.execute(request, managedConn, context);
//根据配置的策略，判断是否保持连接，永久还是一段时长
// 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();
}
//跳过
if (needAuthentication(
targetAuthState, proxyAuthState, route, response, context)) {
// Make sure the response body is fully consumed, if present
final HttpEntity entity = response.getEntity();
if (connHolder.isReusable()) {
EntityUtils.consume(entity);
} else {
managedConn.close();
if (proxyAuthState.getState() == AuthProtocolState.SUCCESS
&& proxyAuthState.getAuthScheme() != null
&& proxyAuthState.getAuthScheme().isConnectionBased()) {
this.log.debug("Resetting proxy auth state");
proxyAuthState.reset();
}
if (targetAuthState.getState() == AuthProtocolState.SUCCESS
&& targetAuthState.getAuthScheme() != null
&& targetAuthState.getAuthScheme().isConnectionBased()) {
this.log.debug("Resetting target auth state");
targetAuthState.reset();
}
}
// discard previous auth headers
final HttpRequest original = request.getOriginal();
if (!original.containsHeader(AUTH.WWW_AUTH_RESP)) {
request.removeHeaders(AUTH.WWW_AUTH_RESP);
}
if (!original.containsHeader(AUTH.PROXY_AUTH_RESP)) {
request.removeHeaders(AUTH.PROXY_AUTH_RESP);
}
} else {
break;
}
}
if (userToken == null) {
userToken = userTokenHandler.getUserToken(context);
context.setAttribute(HttpClientContext.USER_TOKEN, userToken);
}
if (userToken != null) {
connHolder.setState(userToken);
}
// 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);
} else {
return new HttpResponseProxy(response, connHolder);
}
} catch (final ConnectionShutdownException ex) {
final InterruptedIOException ioex = new InterruptedIOException(
"Connection has been shut down");
ioex.initCause(ex);
throw ioex;
} catch (final HttpException ex) {
connHolder.abortConnection();
throw ex;
} catch (final IOException ex) {
connHolder.abortConnection();
throw ex;
} catch (final RuntimeException ex) {
connHolder.abortConnection();
throw ex;
}
}
总结一下关心的大致流程：
- 创建连接请求
- 根据连接请求的参数，从连接池中获取一个连接
- 配置是否需要校验连接可用性。如果检查不可用，就关闭连接。
- 如果连接没有打开，则创建一个底层的socket连接。
- 发送请求头部（如果请求中带有entity，则发送）
- 如果有响应，接收响应（先接收头部，如果有请求主体，则接收）
这里有一点注意一下：
检测连接有效性的时候，报的是SocketTimeOut异常，而真正读响应的时候，报的是Connection reset异常。为什么不一样呢？我还没找到方法验证，但这里很可能是检测的时间很短，只有1ms，首先触发了SocketTimeOut异常，而实际读响应的时候，是不会这么短时间的。
获取连接
接下来详细说说根据ConnectionRequest获取HttpClientConnection。即：
managedConn = connRequest.get(timeout > 0 ? timeout : 0, TimeUnit.MILLISECONDS);
首先看ConnectionRequest为何物：
//org.apache.http.impl.conn.PoolingHttpClientConnectionManager
@Override
public ConnectionRequest requestConnection(
final HttpRoute route,
final Object state) {
Args.notNull(route, "HTTP route");
if (this.log.isDebugEnabled()) {
this.log.debug("Connection request: " + format(route, state) + formatStats(route));
}
//从连接池中获取一个CPoolEntry（Connection的包装类）
final Future<CPoolEntry> future = this.pool.lease(route, state, null);
return new ConnectionRequest() {
@Override
public boolean cancel() {
return future.cancel(true);
}
// ConnectionRequest的get方法。调用leaseConnection方法，并且传入future（CPoolEntry的封装（connection的封装））
@Override
public HttpClientConnection get(
final long timeout,
final TimeUnit tunit) throws InterruptedException, ExecutionException, ConnectionPoolTimeoutException {
return leaseConnection(future, timeout, tunit);
}
};
}
所以，ConnectionRequest的get方法，实际是调用PoolingHttpClientConnectionManager的leaseConnection，返回一个HttpClientConnection。
关于获取connection的更多详细信息，可以参考这篇文章，详细讲述了PoolingHttpClientConnectionManager的获取连接给用户的方法。
补充
-
关于config.isStaleConnectionCheckEnabled()：
如果设置每次请求检查连接是否可用，会影响性能。4.4版本开始过时，但官方推荐使用org.apache.http.impl.conn.PoolingHttpClientConnectionManager#getValidateAfterInactivity()。详细了解看这篇最后补充的校验连接有效的方法，有一个案例分析。 -
最后返回的HttpResponseProxy带上ConnectionHolder（响应没有一次读完），这篇文章有一个案例了解，查看成功日志的最后几个步骤。RestTemplate读取扩展字段，第二次读取数据。
另一篇关于此段源码的解读，见这里。
