okhttp3.6.0源码分析系列文章整体内容如下：

okhttp3.6.0源码分析准备2——java知识

okhttp3.6.0源码分析1——Call

okhttp3.6.0源码分析2——拦截器

okhttp3.6.0源码分析3——建立socket连接

okhttp3.6.0源码分析4——连接池

一 okhttp默认的拦截器

okhttp默认执行的拦截器有五个:

RetryAndFollowUpInterceptor 重定向拦截器
BridgeInterceptor 该拦截器是链接客户端代码和网络代码的桥梁，它首先将客户端构建的Request对象信息构建成真正的网络请求;然后发起网络请求，最后是将服务器返回的消息封装成一个Response对象。
CacheInterceptor 缓存拦截器
ConnectInterceptor 打开与服务器的连接
CallServerInterceptor 开启与服务器的网络请求

1.1 拦截器调用

不管是同步请求还是异步请求都会调用

Response response = getResponseWithInterceptorChain();

来获取网络请求内容，下面来看下getResponseWithInterceptorChain()里面是如何实现的:

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));
    //将拦截器封装成InterceptorChain，注意 时候 index为0
    Interceptor.Chain chain = new RealInterceptorChain(
        interceptors, null, null, null, 0, originalRequest);
    return chain.proceed(originalRequest);
  }

从getResponseWithInterceptorChain方法返回时调用的chain.proceed(originalRequest)开始分析，该方法调用RealInterceptorChain的procees方法：

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); //构造一个RealInterceptorChain，新的RealInterceptorChain的index为1
    Interceptor interceptor = interceptors.get(index); //传入的index为0，所以为调用第一个拦截器，假如没有没有添加自定义的拦截器，interceptor是RetryAndFollowUpInterceptor
    Response response = interceptor.intercept(next); //调用的是RetryAndFollowUpInterceptor里的intercept方法
    return response;
  }

RetryAndFollowUpInterceptor中intercept方法:

  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();

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

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

      Response response = null;
      boolean releaseConnection = true;
      try {
       // 再次调用 RealInterceptorChain的proceed方法，注意这里streamAllocation不为null
        response = ((RealInterceptorChain) chain).proceed(request, streamAllocation, null, null);
      priorResponse = response;
    }
  }

再次进入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); //构造一个RealInterceptorChain，新的RealInterceptorChain的index为2
    Interceptor interceptor = interceptors.get(index); //传入的index为1，所以为调用第二个拦截器，假如没有没有添加自定义的拦截器，interceptor是BridgeInterceptor 
    Response response = interceptor.intercept(next); //调用的是BridgeInterceptor 里的intercept方法
    return response;
  }

进入BridgeInterceptor 里的intercept方法：

@Override public Response intercept(Chain chain) throws IOException {
    Request userRequest = chain.request();
    Request.Builder requestBuilder = userRequest.newBuilder();
    //对请求报文进行处理
    RequestBody body = userRequest.body();
    if (body != null) {
      MediaType contentType = body.contentType();
      if (contentType != null) {
        requestBuilder.header("Content-Type", contentType.toString());
      }

      long contentLength = body.contentLength();
      if (contentLength != -1) {
        requestBuilder.header("Content-Length", Long.toString(contentLength));
        requestBuilder.removeHeader("Transfer-Encoding");
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked");
        requestBuilder.removeHeader("Content-Length");
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", hostHeader(userRequest.url(), false));
    }

    if (userRequest.header("Connection") == null) {
      requestBuilder.header("Connection", "Keep-Alive");
    }

    // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
    // the transfer stream.
    boolean transparentGzip = false;
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true;
      requestBuilder.header("Accept-Encoding", "gzip");
    }

    List<Cookie> cookies = cookieJar.loadForRequest(userRequest.url());
    if (!cookies.isEmpty()) {
      requestBuilder.header("Cookie", cookieHeader(cookies));
    }

    if (userRequest.header("User-Agent") == null) {
      requestBuilder.header("User-Agent", Version.userAgent());
    }
     //到这里为止又会进行新的回调，会再次进入RealInterceptorChain方法中去
    Response networkResponse = chain.proceed(requestBuilder.build());

//下面的代码会在上面的回调出栈之后才会调用，那时候网络请求已经完成，已经得到网络相应内容，这时候对响应报文进行处理
    HttpHeaders.receiveHeaders(cookieJar, userRequest.url(), networkResponse.headers());

    Response.Builder responseBuilder = networkResponse.newBuilder()
        .request(userRequest);

    if (transparentGzip
        && "gzip".equalsIgnoreCase(networkResponse.header("Content-Encoding"))
        && HttpHeaders.hasBody(networkResponse)) {
      GzipSource responseBody = new GzipSource(networkResponse.body().source());
      Headers strippedHeaders = networkResponse.headers().newBuilder()
          .removeAll("Content-Encoding")
          .removeAll("Content-Length")
          .build();
      responseBuilder.headers(strippedHeaders);
      responseBuilder.body(new RealResponseBody(strippedHeaders, Okio.buffer(responseBody)));
    }

    return responseBuilder.build();
  }

BridgeInterceptor 中的 chain.proceed(requestBuilder.build());放在intercept方法request信息组装成功之后，这样等到请求结束，就可以在拿到response之后对响应内容进行处理了，这种实现方式太优雅了。
在运行proceed方法时又会跳转到RealInterceptorChain的procees方法：

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); //构造一个RealInterceptorChain，新的RealInterceptorChain的index为3
    Interceptor interceptor = interceptors.get(index); //传入的index为2，所以为调用第三个拦截器，假如没有没有添加自定义的拦截器，interceptor是CacheInterceptor
    Response response = interceptor.intercept(next); //调用的是CacheInterceptor里的intercept方法
    return response;
  }

CacheInterceptor里的intercept方法：

@Override public Response intercept(Chain chain) throws IOException {
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();

    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;

    if (cache != null) {
      cache.trackResponse(strategy);
    }

    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body()); // The cache candidate wasn't applicable. Close it.
    }

    // If we're forbidden from using the network and the cache is insufficient, fail.
    if (networkRequest == null && cacheResponse == null) {
      return new Response.Builder()
          .request(chain.request())
          .protocol(Protocol.HTTP_1_1)
          .code(504)
          .message("Unsatisfiable Request (only-if-cached)")
          .body(Util.EMPTY_RESPONSE)
          .sentRequestAtMillis(-1L)
          .receivedResponseAtMillis(System.currentTimeMillis())
          .build();
    }

    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }

    Response networkResponse = null;
    try {
      networkResponse = chain.proceed(networkRequest);
    } finally {
      // If we're crashing on I/O or otherwise, don't leak the cache body.
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }

    // If we have a cache response too, then we're doing a conditional get.
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
            .headers(combine(cacheResponse.headers(), networkResponse.headers()))
            .sentRequestAtMillis(networkResponse.sentRequestAtMillis())
            .receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
        networkResponse.body().close();

        // Update the cache after combining headers but before stripping the
        // Content-Encoding header (as performed by initContentStream()).
        cache.trackConditionalCacheHit();
        cache.update(cacheResponse, response);
        return response;
      } else {
        closeQuietly(cacheResponse.body());
      }
    }

    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();

    if (cache != null) {
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }

      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

    return response;
  }

networkResponse = chain.proceed(networkRequest);
proceed方法之前的部分是若是配置了缓存策略，并且有缓存，则直接取出，不再进行网络请求，链式调用也终止。
proceed方法执行之后的部分会根据缓存策略，对网络相应内容进行存储。
在调用chain.proceed时，再次进入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); //构造一个RealInterceptorChain，新的RealInterceptorChain的index为4
    Interceptor interceptor = interceptors.get(index); //传入的index为3，所以为调用第四个拦截器，假如没有没有添加自定义的拦截器，interceptor是ConnectInterceptor 
    Response response = interceptor.intercept(next); //调用的是ConnectInterceptor 里的intercept方法
    return response;
  }

ConnectInterceptor 里的intercept方法：

@Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Request request = realChain.request();
   //获取在RetryAndFollowUpInterceptor中构建的streamAllocation
    StreamAllocation streamAllocation = realChain.streamAllocation();

    // We need the network to satisfy this request. Possibly for validating a conditional GET.
    boolean doExtensiveHealthChecks = !request.method().equals("GET");
    //构建HttpCodec 对象
    HttpCodec httpCodec = streamAllocation.newStream(client, doExtensiveHealthChecks);
    //构建RealConnection 对象
    RealConnection connection = streamAllocation.connection();

    return realChain.proceed(request, streamAllocation, httpCodec, connection);
  }

ConnectInterceptor 里的intercept方法比较少，主要是为下一步网络请求做准备；
方法结束时调用realChain.proceed再次进入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); //构造一个RealInterceptorChain，新的RealInterceptorChain的index为5
    Interceptor interceptor = interceptors.get(index); //传入的index为4，所以为调用第五个拦截器，假如没有没有添加自定义的拦截器，interceptor是CallServerInterceptor，这也是最后一个拦截器
    Response response = interceptor.intercept(next); //调用的是ConnectInterceptor 里的intercept方法
    return response;
  }

 @Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    HttpCodec httpCodec = realChain.httpStream();
    StreamAllocation streamAllocation = realChain.streamAllocation();
    RealConnection connection = (RealConnection) realChain.connection();
    Request request = realChain.request();

    long sentRequestMillis = System.currentTimeMillis();
    httpCodec.writeRequestHeaders(request);

    Response.Builder responseBuilder = null;
    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.
      if ("100-continue".equalsIgnoreCase(request.header("Expect"))) {
        httpCodec.flushRequest();
        responseBuilder = httpCodec.readResponseHeaders(true);
      }

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

    httpCodec.finishRequest();

    if (responseBuilder == null) {
      responseBuilder = httpCodec.readResponseHeaders(false);
    }

    Response response = responseBuilder
        .request(request)
        .handshake(streamAllocation.connection().handshake())
        .sentRequestAtMillis(sentRequestMillis)
        .receivedResponseAtMillis(System.currentTimeMillis())
        .build();

    int code = response.code();
    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 {
      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 new ProtocolException(
          "HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
    }

    return response;
  }

将请求报文通过socket传到服务端，读取响应报文，然后返回，终止链式调用。一层一层返回。

二用户自定义拦截器

除了okhttp自定义的拦截器之外，用户也可以给自定义拦截器。
自定义的拦截器分为两种：

应用层拦截器，使用场景是：

Don't need to worry about intermediate responses like redirects and retries.
Are always invoked once, even if the HTTP response is served from the cache.
Observe the application's original intent. Unconcerned with OkHttp-injected headers like If-None-Match.
Permitted to short-circuit and not call Chain.proceed().
Permitted to retry and make multiple calls to Chain.proceed().

网络层拦截器，使用场景是：

Able to operate on intermediate responses like redirects and retries.
Not invoked for cached responses that short-circuit the network.
Observe the data just as it will be transmitted over the network.
Access to the Connection that carries the request.

拦截器添加的源码如下：

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

拦截器执行流程如下所示：

拦截器执行流程

上面的这些使用场景结合源码看就很容易理解了。

2.1 应用层拦截器

client.interceptors获取的拦截器就是应用层的拦截器，会在所有拦截器之前处理request，这时候的request是没有被系统拦截器修改过的。
如果要拦截网络异常并上报，那么应该使用这类拦截器。

2.2 网络层拦截器

client.networkInterceptions()返回的是网络层拦截器，可以看出它拿到的request可能会被重定向，而且如果开启了网络缓存，那么是这类拦截器将不会被调用。因为他是最后被调用的，所以它能拿到最终被传输的请求，也是我们最后能够处理请求的机会。
facebook的stetho定义的拦截器StethoInterceptor就是一种网络层连接器：

new OkHttpClient.Builder()
    .addNetworkInterceptor(new StethoInterceptor())
    .build();

（完）

okhttp3.6.0源码分析2——拦截器

一 okhttp默认的拦截器

1.1 拦截器调用

二 用户自定义拦截器

2.1 应用层拦截器

2.2 网络层拦截器

二用户自定义拦截器