Square开源网络请求库OkHttp的工作原理解析

  /*** Prepares the {@code request} to be executed at some point in the future.*/@Override public Call newCall(Request request) {wRealCall(this, request, false /* for web socket */);}

我们可以看出wRealCall(),返回了Call对象，看下RealCall

final class RealCall implements Call {/**省略部分代码*/static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {// Safely publish the Call instance to the EventListener.RealCall call = new RealCall(client, originalRequest, forWebSocket);call.eventListener = client.eventListenerFactory().create(call);return call;}@Override public Response execute() throws IOException {/**省略部分代码*/try {client.dispatcher().executed(this);//=============关键代码==============Response result = getResponseWithInterceptorChain();if (result == null) throw new IOException("Canceled");return result;} catch (IOException e) {eventListener.callFailed(this, e);throw e;} finally {client.dispatcher().finished(this);}/**省略部分代码*/}

可以看出RealCall 实现了 Call接口，静态方法newRealCall初始化一个RealCall对象，并且有一个execute()方法，这个方法返回值就是Response 对象，也就是说，我们调用wCall(request).execute()发起Request，然后返回 Response。

 Response response = getResponseWithInterceptorChain();

RealCall的execute()方法中有这样一行代码，很显然，是getResponseWithInterceptorChain()拿到了对应的Response 信息，一起看下RealCall中的这个方法

  Response getResponseWithInterceptorChain() throws IOException {// Build a full stack of interceptors.List<Interceptor> interceptors = new ArrayList<>();interceptors.addAll(client.interceptors());interceptors.add(retryAndFollowUpInterceptor);interceptors.add(new kieJar()));interceptors.add(new CacheInterceptor(client.internalCache()));interceptors.add(new ConnectInterceptor(client));if (!forWebSocket) {interceptors.addAll(clientworkInterceptors());}interceptors.add(new CallServerInterceptor(forWebSocket));Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,originalRequest, this, eventListener, tTimeoutMillis(),adTimeoutMillis(), client.writeTimeoutMillis());return chain.proceed(originalRequest);}

getResponseWithInterceptorChain方法首先把所有的interceptors封装到一个集合中，然后把这个集合作为参数，初始化RealInterceptorChain【RealInterceptorChain是拦截器链，承载所有的拦截器链，包含：所有的自定义拦截器，OK内核，所有的网络拦截器，及网络调用。】
最后执行proceed(),现在我们一步步靠近Ok请求的核心了，看下proceed方法

  public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,RealConnection connection) throws IOException {/**省略部分代码*/// Call the next interceptor in the chain.RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec,connection, index + 1, request, call, eventListener, connectTimeout, readTimeout,writeTimeout);Interceptor interceptor = (index);//=============关键代码==============Response response = interceptor.intercept(next);/**省略部分代码*/return response;}

可以看到 chain内部的proceed方法最终还是执行的interceptor.intercept()方法拿到了Response,那几回过头看下前面getResponseWithInterceptorChain()方法中都有那些interceptor

 //只看interceptorResponse getResponseWithInterceptorChain() throws IOException {// Build a full stack of interceptors.List<Interceptor> interceptors = new ArrayList<>();//client我们自己设置的interceptorinterceptors.addAll(client.interceptors());//retryAndFollowUpInterceptor：请求失败时，重试和重定向拦截器。interceptors.add(retryAndFollowUpInterceptor);//从应用程序代码到网络代码的桥梁interceptors.add(new kieJar()));//缓存拦截器 从cache中读取response和写response到 cacheinterceptors.add(new CacheInterceptor(client.internalCache()));//打开到目标服务器的连接，并继续执行下一个拦截器interceptors.add(new ConnectInterceptor(client));if (!forWebSocket) {interceptors.addAll(clientworkInterceptors());}//拦截器链中最后一个interceptor，It makes a network call to the serverinterceptors.add(new CallServerInterceptor(forWebSocket));/**省略部分代码*/}

注释很明显，最后一个CallServerInterceptor拦截器的任务是向Remote Server发起Request。又前面我们知道 调用的都是Interceptor的 intercept()方法，那最终，我们跟踪一个发起的Request到了 CallServerInterceptor的intercept方法中。

@Override public Response intercept(Chain chain) throws IOException {/*** * A concrete interceptor chain that carries the entire interceptor chain: all application* interceptors, the OkHttp core, all network interceptors, and finally the network caller.* 拦截器 链 ，ok的核心，拦截器是网咯的调用者*/RealInterceptorChain realChain = (RealInterceptorChain) chain;/*** Encodes HTTP requests and decodes HTTP responses. 编码http请求，解码http响应*/HttpCodec httpCodec = realChain.httpStream();/*** 协调 Connections 、Stream、 Calls 之间关系的类。* Connections： physical socket connections to remote servers  ：物理Socket 连接远程服务器* Streams：HTTP request/response pairs  HTTP 请求/响应对。* Calls：a logical sequence of streams, typically an initial request and its follow up requests.*  一系列的流，通常是初始请求及后续请求，推荐每个call上面所有的流，使用相同的链接。* We prefer to keep all streams of a single call on the same connection for better behavior and locality.*/StreamAllocation streamAllocation = realChain.streamAllocation();/***  HTTP套接字和流  发送和接收数据*/RealConnection connection = (RealConnection) tion();/*** HTTP请求*/Request request = quest();long sentRequestMillis = System.currentTimeMillis();/*** 开始处理请求头*/realChain.eventListener().requestHeadersStart(realChain.call());httpCodec.writeRequestHeaders(request);realChain.eventListener().requestHeadersEnd(realChain.call(), request);Response.Builder responseBuilder = null;/*** 判断请求方法 和请求body 不为空*/if (HttpMethod.hod()) && request.body() != null) {// If there's a "Expect: 100-continue" header on the request, wait for a "HTTP/1.1 100// Continue" response before transmitting the request body. If we don't get that, return// what we did get (such as a 4xx response) without ever transmitting the request body.if (responseBuilder == null) {/*** Write the request body if the "Expect: 100-continue" expectation was met.* 如果“期望:100继续”的期望得到满足，请编写请求体。*/realChain.eventListener().requestBodyStart(realChain.call());long contentLength = request.body().contentLength();CountingSink requestBodyOut =new ateRequestBody(request, contentLength));BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);request.body().writeTo(bufferedRequestBody);bufferedRequestBody.close();realChain.eventListener().requestBodyEnd(realChain.call(), requestBodyOut.successfulCount);} else if (!connection.isMultiplexed()) {// If the "Expect: 100-continue" expectation wasn't met, prevent the HTTP/1 connection// from being reused. Otherwise we're still obligated to transmit the request body to// leave the connection in a consistent NewStreams();}}httpCodec.finishRequest();if (responseBuilder == null) {realChain.eventListener().responseHeadersStart(realChain.call());responseBuilder = adResponseHeaders(false);}/*** 初始化response对象*/Response response = quest(request).tion().handshake()).sentRequestAtMillis(sentRequestMillis).receivedResponseAtMillis(System.currentTimeMillis()).build();/*** 响应头*/realChain.eventListener().responseHeadersEnd(realChain.call(), response);int code = de();if (forWebSocket && code == 101) {/***Connection is upgrading, but we need to ensure interceptors see a non-null response body.连接正在升级，但是我们需要确保拦截器看到一个非空响应体*/response = wBuilder().body(Util.EMPTY_RESPONSE).build();} else {/*** 最终执行到这里将response对象，构建完成，然后返回* 构建response 的ResponseBody*/response = wBuilder().body(httpCodec.openResponseBody(response)).build();}//===========删除部分代码========================return response;}

这个方法比较重要，所以要看仔细一点，由此，我们可以得到我们想要的结果了。

结论

一个Request的发起到接收Response 经历的过程：
首先构建OkHttpClient 对象，接下来使用构建好的Request作为参数传递给OkHttpClient 的newCall() 生成RealCall 对象，然后执行call的execute方法，最终这个方法内部通过CallServerInterceptor返回了Response，Response 封装了服务器返回的数据。

大体流程就是这样，更多细节与流程图稍后补充。