1.Http网络请求流程
- 建立连接（tcp 3次握手）
- 发送请求给服务器（头信息 body等等）
- 服务器返回数据给客户端（状态 数据等等）
- 客户端取消连接（tcp 4次挥手）
ps:服务器返回值状态码 1xx 信息，2xx成功 ，3xx重定向，4xx错误，5xx服务器错误
版本基于com.squareup.okhttp3:okhttp:3.14.7
2 .OkHttp执行流程源码解读
getResponseWithInterceptorChain（）方法完成请求，并返回数据，我们看具体步骤
- 第一步按顺序添加所有拦截器，我们可以看到，最先添加应用拦截器，而网络拦截器是在ConnectInterceptor和CallServerInterceptor中间添加的
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
//按照顺序添加所有的拦截器
List<Interceptor> interceptors = new ArrayList<>();
interceptors.addAll(client.interceptors());
interceptors.add(new RetryAndFollowUpInterceptor(client));
interceptors.add(new BridgeInterceptor(client.cookieJar()));
interceptors.add(new CacheInterceptor(client.internalCache()));
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
interceptors.addAll(client.networkInterceptors());
}
//这是最后一个拦截器
interceptors.add(new CallServerInterceptor(forWebSocket));
- 拦截器执行顺序
Interceptor.Chain chain = new RealInterceptorChain(interceptors, transmitter, null, 0,
originalRequest, this, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
boolean calledNoMoreExchanges = false;
try {
//这里看到开始执行拦截器顺序
Response response = chain.proceed(originalRequest);
我们继续看proceed方法,下面这段代码是一个递归调用，从第一个拦截器开始执行，直到最后一个拦截器结束。其实我们会从第一个拦截器的intercept方法开始调用，每次遇到realChain.proceed，又开始调用RealInterceptorChain中proceed方法，开始会对下一个拦截器调用。也就是责任链模式。
// Call the next interceptor in the chain.
RealInterceptorChain next = new RealInterceptorChain(interceptors, transmitter, exchange,
index + 1, request, call, connectTimeout, readTimeout, writeTimeout);
Interceptor interceptor = interceptors.get(index);
Response response = interceptor.intercept(next);
- 连接与发送请求
ConnectInterceptor里面初始化Exchage对象，建立socket连接
// We need the network to satisfy this request. Possibly for validating a conditional GET.
boolean doExtensiveHealthChecks = !request.method().equals("GET");
Exchange exchange = transmitter.newExchange(chain, doExtensiveHealthChecks);
我们继续看ConnectInterceptor中的方法，transmitter.newExchange中ExchangeCodec，该类子类有Http1ExchangeCodec和Http2ExchangeCodec，表示http请求的协议。方法执行到这里，我们确定了这次请求的协议。
好了，接下来就是调用最后一个拦截器了CallServerInterceptor，也就是在这里将请求头数据发送给服务器。我们看intercept里面的方法
1.准备请求头信息
exchange.writeRequestHeaders(request);
我们点进去会发现，最终是Http1ExchangeCodec类处理发送requeset请求，并且处理返回的response数据。找到请求头，我们可以看到okhttp的请求使用socket实现的，也就是说okhttp和httpurlconnection一样，同样是对socket的封装。下面是代码
//这里对请求就行了封装，socket请求包括head等信息。包括\r\n的换行等等
/** Returns bytes of a request header for sending on an HTTP transport. */
public void writeRequest(Headers headers, String requestLine) throws IOException {
if (state != STATE_IDLE) throw new IllegalStateException("state: " + state);
sink.writeUtf8(requestLine).writeUtf8("\r\n");
for (int i = 0, size = headers.size(); i < size; i++) {
sink.writeUtf8(headers.name(i))
.writeUtf8(": ")
.writeUtf8(headers.value(i))
.writeUtf8("\r\n");
}
sink.writeUtf8("\r\n");
state = STATE_OPEN_REQUEST_BODY;
}
2.请求头准备好了，socket的连接也在上一个connectintercept连接了，那就发送请求给服务器
@Override public void flushRequest() throws IOException {
sink.flush();
}
3.Socket连接与请求详细说明
1.ConnectInterceptor 拦截器，用来建立Socket连接，核心连接代码位于ExchangeFinder.findConnection()
//tcp 三次握手，建立连接
// Do TCP + TLS handshakes. This is a blocking operation.
result.connect(connectTimeout, readTimeout, writeTimeout, pingIntervalMillis,
connectionRetryEnabled, call, eventListener);
connectionPool.routeDatabase.connected(result.route());
我们在点进去，看看connetc方法
if (route.requiresTunnel()) {
//开始进行连接，如果服务器需要安全认证，则抛出异常
connectTunnel(connectTimeout, readTimeout, writeTimeout, call, eventListener);
if (rawSocket == null) {
// We were unable to connect the tunnel but properly closed down our resources.
break;
}
} else {
connectSocket(connectTimeout, readTimeout, call, eventListener);
}
无论是connectTunnel或者connectSocket，还是最后执行connectSocket方法
我们继续看看connectTunnel方法，
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
//继续点进去，到这里开始正式建立连接
socket.connect(address, connectTimeout);
2.CallServerInterceptor 再上一个拦截器执行完毕后，socket已经正式建立连接，接下来就是发送数据在这拦截器里面。在这个拦截器里面，我们准备header等信息
@Override public Response intercept(Chain chain) throws IOException {
RealInterceptorChain realChain = (RealInterceptorChain) chain;
Exchange exchange = realChain.exchange();
Request request = realChain.request();
//准备heade信息
exchange.writeRequestHeaders(request);
3.接下来重点，发送真正的请求
if (request.body() == null || !request.body().isDuplex()) {
exchange.finishRequest();
}
//continue
public void finishRequest() throws IOException {
try {
codec.finishRequest();
} catch (IOException e) {
eventListener.requestFailed(call, e);
trackFailure(e);
throw e;
}
}
//continue
//最终调用Http1ExchangeCodec中的，这里的sink.flush就是发送请求啦
@Override public void finishRequest() throws IOException {
sink.flush();
}
这里的sink是什么呢？我们去找相关的初始化方法
//在RealConntection 我们找到了初始化
ExchangeCodec newCodec(OkHttpClient client, Interceptor.Chain chain) throws SocketException {
if (http2Connection != null) {
return new Http2ExchangeCodec(client, this, chain, http2Connection);
} else {
socket.setSoTimeout(chain.readTimeoutMillis());
source.timeout().timeout(chain.readTimeoutMillis(), MILLISECONDS);
sink.timeout().timeout(chain.writeTimeoutMillis(), MILLISECONDS);
return new Http1ExchangeCodec(client, this, source, sink);
}
}
//看到这里，我们应该知道soucc sink由realconnection传入
//最终我们在这里看到，source输入流，sink输出流
source = Okio.buffer(Okio.source(socket));
sink = Okio.buffer(Okio.sink(socket));
到这里，我们就该明白sink.flush方法，也就是将我们的header信息发送给服务器，下面就是通过source读取数据了。
if (responseBuilder == null) {
responseBuilder = exchange.readResponseHeaders(false);
}
//最终我们执行到这里，读取socket流数据
private String readHeaderLine() throws IOException {
String line = source.readUtf8LineStrict(headerLimit);
headerLimit -= line.length();
return line;
}
4.总结
okhttp的请求流程整体是比较简单的，底层采用socket连接，又准备了连接池缓存，减少重复的服务器连接，有利于高并发效率。Okhttp对输入流输出流用了okio这个框架，高效也更加方便处理输入输出流，sink处理输出流，source处理输入流，内部也用了字符缓存池。
拦截器的执行顺序也是按照第一个添加的顺序依次往下执行，至于添加应用拦截器还是网络拦截器也很简单，取决于你想处理网络连接以后的数据还是连接之前的处理，前者用网络拦截器。
okhttp系统自带5个拦截器。RetryAndFollowUpInterceptor 处理网络连接失败，再次发送请求和重定向。BridgeInterceptor处理一些head信息。添加一些Connection", "Keep-Alive ，编码之类的信息。CacheInterceptor就是将返回的数据进行缓存。ConnectInterceptor拦截器连接服务器，socket连接。CallServerInterceptor发送请求信息给服务器，处理响应数据。
关于拦截器的具体实现，比如缓存拦截器处理机制没有仔细去看，应该也不难
应用开发中。我们自定义拦截器也是比较简单的，大致可以按照下面这个模板处理。处理下request response就行了、然后注意的就是你要添加应用拦截器还是网络拦截器
@Override public Response intercept(Interceptor.Chain chain) throws IOException {
//1.获取request
Request request = chain.request();
......处理
//2.获取response
Response response = chain.proceed(request);
.......处理
/3./返回response
return response;
}
