极简版的实现，核心架构的原初模型
从MinimalHttpClient从名字可以看出，是一个极简可以用的版本，是核心设计的原初模型。所以我们就从最精简的开始分析。
核心元素只有三个，一个参数 params，一个执行器 requestExecutor，一个连接管理器 connManager。
|
HttpClientConnectionManager(@since 4.3):
连接池组件，管理连接的整个生命周期。连接在连接池中创建、复用以及移除。Connection manager封装了对连接池的具体操作，比如向连接池租用和归还连接。
Connection被创建出来后处于闲置状态，由连接池管理，调用时会校验是否是open状态，不是的话会进行connect。connect的过程就是 基于不同schema(主要是http和https)创建不同的socket连接(ssl和plain)并且将http请求（连接）绑定到socket。同时连接也会因为心跳或者过期等原因被close变成stale状态，直至被下一次get到时或者连接满时被清理出去。
同时连接池还能对连接进行限流–全局和单route连接数。
ClientExecChain：
代表一次完整的调用执行过程，它是一个包装类，类似于java io类，每个包装类完成一个特定的功能，多层嵌套完成一个系统性的功能，比如处理协议范畴的例如cookie、报文解析等，又比如处理自动重试的，等等。
|
再来看核心的执行方法
|
@Override
protected CloseableHttpResponse doExecute(
final HttpHost target,
final HttpRequest request,
final HttpContext context) throws IOException, ClientProtocolException {
Args.notNull(target, "Target host");
Args.notNull(request, "HTTP request");
HttpExecutionAware execAware = null;
if (request instanceof HttpExecutionAware) {
execAware = (HttpExecutionAware) request;
}
try {
final HttpRequestWrapper wrapper = HttpRequestWrapper.wrap(request);
final HttpClientContext localcontext = HttpClientContext.adapt(
context != null ? context : new BasicHttpContext());
final HttpRoute route = new HttpRoute(target);
RequestConfig config = null;
if (request instanceof Configurable) {
config = ((Configurable) request).getConfig();
}
if (config != null) {
localcontext.setRequestConfig(config);
}
return this.requestExecutor.execute(route, wrapper, localcontext, execAware);
} catch (final HttpException httpException) {
throw new ClientProtocolException(httpException);
}
}
|
|
HttpExecutionAware：一个类可能发生blocking I/O可以继承这个接口，这样当blocking I/O被取消的时候，继承这个接口的类会收到通知。
HttpRequestWrapper：HttpRequest的包装类，可以保证在修改Request的时候原始请求对象不会被改变。
HttpRoute：指示对方服务器地址。HttpRoutePlanner用来创建HttpRoute。后者代表客户端request的对端服务器，主要包含rout的host以及proxy信息。
RequestConfig：一些与HTTP请求相关的基础设置。
 |
|
最终，落实到 requestExecutor 去执行。
public MinimalHttpClient(
final HttpClientConnectionManager connManager) {
super();
this.connManager = Args.notNull(connManager, "HTTP connection manager");
this.requestExecutor = newMinimalClientExec(
new HttpRequestExecutor(),
connManager,
DefaultConnectionReuseStrategy.INSTANCE,
DefaultConnectionKeepAliveStrategy.INSTANCE);
this.params = new BasicHttpParams();
}
|
MinimalClientExec：是ClientExecChain的一个实现，只是封装了最基本的HTTP过程，提供最直接的客户端服务器交互，不支持代理，不支持在各种情况下的重试（重定向，权限校验，IO异常等）。
所以，我们在往下一层，看 MinimalClientExec 是如何执行的，由于代码很长，略过非核心的代码用省略代替。
|
private final HttpRequestExecutor requestExecutor;
private final HttpClientConnectionManager connManager;
private final ConnectionReuseStrategy reuseStrategy;
private final ConnectionKeepAliveStrategy keepAliveStrategy;
private final HttpProcessor httpProcessor;
public MinimalClientExec(
final HttpRequestExecutor requestExecutor,
final HttpClientConnectionManager connManager,
final ConnectionReuseStrategy reuseStrategy,
final ConnectionKeepAliveStrategy keepAliveStrategy) {
Args.notNull(requestExecutor, "HTTP request executor");
Args.notNull(connManager, "Client connection manager");
Args.notNull(reuseStrategy, "Connection reuse strategy");
Args.notNull(keepAliveStrategy, "Connection keep alive strategy");
this.httpProcessor = new ImmutableHttpProcessor(
new RequestContent(),
new RequestTargetHost(),
new RequestClientConnControl(),
new RequestUserAgent(VersionInfo.getUserAgent(
"Apache-HttpClient", "org.apache.http.client", getClass())));
this.requestExecutor = requestExecutor;
this.connManager = connManager;
this.reuseStrategy = reuseStrategy;
this.keepAliveStrategy = keepAliveStrategy;
}
|
|
public CloseableHttpResponse execute(){
。。。。
final ConnectionRequest connRequest = connManager.requestConnection(route, null);
。。。。
final HttpClientConnection managedConn = connRequest.get(timeout > 0 ? timeout : 0, TimeUnit.MILLISECONDS);
。。。。
context.setAttribute(HttpCoreContext.HTTP_TARGET_HOST, target);
context.setAttribute(HttpCoreContext.HTTP_REQUEST, request);
context.setAttribute(HttpCoreContext.HTTP_CONNECTION, managedConn);
context.setAttribute(HttpClientContext.HTTP_ROUTE, route);
。。。。
httpProcessor.process(request, context);
final HttpResponse response = requestExecutor.execute(request, managedConn, context);
httpProcessor.process(response, context);
。。。。
final HttpEntity entity = response.getEntity();
。。。。
}
|
|
ConnectionRequest：是由ConnectionManager来管理的Request。
HttpClientConnection：Http连接，用于做请求发送和响应收取。
HttpContext：存储KV型的数据。主要用于HTTP请求过程中，多个逻辑过程之间的数据共享。
ImmutableHttpProcessor：是HttpProcessor的一个实现，从这个接口的名字就可以看出来，为的是处理Http协议。其中包含了多个协议拦截器，分开处理HTTP协议中的不同部分，这是责任链模式的一个典范实现。单纯到ImmutableHttpProcessor，就是一系列HttpRequestInterceptor 和 HttpResponseInterceptor。然后按照次序调用这些拦截器，处理Request或者Response这两个过程。
|
除了上面说说的，外围的管理和处理，最核心的就在于Http请求是如何发出的，如何拿到最原始的数据返回。这就是
HttpRequestExecutor 做的事情。其核心流程是基于 blocking (classic) I/O 模型的。同样，我们略去非核心的部分，只留下核心代码。
|
public HttpResponse execute(){
。。。
HttpResponse response = doSendRequest(request, conn, context);
if (response == null) {
response = doReceiveResponse(request, conn, context);
}
。。。
}
|
|
protected HttpResponse doSendRequest(
final HttpRequest request,
final HttpClientConnection conn,
final HttpContext context) throws IOException, HttpException {
。。。。
conn.sendRequestHeader(request);
if (request instanceof HttpEntityEnclosingRequest) {
// Check for expect-continue handshake. We have to flush the
// headers and wait for an 100-continue response to handle it.
// If we get a different response, we must not send the entity.
boolean sendentity = true;
final ProtocolVersion ver =
request.getRequestLine().getProtocolVersion();
if (((HttpEntityEnclosingRequest) request).expectContinue() &&
!ver.lessEquals(HttpVersion.HTTP_1_0)) {
conn.flush();
// As suggested by RFC 2616 section 8.2.3, we don't wait for a
// 100-continue response forever. On timeout, send the entity.
if (conn.isResponseAvailable(this.waitForContinue)) {
response = conn.receiveResponseHeader();
if (canResponseHaveBody(request, response)) {
conn.receiveResponseEntity(response);
}
final int status = response.getStatusLine().getStatusCode();
if (status < 200) {
if (status != HttpStatus.SC_CONTINUE) {
throw new ProtocolException(
"Unexpected response: " + response.getStatusLine());
}
// discard 100-continue
response = null;
} else {
sendentity = false;
}
}
}
if (sendentity) {
conn.sendRequestEntity((HttpEntityEnclosingRequest) request);
}
}
conn.flush();
context.setAttribute(HttpCoreContext.HTTP_REQ_SENT, Boolean.TRUE);
return response;
}
|
|
protected HttpResponse doReceiveResponse(
final HttpRequest request,
final HttpClientConnection conn,
final HttpContext context) throws HttpException, IOException {
。。。。。
while (response == null || statusCode < HttpStatus.SC_OK) {
response = conn.receiveResponseHeader();
if (canResponseHaveBody(request, response)) {
conn.receiveResponseEntity(response);
}
statusCode = response.getStatusLine().getStatusCode();
} // while intermediate response
return response;
}
|
通过上面的代码，可以发现，最终发出请求和收取请求内容，是 HttpClientConnection 来完成的。Executor只是封装了这个过程，并完成了外围处理。至于 HttpClientConnection 的功能设计和底层Socket实现，之后再讨论。
到这里，其实Http请求的发出收取处理管理等工作的最基础版本（Minimal）就已经非常清楚了。最后理一下MinimalHttpClient最相关的核心类：
可以看到，一个简单的 发送-收取 过程被分成了众多的类来分别处理。看上去很多，实际上也就三个步骤：管理请求(ConnectionManager)，执行请求(ReqeustExecutor)，处理请求(HttpProcessor)。
而每个步骤都有不少相关的东西，但是主线逻辑是非常清晰的。这里基本把最核心的执行链讲完了，下面是分开讨论其他问题。