OKHttp框架图：

OkHttp源码大概流程

这个图片是从拆轮子系列：拆 OkHttp，大神对Okhttp源码分析，他分析得特别好，推荐是看的博文。我只是结合他的总结，然后总结成自己的东西，写一下，希望可以对okhttp更进一步了解。
源码有很多地方值得我们去学习。

一、Builder模式

OKHttpClient，Request，Response等大量的使用这个模式，这些类都需要大量的参数，所以使用Builder模式是很好的设计

• 1、这个模式可以避免构造方法需要传入大量的参数，相比使用setting的方式设置参数，使用Builder更加清晰。
• 2、如果有大量的参数，可能会有多个构造方法，有一些默认的参数，这样很容易使用了不对的构造方法。
• 3、虽然增加了不少代码量，但是客户端的调用非常的清晰
  Builer模式的分析

二、使用队列管理请求，实现高并发

相应的类RealCall、Dispatcher
Dispatcher内部管理了三个队列

三个队列

同时Dispatcher设置了最大请求数64，设置了最大Host5
使用Dispatcher的finished方法控制队列
将线程管理、线程池放在Dispatcher里面进行管理，RealCall、AsyncCall负责执行的逻辑。

同步excute的调用

异步调用A'syncCall最后的调用

不论是同步还是异步，最后都是调用getResponseWithInterceptorChain()

三、责任链模式

OKHttp把责任链模式设计在最核心的地方，每一个请求会有连接、请求、处理返回等等一系列的任务。在OKHttp中已拦截器作为每个责任的任务Interceptor

Interceptor

然后关联到Chain的链条上，在Interceptor的每个intercept中，在执行Chain的proceed方法，知道Chain中没有任务。
getResponseWithInterceptorChain

Interceptors

Interceptors

3.1 RetryAndFollowUpInterceptor

重试重定向拦截器，不断判断返回数据，有问题重试或者重定向
会判断后面拦截器返回的response的值，看是否请求完成，或者需要重定向或者重试
RetryAndFollowUpInterceptor的详细分析

3.2 BridgeInterceptor

Bridges from application code to network code. First it builds a network request from a *user request. Then it proceeds to call the network. Finally it builds a user response *from the network response.

将应用代码转换成网络代码，对用户发送请求的数据进行校验并矫正；同时网络请求返回的数据进行处理，处理为用户希望也是用户能够理解的数据。
BridgeInterceptor源码 主要看intercept方法
chain.proceed调用之前是对请求数据进行转换，调用之后是对请求返回数据进行转换

3.3 CacheInterceptor 缓存拦截器

/** Serves requests from the cache and writes responses to the cache. */

读取缓存和写入更新缓存
缓存机制

3.4 ConnectInterceptor

ConnectInterceptor

看似简单
StreamAllocation 分配流，他实际上是在RetryAndFollowUpInterceptor中创建的，那时候它负责把创建的对象传给chain，如果需要重定向就会重新创建，在这个拦截器中，从其中获取连接，获取编解码器
RealConnection 真是连接，通过streamAllocation寻找可用连接
HttpCodec Http编解码
别人详细的分析
将获取到的内容传给后续的拦截器，获取到返回之后直接返回给前面的拦截器，没有做进一步的处理。

3.5 networkInterceptors

这些是在请求的时候设置的拦截器

3.6 CallServerInterceptor

最后一个拦截器，也是最重要的拦截器，response就是在这个拦截器中通过网络请求获取到的。

@OverridepublicResponse intercept(Chain chain)throwsIOException {
  RealInterceptorChain realChain = (RealInterceptorChain) chain;
  HttpCodec httpCodec = realChain.httpStream();
  StreamAllocation streamAllocation = realChain.streamAllocation();
  RealConnection connection = (RealConnection) realChain.connection();
  Request request = realChain.request();
  longsentRequestMillis = System.currentTimeMillis();
  //写入头部
  httpCodec.writeRequestHeaders(request);
  Response.Builder responseBuilder =null;
  //请求是否有body
  if(HttpMethod.permitsRequestBody(request.method()) && 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.
    //头部是否有100-continue，有的话等待response
    if("100-continue".equalsIgnoreCase(request.header("Expect"))) {
      httpCodec.flushRequest();
      responseBuilder = httpCodec.readResponseHeaders(true);
    }

    //没有100-continue 
    if(responseBuilder ==null) {
      // Write the request body if the "Expect: 100-continue" expectation was met.
      Sink requestBodyOut = httpCodec.createRequestBody(request, request.body().contentLength());
      BufferedSink bufferedRequestBody = Okio.buffer(requestBodyOut);
      //写入body
      request.body().writeTo(bufferedRequestBody);
      bufferedRequestBody.close();
    }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 state.
      streamAllocation.noNewStreams();
    }
  }

  //完成request写入
  httpCodec.finishRequest();
  if(responseBuilder ==null) {
    //读取头部，并返回response
    responseBuilder = httpCodec.readResponseHeaders(false);
  }
  //创建response
  Response response = responseBuilder
    .request(request)
    .handshake(streamAllocation.connection().handshake())
    .sentRequestAtMillis(sentRequestMillis)
    .receivedResponseAtMillis(System.currentTimeMillis())
    .build();
  
  intcode = response.code();
  //根据类型更新response属性
  if(forWebSocket&& code ==101) {
  // Connection is upgrading, but we need to ensure interceptors see a non-null response body.
    response = response.newBuilder()
        .body(Util.EMPTY_RESPONSE)
        .build();
  }else{
    //读取body
    response = response.newBuilder()
      .body(httpCodec.openResponseBody(response))
      .build();
  }
  
  //请求是否要求关闭连接
  if("close".equalsIgnoreCase(response.request().header("Connection"))
      ||"close".equalsIgnoreCase(response.header("Connection"))) {
    streamAllocation.noNewStreams();
  }
  
  if((code ==204|| code ==205) && response.body().contentLength() >0) {
      throw newProtocolException(
        "HTTP "+ code +" had non-zero Content-Length: "+     response.body().contentLength());
  }
  return response;
}

继续总结中......