1.OkHttp的简单使用

一般情况下，对于网络框架有两种常见的使用场景，同步请求和异步请求。
同步请求：

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
Call call = client.newCall(request);
Response response = call.execute();

异步请求：

OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url("http://www.baidu.com").build();
client.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {

    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {

    }
});

上面代码比较简单，并不是本文的重点。旨在抛砖引玉...

2.OkHttp内部相关类的介绍

• OkHttpClient：Okhttp的主类，一般情况下设计成单列使用。
• Request：OkHttp的请求类，可以分装了请求消息头，消息实体相关的信息
• Response：OkHttp的响应类，分装了相应码，相应实体相关的信息
• Call：对于OkHttp来说，一个call对应一次网络请求操作
• RealCall：Call接口的真正实现
• AsyncCall：当执行的时移步请求时，会转化成AsyncCall，它实现Runnable接口，是对RealCall的再次封装
• Dispatcher：用来分发请求任务的类
• RetryAndFollowUpInterceptor：负责重连和重定向的拦截器
• BridgeInterceptor：桥拦截器，处理请求头
• CacheInterceptor：缓存拦截器
• ConnectInterceptor：连接拦截器
• CallServerInterceptor：服务相应拦截器

3.OkHttp内部执行流程介绍

同步请求流程：
当一次同步请求被执行时，会先调用RealCall的excute方法

  @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } finally {
      client.dispatcher().finished(this);
    }
  }

这个方法的作用是先对同步请求进行分发，调用的Diapatcher的excuted方法，这个方法只是将请求缓存到dispatcher的runningSyncCalls的队列集合中，然后调用RealCall自己的getResponseWithInterceptorChain方法，这是整体OkHttp最为核心的方法，这个一个拦截器链，它将一层层过滤请求，最终返回响应，然后在调用dispatcher的finished方法，就是从runningSyncCalls队列集合中将请求剔除。这就是一次完整的okhttp的同步请求。

异步请求流程：
当一次异步请求被执行时，会先调用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));
  }

这个方法的作用时判断这个请求是否已经被执行了，如果没有被执行，会将这个RealCall转化成AsyncCall对象，然后把他交给dispatcher类进行分发，dispather对象中有两个队列集合跟异步请求有关系。

/** Ready async calls in the order they'll be run. */
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

这两个队列集合从名字上就可以看出一个是准备去执行的异步请求，一个时正在执行中的异步请求。dsipather的enqueue方法会对异步请求做进一步处理

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

这个方法的逻辑很清晰，如果超过最大任务数量64个，或者同一个域名任务数5个，它将进入准备队列，反之将进入执行队列，交由线程池执行。因为AsyncCall继承了NamedRunnable类，而NamedRunnable类实现了Runnable接口，所以最终的执行方法在AsyncCall的execute的方法。

@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);
      }
    }

这个方法的逻辑的核心还是getResponseWithInterceptorChai这个方法，根据这个方法的返回回调Callback接口实现，然后在Dispatcher中的集合中剔除。

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) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    return chain.proceed(originalRequest);
  }

这个就是getResponseWithInterceptorChain的方法实现，这个就是一个责任链设计的拦截器链，每个拦截器层层处理。

以上就是okhttp内部的大致使用流程。