0.前言

欢迎阅读笔者文章，本文是OkHttp源码解析系列文章的第二篇，如果没看过上一篇文章的，请转OkHttp源码分析之（一）请求流程,有什么不足的地方，记得提出来哦，您的支持，是对我写作的最大支持。
皮一下：笔者在android技术上遇到瓶颈了，但是通过这几个星期对框架源码的学习，终于得到突破了，强烈推荐在技术上遇到瓶颈的童鞋尝试阅读下流行框架的源码。这玩意，还很容易上瘾>_<

1.Dispatcher

在上一篇文章中，已经对Dispatcher里面的部分方法进行了解析，在这里，我将站在总体的角度上对其进行一个总结。
（1）Dispatcher做了什么？
先来看看Dispatcher里面定义的参数：

public final class Dispatcher {
  private int maxRequests = 64;
  private int maxRequestsPerHost = 5;
  private @Nullable Runnable idleCallback;

  /** Executes calls. Created lazily. */
  private @Nullable ExecutorService executorService;

  /** 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<>();

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

}

可以看到，Dispatcher里面维护了三个请求队列：同步请求队列、异步请求就绪队列、异步请求正在执行队列，没错，Dispatcher就干维护这三个请求队列、处理所有请求这两件事。
（2）Dispatcher为什么要维护这三个队列？
这个问题好解释，还是回到上一节讲到的网略请求部分，先看看同步请求：

@Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    timeout.enter();
    eventListener.callStart(this);
    try {
      client.dispatcher().executed(this);//代码1,入队
      Response result = getResponseWithInterceptorChain();
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      e = timeoutExit(e);
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);//代码2，出队
    }
  }
/**Dispatcher中**/

//代码1
 /** Used by {@code Call#execute} to signal it is in-flight. */
  synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

//代码2
 /** Used by {@code Call#execute} to signal completion. */
  void finished(RealCall call) {
    finished(runningSyncCalls, call);
  }

 private <T> void finished(Deque<T> calls, T call) {
    Runnable idleCallback;
    synchronized (this) {
      if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
      idleCallback = this.idleCallback;
    }

    boolean isRunning = promoteAndExecute();

    if (!isRunning && idleCallback != null) {
      idleCallback.run();
    }
  }

//重点代码
 private boolean promoteAndExecute() {
    assert (!Thread.holdsLock(this));

    List<AsyncCall> executableCalls = new ArrayList<>();
    boolean isRunning;
    synchronized (this) {
      //遍历就绪异步请求队列（有异步请求时才会执行）
      for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
        AsyncCall asyncCall = i.next();//从就绪队列中取出请求

        if (runningAsyncCalls.size() >= maxRequests) break; // Max capacity.//如果正在运行的异步请求没有超限
        if (runningCallsForHost(asyncCall) >= maxRequestsPerHost) continue; // Host max capacity.//并且Host请求没有大于最大数

        i.remove();//从就绪队列中移除掉异步请求
        executableCalls.add(asyncCall);//将其添加至可执行的队列中
        runningAsyncCalls.add(asyncCall);//添加至正在执行的异步请求队列中
      }
      isRunning = runningCallsCount() > 0;//重新计算正在执行的队列数
    }
    
    //具体调用执行异步操作的方法（有异步请求时才会执行）
    for (int i = 0, size = executableCalls.size(); i < size; i++) {
      AsyncCall asyncCall = executableCalls.get(i);
      asyncCall.executeOn(executorService());
    }

    return isRunning;
  }

代码在上一篇文章中已经解析过，这里就不解析了，主要看代码1和代码2，同步请求主要就干了两件事：入队和出队，这里重点还是promoteAndExecute（）方法，当执行同步请求是，在上一步重正在执行的同步请求队列中移除掉请求之后，这里仅仅是重新计算正在执行的队列数（等于runningAsyncCalls.size() + runningSyncCalls.size()）；如果是异步请求，则会执行注释中的代码，其中重要的一点就是当runningAsyncCalls.size()超额时仅会把请求放到就绪的异步请求队列（readyAsyncCalls）中（breake了），而这里，则是当runningAsyncCalls小于maxRequests时（有空位了），将异步请求从就绪队列readyAsyncCalls中取出来放到runningAsyncCalls之中。
因此，Dispatcher才需要维护这三个队列。
关于Dispatcher就介绍到这里，接下来介绍下OkHttp另一核心内容：拦截器

2.拦截器

啥？什么拦截器？我怎么没听说过呀？
别紧张，先来看看拦截器的是什么。
拦截器是什么？官网的解释是：

Interceptors are a powerful mechanism that can monitor, rewrite, and retry calls.
拦截器是OkHttp中提供的一种强大机制，可以实现网略监听、重写和请求、请求失败重试等功能。
官网

顺便附上官网提供的图：

interceptors@2x.png

由官方解释可见拦截器是不管同步还是异步请求都会执行的。
关于拦截器的分析，由于代码实在是太多了，由于篇幅关系，无法进行详细解释，但是流程还是要有的，做了什么也是要交代清楚的，于是，在这里，我就简单讲讲这厮做了什么。
（1）流程
首先还是从RealCall的代码中入手（execute中和Async里面的execute，同步异步都会执行），这里举个栗子就从同步请求入手吧：

 @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    timeout.enter();
    eventListener.callStart(this);
    try {
      client.dispatcher().executed(this);
      Response result = getResponseWithInterceptorChain();//重点
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      e = timeoutExit(e);
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);
    }
  }

重点就是getResponseWithInterceptorChain（）方法，来看看它做了什么：

 Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    //包含所有拦截器的List
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());//将用户定义的拦截器添加进来，即上图中的Application拦截器
    //添加OkHttp内部的五大拦截器
    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, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

可以看到，先是将用户自定义的拦截器添加进拦截器列表中，后又将OkHttp内部的五个拦截器分别添加进去，这五个拦截器分别：

• retryAndFollowUpInterceptor:重试和失败重定向拦截器
• BridgeInterceptor：桥接适配器拦截器
• CacheInterceptor：缓存拦截器
  这两个拦截器主要负责补充请求头等信息和处理缓存。
• ConnectInterceptor：连接拦截器。负责连接。
• CallServerInterceptor：服务响应拦截器。负责将Http请求写入到网略中，并从网略IO流中读取数据返回给客户端。
  接下来是重点，这里为什么说是拦截器链呢？请往下看RealInterceptorChain：

 private final List<Interceptor> interceptors;
  private final StreamAllocation streamAllocation;
  private final HttpCodec httpCodec;
  private final RealConnection connection;
  private final int index;
  private final Request request;
  private final Call call;
  private final EventListener eventListener;
  private final int connectTimeout;
  private final int readTimeout;
  private final int writeTimeout;
  private int calls;

  public RealInterceptorChain(List<Interceptor> interceptors, StreamAllocation streamAllocation,
      HttpCodec httpCodec, RealConnection connection, int index, Request request, Call call,
      EventListener eventListener, int connectTimeout, int readTimeout, int writeTimeout) {
    this.interceptors = interceptors;
    this.connection = connection;
    this.streamAllocation = streamAllocation;
    this.httpCodec = httpCodec;
    this.index = index;
    this.request = request;
    this.call = call;
    this.eventListener = eventListener;
    this.connectTimeout = connectTimeout;
    this.readTimeout = readTimeout;
    this.writeTimeout = writeTimeout;
  }

构造方法主要初始化了一些数据，这里不多讲，关键在于它的proceed方法：

 @Override public Response proceed(Request request) throws IOException {
    return proceed(request, streamAllocation, httpCodec, connection);
  }

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec,
      RealConnection connection) throws IOException {
    if (index >= interceptors.size()) throw new AssertionError();

    calls++;

    // If we already have a stream, confirm that the incoming request will use it.
    if (this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must retain the same host and port");
    }

    // If we already have a stream, confirm that this is the only call to chain.proceed().
    if (this.httpCodec != null && calls > 1) {
      throw new IllegalStateException("network interceptor " + interceptors.get(index - 1)
          + " must call proceed() exactly once");
    }

    //重点1：index + 1，即下一个拦截器
    // 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 = interceptors.get(index);
    Response response = interceptor.intercept(next);//将下一个拦截器传递进去

    // Confirm that the next interceptor made its required call to chain.proceed().
    if (httpCodec != null && index + 1 < interceptors.size() && next.calls != 1) {
      throw new IllegalStateException("network interceptor " + interceptor
          + " must call proceed() exactly once");
    }

    // Confirm that the intercepted response isn't null.
    if (response == null) {
      throw new NullPointerException("interceptor " + interceptor + " returned null");
    }

    if (response.body() == null) {
      throw new IllegalStateException(
          "interceptor " + interceptor + " returned a response with no body");
    }

    return response;
  }

这里重要的一点就是indext+1，表示只能访问下一个拦截器，这样就把所有的拦截器连接起来成为一条链了。
总结起来，getResponseWithInterceptorChain做了两件事：

• 将五大拦截器添加进List中
• 创建拦截器链RealInterceptorChain，并执行proceed方法
  而具体的拦截器里面执行的其实也是下一个拦截器的proceed方法，这里以RetryAndFollowUpInterceptor未来，看看他里面的intercept方法：

@Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Call call = realChain.call();
    EventListener eventListener = realChain.eventListener();

    StreamAllocation streamAllocation = new StreamAllocation(client.connectionPool(),
        createAddress(request.url()), call, eventListener, callStackTrace);
    this.streamAllocation = streamAllocation;

    int followUpCount = 0;
    Response priorResponse = null;
    while (true) {
      if (canceled) {
        streamAllocation.release();
        throw new IOException("Canceled");
      }

      Response response;
      boolean releaseConnection = true;
      try {
        response = realChain.proceed(request, streamAllocation, null, null);//重点，代码1
        releaseConnection = false;
      } catch (RouteException e) {
        // The attempt to connect via a route failed. The request will not have been sent.
        if (!recover(e.getLastConnectException(), streamAllocation, false, request)) {
          throw e.getFirstConnectException();
        }
        releaseConnection = false;
        continue;
      } catch (IOException e) {
        // An attempt to communicate with a server failed. The request may have been sent.
        boolean requestSendStarted = !(e instanceof ConnectionShutdownException);
        if (!recover(e, streamAllocation, requestSendStarted, request)) throw e;
        releaseConnection = false;
        continue;
      } finally {
        // We're throwing an unchecked exception. Release any resources.
        if (releaseConnection) {
          streamAllocation.streamFailed(null);
          streamAllocation.release();
        }
      }

      // Attach the prior response if it exists. Such responses never have a body.
      if (priorResponse != null) {
        response = response.newBuilder()
            .priorResponse(priorResponse.newBuilder()
                    .body(null)
                    .build())
            .build();
      }

      Request followUp;
      try {
        followUp = followUpRequest(response, streamAllocation.route());
      } catch (IOException e) {
        streamAllocation.release();
        throw e;
      }

      if (followUp == null) {
        streamAllocation.release();
        return response;
      }

      closeQuietly(response.body());

      if (++followUpCount > MAX_FOLLOW_UPS) {
        streamAllocation.release();
        throw new ProtocolException("Too many follow-up requests: " + followUpCount);
      }

      if (followUp.body() instanceof UnrepeatableRequestBody) {
        streamAllocation.release();
        throw new HttpRetryException("Cannot retry streamed HTTP body", response.code());
      }

      if (!sameConnection(response, followUp.url())) {
        streamAllocation.release();
        streamAllocation = new StreamAllocation(client.connectionPool(),
            createAddress(followUp.url()), call, eventListener, callStackTrace);
        this.streamAllocation = streamAllocation;
      } else if (streamAllocation.codec() != null) {
        throw new IllegalStateException("Closing the body of " + response
            + " didn't close its backing stream. Bad interceptor?");
      }

      request = followUp;
      priorResponse = response;
    }
  }

重点看代码1，由前面分析可知，这里执行的是下一个拦截器的intercept，而下一个拦截器的intercept又会执行realChain.proceed，由此形成连接，将所有拦截器连接起来。
嘛，流程图还是要有的：

getResponseWithInterceptorChain (1).png