Okhttp源码分析

2021-01-13

OkHttp的简介与使用

简介：OkHttp是square公司开源出来的一个优秀的网络请求框架。Android4.4开始HttpUrlConnection的底层实现采用的就是okhttp。

主页: https://github.com/square/okhttp

特点:

支持HTTP/2 和 SPDY
默认支持 GZIP 降低传输内容的大小
支持网络请求的缓存
当网络出现问题时,自动重试一个主机的多个 IP 地址

使用步骤

* 使用步骤:
1. 创建OkHttpClient对象
2. 创建Request对象
3. 添加Request对象到OkHttpClient对象中并执行请求.示例代码:

//创建OkHttpClient对象
OkHttpClient client=new OkHttpClient();


//get请求
Request request = new Request.Builder()
        .get()
        .url("https: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 {	// 请求成功的处理
        
    }
});




//post请求
RequestBody body = new FormBody.Builder()
        .add("phone", "xxxxxxxxxxxxxx")// 构造请求的参数
        .add("key", "xxxxxxxxxxxxxxxxxxxxx")// 构造请求的参数
        .build();
Request post_request = new Request.Builder()
        .url(URL_POST)// 指定请求的地址
        .post(body)// 指定请求的方式为POST
        .build();
//异步调用
client.newCall(post_request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 请求失败的处理
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {	// 请求成功的处理
        ResponseBody body = response.body();
        String string = body.string();// 把返回的结果转换为String类型
		// body.bytes();// 把返回的结果转换为byte数组
		// body.byteStream();// 把返回的结果转换为流
    }
});

分发器

OkHttp其实主要就是两部分：分发器和拦截器。分发器内部维护队列与线程池，完成请求调配。

我们根据使用流程来看一下，首先client.newCall(request)返回的是一个RealCall对象，也就是说client.newCall(post_request).enqueue()其实调用的就是RealCall的enqueue方法。

//RealCall 类
@Override public void enqueue(Callback responseCallback) {
  //同一个RealCall对象，只能调用一次enqueue方法，否则抛异常
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    //将AsyncCall交给分发器，假如我们没有自定义分发器，则用的默认的Dispatcher
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
}

执行请求最终是通过Dispatcher类来调用的，Dispatcher就是OkHttp的分发器。

//Dispatcher 类
synchronized void enqueue(AsyncCall call) {
    //maxRequests 64  正在执行的队列大小<64  客户端压力
    //maxRequestsPerHost 5  相同host请求不能超过5个  服务器压力
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      //放入线程池
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
}

Dispatcher类维护了两个队列，readyAsyncCalls等待执行的队列，runningAsyncCalls正在执行的队列。
采用ArrayDeque，但是目前来说没有用到双向的操作，也许为了以后的扩展吧。

Dispatcher还维护了一个线程池，见上一篇Okhttp的线程池

当正在执行的队列大小<64并且相同host请求不能超过5个的时候，将请求放入runningAsyncCalls队列，并取线程执行。否则放入readyAsyncCalls队列等待。

那么为什么可以将AsyncCall交给线程池，到底执行的是什么呢？由源码可见AsyncCall最终还是继承的Runnable。

//AsyncCall 类
@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 {
      eventListener.callFailed(RealCall.this, e);
      responseCallback.onFailure(RealCall.this, e);
    }
  } finally {
  //一次请求结束会执行这里！！
    client.dispatcher().finished(this);
  }
}

一次请求结束后会调用Dispatcher的finished方法，在这里会将readyAsyncCalls中的call放入runningAsyncCalls去执行。

//Dispatcher类
void finished(AsyncCall call) {
    finished(runningAsyncCalls, call, true);
  }


private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
    int runningCallsCount;
    Runnable idleCallback;
    synchronized (this) {
        //从runningAsyncCalls中移除call
      if (!calls.remove(call)) throw new AssertionError("Call wasn't in-flight!");
      if (promoteCalls) promoteCalls();
      runningCallsCount = runningCallsCount();
      idleCallback = this.idleCallback;
    }

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

//这个方法主要将readyAsyncCalls中的call放入runningAsyncCalls去执行
private void promoteCalls() {
    if (runningAsyncCalls.size() >= maxRequests) return; // Already running max capacity.
    if (readyAsyncCalls.isEmpty()) return; // No ready calls to promote.

    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext(); ) {
      AsyncCall call = i.next();

      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
      }

      if (runningAsyncCalls.size() >= maxRequests) return; // Reached max capacity.
    }
}

拦截器

OkHttp默认有五个拦截器，五大拦截器完成整个请求过程。Okhttp使用责任链模式将这五大拦截器串起来了。

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, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
}

RetryAndFollowUpInterceptor 重试重定向拦截器

在交给桥接拦截器前，负责判断用户是否取消了请求；在获得了结果之后会根据响应码判断是否需要重定向，如果满足条件就会重启执行所有拦截器。

主要是对响应做的处理。

//RetryAndFollowUpInterceptor 类
@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);
        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 {
        
        //没有异常，直接释放资源
        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();
      }
    
      //处理3xx和4xx的一些状态，比如301/302重定向
      //说明响应头有Location字段，需要重定向
      Request followUp;
      try {
        followUp = followUpRequest(response, streamAllocation.route());
      } catch (IOException e) {
        streamAllocation.release();
        throw e;
      }
      
      //表示不需要重定向，直接返回response，结束循环
      if (followUp == null) {
        if (!forWebSocket) {
          streamAllocation.release();
        }
        return response;
      }
      
      //---------需要重定向才走下面的代码

      closeQuietly(response.body());
    
      //重定向次数不能大于20次，否则抛出协议异常
      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;
    }
}

//基本上比较可能的就是网络波动的时候重试
//其他情况概率很低
private boolean recover(IOException e, StreamAllocation streamAllocation,
      boolean requestSendStarted, Request userRequest) {
    streamAllocation.streamFailed(e);
    
    //判断OkHttpClient是否配置了允许重试retryOnConnectionFailure，默认是true
    if (!client.retryOnConnectionFailure()) return false;

    // 判断单个request是否配置重试
    //如果我们的请求体是UnrepeatableRequestBody这个类型，就不会重试
    //我们可以自己去实现UnrepeatableRequestBody
    //当然了一般不这么使用
    if (requestSendStarted && userRequest.body() instanceof UnrepeatableRequestBody) return false;

    // 判断是不是属于重试的异常
    //协议异常：响应码无内容204或者是刷新205，但是又说contentLength>0，不能重试
    //网络超时异常可以重试
    //证书异常、校验失败等不重试
    if (!isRecoverable(e, requestSendStarted)) return false;

    //判断有没有更多的路由
    if (!streamAllocation.hasMoreRoutes()) return false;

    // For failure recovery, use the same route selector with a new connection.
    return true;
}

BridgeInterceptor 桥接拦截器

在交给缓存拦截器前，负责将HTTP协议必备的请求头加入其中并添加一些默认的行为；在获得了结果后，调用保存cookie接口并解析GZIP数据。

//BridgeInterceptor 类
@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));
    }
    
    //Connection ：Keep-Alive 希望跟服务器保持长连接
    //如果服务器也想保持长连接，则响应头Connection ：Keep-Alive
    //如果服务器不想保持长连接，则响应头Connection ：Close
    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");
    }
    
    //如果要使用Cookie的话，这个保存得自己处理
    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());
    }

    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);
      String contentType = networkResponse.header("Content-Type");
      responseBuilder.body(new RealResponseBody(contentType, -1L, Okio.buffer(responseBody)));
    }

    return responseBuilder.build();
}

如果要使用Cookie的话，创建OkHttpClient的时候需要调用cookieJar处理。

OkHttpClient.Builder httpBuilder = new OkHttpClient.Builder()
    .cookieJar(new CookieJar() {
        @Override
        public void saveFromResponse(HttpUrl url, List<Cookie> cookies) {
            
        }

        @Override
        public List<Cookie> loadForRequest(HttpUrl url) {
            return null;
        }
    });

CacheInterceptor 缓存拦截器

在交给连接拦截器前，读取并判断是否使用缓存；获得结果后判断是否缓存。OkHttp只支持Get缓存。如果要使用OkHttp的缓存，则需要在创建OkHttpClient的时候设置Cache

1 2	int cacheSize = 100 * 1024 * 1024; // 10MB okHttpClientBuilder.cache(new Cache(iNetworkRequiredInfo.getApplicationContext().getCacheDir(), cacheSize));

我们看一下Cache的构造方法：

public Cache(File directory, long maxSize) {
    this(directory, maxSize, FileSystem.SYSTEM);
}

Cache(File directory, long maxSize, FileSystem fileSystem) {
    this.cache = DiskLruCache.create(fileSystem, directory, VERSION, ENTRY_COUNT, maxSize);
}

可以知道，Cache用的是开源的缓存文件类DiskLruCache。OkHttp没有内存缓存，只有硬盘缓存。

//CacheInterceptor 类
@Override public Response intercept(Chain chain) throws IOException {
    //通过url的md5数据从文件缓存查找
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;
    
    long now = System.currentTimeMillis();
    
    //缓存策略类 CacheStrategy判断使用缓存或发起网络请求
    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 (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 (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 (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;
}

总的来说就是，networkRequest若存在则优先发起网络请求，否则使用cacheResponse缓存，若都不存在则请求失败。

那么我们来看一下这两个字段值是怎么得出来的：

public CacheStrategy get() {
  CacheStrategy candidate = getCandidate();

  if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {
    // We're forbidden from using the network and the cache is insufficient.
    return new CacheStrategy(null, null);
  }

  return candidate;
}

/** Returns a strategy to use assuming the request can use the network. */
private CacheStrategy getCandidate() {
  //cacheResponse是传进来的缓存，这里指的是没有缓存
  if (cacheResponse == null) {
    return new CacheStrategy(request, null);
  }

  // 如果是https，但是认证过程没有完成
  if (request.isHttps() && cacheResponse.handshake() == null) {
    return new CacheStrategy(request, null);
  }

  // If this response shouldn't have been stored, it should never be used
  // as a response source. This check should be redundant as long as the
  // 不使用缓存
  if (!isCacheable(cacheResponse, request)) {
    return new CacheStrategy(request, null);
  }
    
  //不使用缓存
  CacheControl requestCaching = request.cacheControl();
  if (requestCaching.noCache() || hasConditions(request)) {
    return new CacheStrategy(request, null);
  }
    
  //是否请求的response是不可改变的，是的话就直接用缓存的
  CacheControl responseCaching = cacheResponse.cacheControl();
  if (responseCaching.immutable()) {
    return new CacheStrategy(null, cacheResponse);
  }
    
  long ageMillis = cacheResponseAge();
  long freshMillis = computeFreshnessLifetime();
  
  // 如果request缓存有设置存活时间，取最小值
  if (requestCaching.maxAgeSeconds() != -1) {
    freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));
  }
  // 最小请求刷新时间
  long minFreshMillis = 0;
  if (requestCaching.minFreshSeconds() != -1) {
    minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());
  }
  // 最大腐败时间
  long maxStaleMillis = 0;
  if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {
    maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());
  }

  // 如果使用缓存，且存活时间+最小存活时间 < 存活时间 + 最大腐败时间，使用缓存
  if (!responseCaching.noCache() && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
    Response.Builder builder = cacheResponse.newBuilder();
    if (ageMillis + minFreshMillis >= freshMillis) {
      builder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"");
    }
    long oneDayMillis = 24 * 60 * 60 * 1000L;
    if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
      builder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
    }
    return new CacheStrategy(null, builder.build());
  }

  // Find a condition to add to the request. If the condition is satisfied, the response body
  // will not be transmitted.
  String conditionName;
  String conditionValue;
  if (etag != null) {
    conditionName = "If-None-Match";
    conditionValue = etag;
  } else if (lastModified != null) {
    conditionName = "If-Modified-Since";
    conditionValue = lastModifiedString;
  } else if (servedDate != null) {
    conditionName = "If-Modified-Since";
    conditionValue = servedDateString;
  } else {
    return new CacheStrategy(request, null); // No condition! Make a regular request.
  }

  Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
  Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);

  Request conditionalRequest = request.newBuilder()
      .headers(conditionalRequestHeaders.build())
      .build();
  return new CacheStrategy(conditionalRequest, cacheResponse);
}

ConnectInterceptor 连接拦截器

在交给请求服务器拦截器前，负责找到或者新建一个连接，并获得对应的socket流；获得结果后不进行额外的处理。

//ConnectInterceptor 类
@Override public Response intercept(Chain chain) throws IOException {
    RealInterceptorChain realChain = (RealInterceptorChain) chain;
    Request request = realChain.request();
    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 = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
    RealConnection connection = streamAllocation.connection();

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

Socket和服务器IP/PORT是对应的。ConnectionPool是Socket的连接池，默认最大闲置连接有5个，保活时间5分钟。

1
2
3

public ConnectionPool() {
    this(5, 5, TimeUnit.MINUTES);
}

//如果清理任务未执行就启动它，再把连接加入到队列
void put(RealConnection connection) {
    assert (Thread.holdsLock(this));
    if (!cleanupRunning) {
      cleanupRunning = true;
      //开线程执行
      executor.execute(cleanupRunnable);
    }
    connections.add(connection);
}

cleanupRunnable的过程是什么？也就是说连接池是怎么移除连接的？

会对连接池遍历，获得在用连接数、闲置连接数、最大的闲置连接，如果最大的闲置连接超过了保活时间5分钟或者连接池内连接超过了5个，则马上移除它；否则如果有闲置连接但是还不到5分钟，则(5分钟-闲置时间)后再检查；否则有使用中的连接，等5分钟后再检查。

@Nullable RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
    assert (Thread.holdsLock(this));
    for (RealConnection connection : connections) {
      if (connection.isEligible(address, route)) {
        streamAllocation.acquire(connection, true);
        return connection;
      }
    }
    return null;
}


public boolean isEligible(Address address, @Nullable Route route) {
    // 该连接在使用，不能复用
    if (allocations.size() >= allocationLimit || noNewStreams) return false;

    // 如果地址不同，不能复用
    if (!Internal.instance.equalsNonHost(this.route.address(), address)) return false;

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url().host().equals(this.route().address().url().host())) {
      return true; // This connection is a perfect match.
    }

    // At this point we don't have a hostname match. But we still be able to carry the request if
    // our connection coalescing requirements are met. See also:
    // https://hpbn.co/optimizing-application-delivery/#eliminate-domain-sharding
    // https://daniel.haxx.se/blog/2016/08/18/http2-connection-coalescing/

    // 1. This connection must be HTTP/2.
    if (http2Connection == null) return false;

    // 2. The routes must share an IP address. This requires us to have a DNS address for both
    // hosts, which only happens after route planning. We can't coalesce connections that use a
    // proxy, since proxies don't tell us the origin server's IP address.
    if (route == null) return false;
    if (route.proxy().type() != Proxy.Type.DIRECT) return false;
    if (this.route.proxy().type() != Proxy.Type.DIRECT) return false;
    if (!this.route.socketAddress().equals(route.socketAddress())) return false;

    // 3. This connection's server certificate's must cover the new host.
    if (route.address().hostnameVerifier() != OkHostnameVerifier.INSTANCE) return false;
    if (!supportsUrl(address.url())) return false;

    // 4. Certificate pinning must match the host.
    try {
      address.certificatePinner().check(address.url().host(), handshake().peerCertificates());
    } catch (SSLPeerUnverifiedException e) {
      return false;
    }

    return true; // The caller's address can be carried by this connection.
}

CallServerInterceptor 请求服务器拦截器

进行的真正的与服务器通信，将组装成HTTP报文格式发送到服务器，解析读取的响应数据。

如果请求头有 Expect：100-continue ，代表了先询问服务器是否愿意接收发送的请求体数据。一般出现于上传大容量请求体或者需要验证的情况下。OkHttp的做法是，如果服务器允许则返回100，客户端继续发送请求体，如果服务器不允许则直接返回给用户，同时服务器也可能会忽略此请求头，一直无法读取应答，此时抛出超时异常。

OkHttp的总结

OkHttp用了哪些设计模式

责任链模式

五大拦截器链式调用，这也是okhttp的精髓所在。可以降低逻辑的耦合，相互独立的逻辑写到自己的拦截器中；扩展性强，可以添加新的拦截器。
2. 构建者模式

在Okhttp中，建造者模式也是用的挺多的，主要用处是将对象的创建与表示相分离，用Builder组装各项配置。
3. 单例模式

Platform类中用了单例模式

享元模式

线程池的使用。
5. 工厂模式

CacheStrategy这个对象的生成用的就是工厂模式。

response.body().string() 只能调用一次

之前在使用网上某个开源库的时候也遇到过，这里先不多谈。当我们解析response的时候，有时候会直接打印数据，如果你写了两次response.body().string()会有异常的。

response.body()返回的是ResponseBody对象。

//ResponseBody 类
public final String string() throws IOException {
    BufferedSource source = source();
    try {
      Charset charset = Util.bomAwareCharset(source, charset());
      return source.readString(charset);
    } finally {
      Util.closeQuietly(source);
    }
}

//Util 类
public static void closeQuietly(Closeable closeable) {
    if (closeable != null) {
      try {
        closeable.close();
      } catch (RuntimeException rethrown) {
        throw rethrown;
      } catch (Exception ignored) {
      }
    }
  }

可知，Util.closeQuietly(source)关闭了 ResponseBody 子类所持有的 BufferedSource 接口对象。当我们第一次调用 response.body().string() 时，OkHttp 将响应体的缓冲资源返回的同时，调用 closeQuietly() 方法默默释放了资源。

为什么要这么设计呢？下面这个回答也是在网上找到的答案哈哈。

在实际开发中，响应主体 RessponseBody 持有的资源可能会很大，所以 OkHttp 并不会将其直接保存到内存中，只是持有数据流连接。只有当我们需要时，才会从服务器获取数据并返回。同时，考虑到应用重复读取数据的可能性很小，所以将其设计为一次性流(one-shot)，读取后即 ‘关闭并释放资源’。