OKHTTP基本流程分析

接触okhttp其实挺长时间了，期间呢也了解过源码，现在趁不忙来总结一下。
okhttp是一款优秀的http请求框架支持Get 和Post请求，支持基于http的文件上传下载，支持加载图片，支持下载文件透明的gzip压缩，支持超时重连与请求缓存，支持响应缓存避免重复的网络请求，支持使用连接池来降低响应延迟问题。
注：此次源码基于OK 3.8.0

ok的基本使用
 资料1
资料2

我们先从OK的基本流程开始，

    OkHttpClient client = new OkHttpClient();
    Request mRequest = new Request.Builder().url(url).build();
    Call mCall = client.newCall(mRequest);

首先创建出 OkHttpClient 的实例，通过源码我们可以看出，它是通过建造者模式来实现的，可以对整体请求的参数进行设置（如：分发器Dispatcher ，超时时间，拦截器等）。然后创建出Request的实例，最后将 Request 添加到请求中。

 public OkHttpClient() {
    this(new Builder());
  }

我们重点看请求的方法的实现:

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

其实Call是一个接口，具体的请求是通过RealCall来实现的，首先我们来看RealCall 的异步（enqueue ）方法

  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    //
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }

这里的 client 就是我们之前创建的OkHttpClient 实例。AsyncCall 间接实现了Runnable接口，通过dispatcher的enqueue方法讲runnable实例添加到线程池队列，我们接着看 dispatcher 的 enqueue 方法

  synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }

其实上面方法的操作很简单，就是将请求添加到线程池队列中，并启动线程池。到这里的时候我们发现，虽然找到了线程池，但是并没有找到具体执行网络请求的操作。其实具体的操作就在刚才的AsyncCall类中，AsyncCall为RealCall中的内部类，使用final修饰，不可被继承。

//NamedRunnable 实现了Runnable的接口 所以AsyncCall 也间接的实现类Runnable接口
final class AsyncCall extends NamedRunnable {
  ***
@Override protected void execute() {
      boolean signalledCallback = false;
      try {
        Response response = getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
          signalledCallback = true;
          responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
        } else {
          signalledCallback = true;
          responseCallback.onResponse(RealCall.this, response);
        }
      } catch (IOException e) {
        if (signalledCallback) {
          // Do not signal the callback twice!
          Platform.get().log(INFO, "Callback failure for " + toLoggableString(), e);
        } else {
          responseCallback.onFailure(RealCall.this, e);
        }
      } finally {
        client.dispatcher().finished(this);
      }
    }

  ***
}

通过以上代码我们发现只是通过一个方法便获取到了Response ，那我们看一下这个方法的具体实现

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 BridgeInterceptor(client.cookieJar()));
    //负责缓存的拦截器
    interceptors.add(new CacheInterceptor(client.internalCache()));
    //负责和服务器建立连接的拦截器
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      //配置 OkHttpClient 时设置的网络拦截器
      interceptors.addAll(client.networkInterceptors());
    }
    //负责与服务器通信的连接器（发送请求，接受响应）
    interceptors.add(new CallServerInterceptor(forWebSocket));
    
    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    return chain.proceed(originalRequest);
  }

这里就来到了我们的重点 --- 拦截器，okhttp所有的具体网络操作，缓存等都是由拦截器链来完成的，整个拦截器链采用了责任链模式，通过 RealInterceptorChain 的 proceed 方法，开始整个拦截器链的运行

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    //省略部分代码
    calls++;
    // Call the next interceptor in the chain.
    RealInterceptorChain next = new RealInterceptorChain(
        interceptors, streamAllocation, httpCodec, connection, index + 1, request);
    //从拦截器集合中获取一个拦截器， 
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);

    //省略部分代码
    return response;
  
      }

我们下接着看一下拦截器的intercept 方法，然后在对整个拦截器的工作流程进行分析，当然每个拦截器的intercept 方法中具体实现是不同的，我们调其中一个来看一下

@Override public Response intercept(Chain chain) throws IOException {
    //其实我们要看的就时这一行代码
    Response networkResponse = chain.proceed(requestBuilder.build());
    //省略部分代码
    return responseBuilder.build();
  }

现在我们结合以上代码来对整个拦截器链的工作流程进行分析，首先看RealInterceptorChain 类的 proceed方法，其实该方法是个递归方法，首先通过对index的控制来获取链中的拦截器，然后调用interceptor 的intercept方法，在intercept中又会调用新的RealInterceptorChain 实例的
proceed方法，就这样直到所有拦截器都执行后，对结果处理后返回Response。最后回到RealCall的getResponseWithInterceptorChain方法

以上就是对okhttp的整体流程的基本概况，上面呢我们是通过异步来实现的，现在再把同步任务简单说一下：

关于ok的同步任务就不上代码了，其实它与异步的不同处在于，同步并没有使用线程池，仅此而已，还是通过getResponseWithInterceptorChain方法来开启整个流程的。

如有问题，请指正