OKHttp原码分析(七)之HttpStream

一，概述

在上篇blog中，讲解了RealConnection类以及重要的方法。当RealConnection类只在httpStream类中被引用。httpStream类是对RealConnection类的封装。

在ConnectInterceptor类中创建了httpStream对象。在CallServerInterceptor类中使用httpstream写请求头，写请求头，得到Response对象。从这也可以看出httpstream类的重要性。

在网络请求中除了httpStream类和RealConnection类还有一个重要的类，StreamAllocation。下面首先看下这个类的创建。

二，StreamAllocation对象的创建

得到StreamAllocation对象的代码是：

StreamAllocation streamAllocation = ((RealInterceptorChain) chain).streamAllocation();

下面看RealInterceptorChain类的streamAllocation方法的源码：

public StreamAllocation streamAllocation() {
return streamAllocation;
}

发现这个方法只是返回了streamAllocation对象，这个对象已经在其他地方被创建了。下面开始寻找这个对象的来源。

通过寻找发现streamAllocation对象在RetryAndFollowUpInterceptor类的intercept方法中被创建，核心代码是：

streamAllocation = new StreamAllocation(client.connectionPool(), createAddress(request.url()));

下面看createAddress方法的源码：

private Address createAddress(HttpUrl url) {
SSLSocketFactory sslSocketFactory = null;
HostnameVerifier hostnameVerifier = null;
CertificatePinner certificatePinner = null;
if (url.isHttps()) {
sslSocketFactory = client.sslSocketFactory();
hostnameVerifier = client.hostnameVerifier();
certificatePinner = client.certificatePinner();
}

return new Address(url.host(), url.port(), client.dns(), client.socketFactory(),
sslSocketFactory, hostnameVerifier, certificatePinner, client.proxyAuthenticator(),
client.proxy(), client.protocols(), client.connectionSpecs(), client.proxySelector());
}

这儿有个重要的字段需要注意，sslSocketFactory。如果url是https则sslSocketFactory有值。如果url是http则sslSocketFactory等于null.

三，httpstream对象的创建

创建httpstream对象使用的代码是：

HttpStream httpStream = streamAllocation.newStream(client, doExtensiveHealthChecks);

streamAllocation是StreamAllocation 类，newStream方法的源码是：

public HttpStream newStream(OkHttpClient client, boolean doExtensiveHealthChecks) {
int connectTimeout = client.connectTimeoutMillis();//得到设置在OKHttpClient中的字段
int readTimeout = client.readTimeoutMillis();
int writeTimeout = client.writeTimeoutMillis();
boolean connectionRetryEnabled = client.retryOnConnectionFailure();

try {
;//得到RealConnection 对象，这个是建立网络连接的关键代码，后面做详细讲解。
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,writeTimeout, connectionRetryEnabled, doExtensiveHealthChecks);

HttpStream resultStream;
;//使用RealConnection 对象创建HttpStream对象，
if (resultConnection.framedConnection != null) {
resultStream = new Http2xStream(client, this,resultConnection.framedConnection);
} else {
resultConnection.socket().setSoTimeout(readTimeout);
resultConnection.source.timeout().timeout(readTimeout, MILLISECONDS);
resultConnection.sink.timeout().timeout(writeTimeout, MILLISECONDS);
resultStream = new Http1xStream(
client, this, resultConnection.source, resultConnection.sink);
}
return resultStream;
} catch (IOException e) {
throw new RouteException(e);
}
}

分析：

在代码中创建httpStream对象时，根据情况使用了两个不同的类，Http1xStream和Http2xStream类。这两个类的作用是一样的，只是使用的协议不同。Http1xStream使用的是http1.1协议，Http2xStream使用的是http2.0或SPDY协议。

究竟是使用Http1xStream对象还是使用Http2xStream对象，要看resultConnection.framedConnection != null的返回值。

在RealConnection类的establishProtocol方法中得知，如果是https则创建framedConnection 对象。即如果是https就使用Http2xStream类创建对象。如果是http则使用Http1xStream创建对象。

其实两个类的作用和用法是类似的，只是协议不同。下面以Http1xStream为例分析HttpStream的使用。首先看Http1xStream的构造方法。

四，Http1xStream的构造方法

public Http1xStream(OkHttpClient client, StreamAllocation streamAllocation, BufferedSource source, BufferedSink sink) {
this.client = client;
this.streamAllocation = streamAllocation;
this.source = source;
this.sink = sink;
}

这个方法中尤其注意一点：source对象和sink对象是从RealConnection中传递过来的，即这是链接socket以后得到的输入流和输出流对象。

五，向服务器中写数据的操作

在分析RequestBody类中我们知道写操作的本质调用的是RequestBody的WriteTo方法，但这个方法中需要传递一个输出流对象。下面就看这个方法被调用的地方。

在CallServerInterceptor类的intercept方法中调用了RequestBody的WriteTo方法，源码如下：

if (HttpMethod.permitsRequestBody(request.method()) && request.body() != null) {
Sink requestBodyOut = httpStream.createRequestBody(request, request.body().contentLength());
BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
request.body().writeTo(bufferedRequestBody);
bufferedRequestBody.close();
}

此时传递的是bufferedRequestBody对象，这个对象是由httpStream的createRequestBody方法得到。下面看Http1xStream类的createRequestBody方法的源码：

@Override public Sink createRequestBody(Request request, long contentLength) {
if ("chunked".equalsIgnoreCase(request.header("Transfer-Encoding"))) {
// Stream a request body of unknown length.
return newChunkedSink();
}

if (contentLength != -1) {
// Stream a request body of a known length.
return newFixedLengthSink(contentLength);
}

throw new IllegalStateException(
"Cannot stream a request body without chunked encoding or a known content length!");
}

这个方法中调用了newFixedLengthSink方法，newFixedLengthSink方法中创建了FixedLengthSink对象。

FixedLengthSink是Http1xStream中的内部类，实现了sink接口，并重写了write方法，下面看write方法的源码：

@Override public void write(Buffer source, long byteCount) throws IOException {
if (closed) throw new IllegalStateException("closed");
checkOffsetAndCount(source.size(), 0, byteCount);
if (byteCount > bytesRemaining) {
throw new ProtocolException("expected " + bytesRemaining
+ " bytes but received " + byteCount);
}
sink.write(source, byteCount);
bytesRemaining -= byteCount;
}

此时发现，FixedLengthSink的write方法调用的是Http1xStream的sink字段的write方法。我们知道Http1xStream的sink字段值来自于socket的输出流。

到目前为止，从RequestBody设置参数，到向服务器写参数都梳理通了。

六，从服务器中得到数据

在分析Response类时，我们知道服务的返回值数据都是从ResponseBody中获取的。那么这个类是什么时候被创建的呢，如下：

在CallServerInterceptor类的intercept方法中有下面代码：

Response response = httpStream.readResponseHeaders()
.request(request)
.handshake(streamAllocation.connection().handshake())
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(System.currentTimeMillis())
.build();//创建请求头

if (!forWebSocket || response.code() != 101) {
response = response.newBuilder()
.body(httpStream.openResponseBody(response))
.build();//设置请求体
}

下面看Http1xStream类的openResponseBody方法的源码：

@Override public ResponseBody openResponseBody(Response response) throws IOException {
Source source = getTransferStream(response);
return new RealResponseBody(response.headers(), Okio.buffer(source));
}

在分析RealResponseBody时就知道，创建RealResponseBody必须有一个输入流，只要有输入流就可以从流中解析字节数组数据或字符串数据。得到source 对象使用的是getTransferStream方法。

在getTransferStream方法中调用了newFixedLengthSource方法，newFixedLengthSource方法中创建了FixedLengthSource对象。

FixedLengthSource是Http1xStream中的内部类，继承AbstractSource类，并重写了read方法，下面看read方法的源码：

@Override public long read(Buffer sink, long byteCount) throws IOException {
if (byteCount < 0) throw new IllegalArgumentException("byteCount < 0: " + byteCount);
if (closed) throw new IllegalStateException("closed");
if (bytesRemaining == 0) return -1;

long read = source.read(sink, Math.min(bytesRemaining, byteCount));
if (read == -1) {
endOfInput(false); // The server didn't supply the promised content length.
throw new ProtocolException("unexpected end of stream");
}

bytesRemaining -= read;
if (bytesRemaining == 0) {
endOfInput(true);
}
return read;
}

此时发现，FixedLengthSource的read方法调用的是Http1xStream的source字段的read方法。我们知道Http1xStream的source字段值来自于socket的输入流。

到目前为止，从服务器中得到流对象，从流对象中解析数据都梳理通了。

八，OKHttp是怎么区分的响应头与响应体

在socket中是不区分响应头和响应体的，所有数据都放在一个流中。而OKHttp是区分响应头和响应体的。OKHttp底层又是socket来实现的。那么OKHttp是怎么区分的响应头和响应体的呢？

在CallServerInterceptor类的intercept方法中可知，是先获取请求头，再获取请求体的。获取请求头的方法是httpStream类的readResponseHeaders()方法，这个方法的源码如下：

@Override public Response.Builder readResponseHeaders() throws IOException {
return readResponse();
}

继续看readResponse方法的源码：

public Response.Builder readResponse() throws IOException {
if (state != STATE_OPEN_REQUEST_BODY && state != STATE_READ_RESPONSE_HEADERS) {
throw new IllegalStateException("state: " + state);
}

try {
while (true) {
StatusLine statusLine = StatusLine.parse(source.readUtf8LineStrict());

Response.Builder responseBuilder = new Response.Builder()
.protocol(statusLine.protocol)
.code(statusLine.code)
.message(statusLine.message)
.headers(readHeaders());

if (statusLine.code != HTTP_CONTINUE) {
state = STATE_OPEN_RESPONSE_BODY;
return responseBuilder;
}
}
} catch (EOFException e) {
// Provide more context if the server ends the stream before sending a response.
IOException exception = new IOException("unexpected end of stream on " + streamAllocation);
exception.initCause(e);
throw exception;
}
}

从代码中发现，请求头数据通过StatusLine.parse(source.readUtf8LineStrict());解析到了statusLine 对象中。

下面看source的readUtf8LineStrict源码。source的实现类是RealBufferedSource。方法源码是：

@Override public String readUtf8LineStrict() throws IOException {
long newline = indexOf((byte) '\n');
if (newline == -1L) {
Buffer data = new Buffer();
buffer.copyTo(data, 0, Math.min(32, buffer.size()));
throw new EOFException("\\n not found: size=" + buffer.size()
+ " content=" + data.readByteString().hex() + "…");
}
return buffer.readUtf8Line(newline);
}

关键代码是indexOf方法，这个方法传递的参数是\n。方法的源码是：

@Override public long indexOf(byte b, long fromIndex) throws IOException {
if (closed) throw new IllegalStateException("closed");

while (true) {
long result = buffer.indexOf(b, fromIndex);
if (result != -1) return result;

long lastBufferSize = buffer.size;
if (source.read(buffer, Segment.SIZE) == -1) return -1L;

// Keep searching, picking up from where we left off.
fromIndex = Math.max(fromIndex, lastBufferSize);
}
}

我们看到，在此时source已经开始从服务器读取数据了。index传递的参数是\n，应该是以\n为分界点，\n之前的数据都读到响应头里面。\n之后的数据交给响应体来读取。

\n分界点是协议的约定，服务器也要遵从这个约定。将响应头数据放在\n之前，将响应体数据放在\n之后。

八，总结

OKHttp中向服务器提交数据有三个重要的类：RequestBody，httpStream，RealConnection。上传流程如下：

1，首先把参数保存在RequestBody对象中，RequestBody类又提供了写方法且接收一个输出流对象，但是不调用，在需要时再调用。

2，RealConnection负责Socket连接，并从连接中得到输出流对象。

3，在httpStream中调用RequestBody的写方法，并把RealConnection的输出流对象传递过去。

以上三步就完成了向服务器写数据的操作。

OKHttp中从服务器中获取数据有三个重要的类：ResponseBody，httpStream，RealConnection。上传流程如下：

1，RealConnection负责Socket连接，并从连接中得到输入流对象。

2，在httpStream中得到RealConnection的输入流对象，并创建ResponseBody对象，就输入流创建传递到ResponseBody对象中。

3，ResponseBody中提供了从输入流对象中得到数据的方法，此时就可以从ResponseBody中得到数据了。

以上三步就完成了从服务器读数据的操作。