OKHttp源码分析3 - HttpEngine底层实现

1 概述

上篇文章，我们详细分析了OKHttp中Request的创建和发送过程。其中sendRequest(), readResponse(), followUpRequest()三个关键方法在底层HttpEngine中实现。革命尚未成功，我们接下来在这篇文章中分析HttpEngine中的这三个方法。由于底层HttpEngine涉及到很多Http协议方面东西，对Http协议不熟悉的同学可以先阅读我的这篇文章 Http协议简介

2 sendRequest()源码分析

sendRequest()方法是client向server发送request的主要方法。它先对request的header添加了一些默认字段，如keep-alive。然后对cache进行处理，判断是否可以直接使用cache。如果不行，才真正发送网络request。

  public void sendRequest() throws RequestException, RouteException, IOException {    if (cacheStrategy != null) return; // Already sent.    if (transport != null) throw new IllegalStateException();    // 对header的处理，利用app中用户构造的原始request    // 主要是对header进行添加。如添加"Connection: Keep-Alive"首部。后面单独分析    Request request = networkRequest(userRequest);    // 对cache的处理    InternalCache responseCache = Internal.instance.internalCache(client);    // 利用request为key，从cache中取出response    Response cacheCandidate = responseCache != null        ? responseCache.get(request)        : null;    // 判断cache是否可用，利用Expires，Last-Modified，Date，Age等header字段，后面详细分析    long now = System.currentTimeMillis();    cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get();    // cache可用或网络被禁止使用则networkRequest为null    networkRequest = cacheStrategy.networkRequest;    // cache不可用，则cacheResponse为null。对应情况有，不允许使用cache，没有对应cache，cache过期需要重新验证    cacheResponse = cacheStrategy.cacheResponse;    if (responseCache != null) {      responseCache.trackResponse(cacheStrategy);    }    if (cacheCandidate != null && cacheResponse == null) {      // cache已过期，不可用，关闭它      closeQuietly(cacheCandidate.body());    }    if (networkRequest != null) {      // networkRequest不为空，代表cache不可用，且网络可用      // 从这儿可以看出，cache可用时会直接使用cache，不可用才走网络数据。这也是符合Http常规做法的。      if (connection == null) {        // 连接到server，直接连接或通过代理均可        connect();      }      // 构造HttpTransport，与发送request到网络中去有关      transport = Internal.instance.newTransport(connection, this);      // 将start line，headers，body写入到buffer中，以等待发送出去      if (callerWritesRequestBody && permitsRequestBody(networkRequest) && requestBodyOut == null) {        // 从request的header中获取content-length        long contentLength = OkHeaders.contentLength(request);        if (bufferRequestBody) {          // bufferRequestBody表示body在内存中了，这可能是多次发送重试等情况          // content-length太大          if (contentLength > Integer.MAX_VALUE) {            throw new IllegalStateException("Use setFixedLengthStreamingMode() or "                + "setChunkedStreamingMode() for requests larger than 2 GiB.");          }          if (contentLength != -1) {            // content-length已知，是个准确值            // 可以将start line和header写入HttpConnection中，此处涉及到Http报文结构和发送，后面重点讲解            transport.writeRequestHeaders(networkRequest);            // 构造request body的buffer，长度为content-length            requestBodyOut = new RetryableSink((int) contentLength);          } else {            // content-length还不确定，此时不能设置content-length首部，因为它还不确定。            // 要等到整个body准备好后，才能计算出content-length            requestBodyOut = new RetryableSink();          }        } else {          transport.writeRequestHeaders(networkRequest);          requestBodyOut = transport.createRequestBody(networkRequest, contentLength);        }      }    } else {      // networkRequest为null，要么cache可用，要么网络被禁止使用      if (connection != null) {          // 回收网络connection，并关闭它          Internal.instance.recycle(client.getConnectionPool(), connection);        connection = null;      }      if (cacheResponse != null) {        // cache可用。可用代表有此request的cache response，且没有过期        this.userResponse = cacheResponse.newBuilder()            .request(userRequest)            .priorResponse(stripBody(priorResponse))            .cacheResponse(stripBody(cacheResponse))            .build();      } else {        // 网络被禁止使用，自己构造一个504的response，gateway timeout        this.userResponse = new Response.Builder()            .request(userRequest)            .priorResponse(stripBody(priorResponse))            .protocol(Protocol.HTTP_1_1)            .code(504)            .message("Unsatisfiable Request (only-if-cached)")            .body(EMPTY_BODY)            .build();      }      // 将利用cache或自己生成的504response，进行gzip压缩      // 前面提到过，request的headers中声明了支持gzip压缩，故response中最好加入gzip压缩。      userResponse = unzip(userResponse);    }  }

我们接下来分析sendRequest()中使用到的一些比较重要的方法。networkRequest()方法作用为，在原有的request基础上添加一些header。从这些header中我们可以看出，OKHttp默认是使用Keep-Alive，response body支持gzip压缩，支持Cookie的使用。看到了吧，分析底层代码有助于我们对Http协议的理解和对OKHttp特性的掌握。

  private Request networkRequest(Request request) throws IOException {    Request.Builder result = request.newBuilder();    // 利用url解析出host，然后添加host header。它指明了server地址    if (request.header("Host") == null) {      result.header("Host", Util.hostHeader(request.httpUrl()));    }    // 添加Connection首部，Keep-Alive表示持久连接，一次request和response完成后，HTTP并不立刻关闭。    if (request.header("Connection") == null) {      result.header("Connection", "Keep-Alive");    }    // 添加Accept-Encoding首部，gzip表示可接收gzip格式的压缩编码    if (request.header("Accept-Encoding") == null) {      transparentGzip = true;      result.header("Accept-Encoding", "gzip");    }    // 处理cookie header    CookieHandler cookieHandler = client.getCookieHandler();    if (cookieHandler != null) {      // 将用户构建的原始request中的header弄成Map结构      Map<String, List<String>> headers = OkHeaders.toMultimap(result.build().headers(), null);      // 从URI中解析出cookie，并添加到Map中，其key为"Cookie"      Map<String, List<String>> cookies = cookieHandler.get(request.uri(), headers);      // 添加Cookie和Cookie2 header      OkHeaders.addCookies(result, cookies);    }    // 添加User-Agent header，它表示client端是啥东西，比如浏览器    // 对于OKHttp来说，就是okhttp和它的版本号    if (request.header("User-Agent") == null) {      result.header("User-Agent", Version.userAgent());    }    return result.build();  }

下面分析下cache是否可用的判断逻辑，也就是下面这行代码的执行逻辑。
cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get();

public final class CacheStrategy {    // 构造方法，nowMillis为传入的系统此刻时间    public Factory(long nowMillis, Request request, Response cacheResponse) {      this.nowMillis = nowMillis;      this.request = request;      this.cacheResponse = cacheResponse;      if (cacheResponse != null) {        // 取出response中的headers        Headers headers = cacheResponse.headers();        // 遍历所有headers，解析出与cache过期有关的headers，并给相应成员变量赋值        for (int i = 0, size = headers.size(); i < size; i++) {          String fieldName = headers.name(i);          String value = headers.value(i);          if ("Date".equalsIgnoreCase(fieldName)) {            // Date header处理            servedDate = HttpDate.parse(value);            servedDateString = value;          } else if ("Expires".equalsIgnoreCase(fieldName)) {            // Expires header处理            expires = HttpDate.parse(value);          } else if ("Last-Modified".equalsIgnoreCase(fieldName)) {            // Last-Modified header处理            lastModified = HttpDate.parse(value);            lastModifiedString = value;          } else if ("ETag".equalsIgnoreCase(fieldName)) {            // ETag header处理            etag = value;          } else if ("Age".equalsIgnoreCase(fieldName)) {            // Age header处理            ageSeconds = HeaderParser.parseSeconds(value, -1);          } else if (OkHeaders.SENT_MILLIS.equalsIgnoreCase(fieldName)) {            sentRequestMillis = Long.parseLong(value);          } else if (OkHeaders.RECEIVED_MILLIS.equalsIgnoreCase(fieldName)) {            receivedResponseMillis = Long.parseLong(value);          }        }      }    }    public CacheStrategy get() {      // CacheStrategy生成的主要方法      CacheStrategy candidate = getCandidate();      if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {        // 网络被用户禁止使用，并且cache不可用，此时networkRequest和cacheResponse都为null        return new CacheStrategy(null, null);      }      return candidate;    }    private CacheStrategy getCandidate() {      // 没有此request的cache response      if (cacheResponse == null) {        return new CacheStrategy(request, null);      }      // 对于HTTPS，必须有handshake字段，否则认为此cache不可用      if (request.isHttps() && cacheResponse.handshake() == null) {        return new CacheStrategy(request, null);      }      // 此response不能使用cache，比如金融类数据，一般追求实时性，不适合使用cache      if (!isCacheable(cacheResponse, request)) {        return new CacheStrategy(request, null);      }      // 使用cache前需要先验证一下保存的response，或者request中有条件GET的headers      // noCache()方法命名不好，有歧义。它不是表示不能使用cache或者没有cache，而是表示使用前要先验证。      CacheControl requestCaching = request.cacheControl();      if (requestCaching.noCache() || hasConditions(request)) {        return new CacheStrategy(request, null);      }      // 计算cache是否过期      long ageMillis = cacheResponseAge(); // 目前response生成时的绝对时间      long freshMillis = computeFreshnessLifetime(); // 到什么时候为止仍然是新鲜的，绝对时间      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;  // 最大过期时间，相对时间      CacheControl responseCaching = cacheResponse.cacheControl();      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\"");        }        // cache可用时，将networkRequest赋值为null，可以看出OKHttp是优先使用cache的        return new CacheStrategy(null, builder.build());      }      // 条件GET的处理。      // 条件GET一般是cache过期了，需要发送验证request给server，以判断cache response是否修改了。如果没有修改，还是可以接着使用cache的。      Request.Builder conditionalRequestBuilder = request.newBuilder();      if (etag != null) {        conditionalRequestBuilder.header("If-None-Match", etag);      } else if (lastModified != null) {        conditionalRequestBuilder.header("If-Modified-Since", lastModifiedString);      } else if (servedDate != null) {        conditionalRequestBuilder.header("If-Modified-Since", servedDateString);      }      Request conditionalRequest = conditionalRequestBuilder.build();      return hasConditions(conditionalRequest)          ? new CacheStrategy(conditionalRequest, cacheResponse)          : new CacheStrategy(conditionalRequest, null);    }}

writeRequestHeaders()向HttpConnection的buffer中以UTF-8的编码格式写入start line和headers，合适的时机会发送到socket中传输出去

public final class HttpTransport implements Transport {  // 这个名字起的不好，这个方法不仅写入了headers，还写入了start line  public void writeRequestHeaders(Request request) throws IOException {    // 发送request之前必须立刻调用，它记录了发送request的系统时间    httpEngine.writingRequestHeaders();    // 生成start line，后面有详细分析    String requestLine = RequestLine.get(        request, httpEngine.getConnection().getRoute().getProxy().type());    // 将start line和headers写入到buffer中，UTF-8格式，合适的时机再将buffer中数据通过socket传输出去    httpConnection.writeRequest(request.headers(), requestLine);  }}public final class RequestLine {  // 生成request的start line，Http协议中它的格式为 method url version  static String get(Request request, Proxy.Type proxyType) {    StringBuilder result = new StringBuilder();    // 写入method    result.append(request.method());    result.append(' ');    // 写入url    if (includeAuthorityInRequestLine(request, proxyType)) {      result.append(request.httpUrl());    } else {      result.append(requestPath(request.httpUrl()));    }    // 写入version，可以看到OKHttp支持的是HTTP/1.1版本    result.append(" HTTP/1.1");    return result.toString();  }}

3 readResponse()源码分析

public void readResponse() throws IOException {    if (userResponse != null) {      // response已经有了，这可能是利用cache生成的response或其他情况，      // 此时我们就不用去接收server端的response了，其实一般此时也没有server端的response让我们去接收，哈哈~      return;     }    if (networkRequest == null && cacheResponse == null) {      throw new IllegalStateException("call sendRequest() first!");    }    if (networkRequest == null) {      return; // No network response to read.    }    Response networkResponse;    if (forWebSocket) {      // 先将start line和header写入socket中      transport.writeRequestHeaders(networkRequest);      // 发送request，并读取response，后面详细分析      networkResponse = readNetworkResponse();    } else if (!callerWritesRequestBody) {      // 先执行拦截器，再写入request到HttpConnection的buffer中，最后发送buffer，并读取response      // 和上面情况比较像，这里就不展开分析了      networkResponse = new NetworkInterceptorChain(0, networkRequest).proceed(networkRequest);    } else {      // 将request body的buffer发出去，这样requestBodyOut中就有了body      if (bufferedRequestBody != null && bufferedRequestBody.buffer().size() > 0) {        bufferedRequestBody.emit();      }      // 处理request headers，并将start line和header写入socket中      if (sentRequestMillis == -1) {        if (OkHeaders.contentLength(networkRequest) == -1            && requestBodyOut instanceof RetryableSink) {          // 如果之前content-length值不清楚，此时在body已经ready的情况下，可以计算出content-length，并将它添加到header中          long contentLength = ((RetryableSink) requestBodyOut).contentLength();          networkRequest = networkRequest.newBuilder()              .header("Content-Length", Long.toString(contentLength))              .build();        }        // 将start line和header写入socket中        transport.writeRequestHeaders(networkRequest);      }      // 将body写入socket中      if (requestBodyOut != null) {        if (bufferedRequestBody != null) {          // This also closes the wrapped requestBodyOut.          bufferedRequestBody.close();        } else {          requestBodyOut.close();        }        if (requestBodyOut instanceof RetryableSink) {          // body 写入socket中          transport.writeRequestBody((RetryableSink) requestBodyOut);        }      }      // 发送request，并读取response，后面会详细分析      networkResponse = readNetworkResponse();    }    // 开始处理获取到的response    // 读取并处理response的headers    receiveHeaders(networkResponse.headers());    // cache response存在的情况下，应该是cache过期了，做了一次条件GET来验证cache的内容是否有变更。    // 根据Http协议，如果cache未变，回复304，not modified。且response中不会包含body，    // 如果cache改变，回复200, OK。response中包含body    if (cacheResponse != null) {      if (validate(cacheResponse, networkResponse)) {        // 再验证通过，cache内容未变，使用cache构造response        userResponse = cacheResponse.newBuilder()            .request(userRequest)            .priorResponse(stripBody(priorResponse))            .headers(combine(cacheResponse.headers(), networkResponse.headers()))            .cacheResponse(stripBody(cacheResponse))            .networkResponse(stripBody(networkResponse))            .build();        networkResponse.body().close();        releaseConnection();        // 更新cache        InternalCache responseCache = Internal.instance.internalCache(client);        responseCache.trackConditionalCacheHit();        responseCache.update(cacheResponse, stripBody(userResponse));        userResponse = unzip(userResponse);        return;      } else {        // cache未命中，response中会包含我们想要的body的。关闭cache body流        closeQuietly(cacheResponse.body());      }    }    // cache未命中，利用server返回的response string构造client使用的Response对象    // 此时会将response缓存起来，以便下次使用    userResponse = networkResponse.newBuilder()        .request(userRequest)        .priorResponse(stripBody(priorResponse))        .cacheResponse(stripBody(cacheResponse))        .networkResponse(stripBody(networkResponse))        .build();    if (hasBody(userResponse)) {      maybeCache();      userResponse = unzip(cacheWritingResponse(storeRequest, userResponse));    }  }

下面详细分析readNetworkResponse()，它会通过socket流读取response string的start line，headers和body。

  private Response readNetworkResponse() throws IOException {    // 将HttpTransport中的buffer flush出去    transport.finishRequest();    // 读取server的response string，并构造出Response对象    Response networkResponse = transport.readResponseHeaders()        .request(networkRequest)        .handshake(connection.getHandshake())        .header(OkHeaders.SENT_MILLIS, Long.toString(sentRequestMillis))        .header(OkHeaders.RECEIVED_MILLIS, Long.toString(System.currentTimeMillis()))        .build();    if (!forWebSocket) {      networkResponse = networkResponse.newBuilder()          .body(transport.openResponseBody(networkResponse))          .build();    }    return networkResponse;  }public final class HttpTransport implements Transport {  @Override public Response.Builder readResponseHeaders() throws IOException {    return httpConnection.readResponse();  }}public final class HttpConnection {  public Response.Builder readResponse() throws IOException {    if (state != STATE_OPEN_REQUEST_BODY && state != STATE_READ_RESPONSE_HEADERS) {      throw new IllegalStateException("state: " + state);    }    try {      while (true) {        // 解析start line，response的start line格式为 protocol，code， message        StatusLine statusLine = StatusLine.parse(source.readUtf8LineStrict());        // 将解析出的protocol， code， message分别放入构造的Response对象中        Response.Builder responseBuilder = new Response.Builder()            .protocol(statusLine.protocol)            .code(statusLine.code)            .message(statusLine.message);        // 解析response string的headers        Headers.Builder headersBuilder = new Headers.Builder();        // 一行行读取headers, 直到遇到空行结束        readHeaders(headersBuilder);        headersBuilder.add(OkHeaders.SELECTED_PROTOCOL, statusLine.protocol.toString());        // 将headers添加到Response对象中        responseBuilder.headers(headersBuilder.build());        // 如果返回code不是100， continue，则可以直接将Response对象返回        // 对于100，continue，server还会继续返回response string，我们需要在while循环中继续接收并解析        if (statusLine.code != HTTP_CONTINUE) {          state = STATE_OPEN_RESPONSE_BODY;          return responseBuilder;        }      }    } catch (EOFException e) {      // Provide more context if the server ends the stream before sending a response.      IOException exception = new IOException("unexpected end of stream on " + connection          + " (recycle count=" + Internal.instance.recycleCount(connection) + ")");      exception.initCause(e);      throw exception;    }  }}

4 followUpRequest()源码分析

client发送一个request之后，server可能回复一个重定向的response，并在这个response中告知client需要重新访问的server的IP。此时，client需要重新向新的server发送request，并等待新server的回复。所以我们需要单独判断重定向response，并发送多次request。有了OKHttp，这一切你都不用管，它会自动帮你完成所有这一切。OKHttp中followUpRequest()方法就是完成这个功能的。是不是瞬间感觉OKHttp强大到不要不要的啊~。这个方法流程比较简单，就不给出流程图了。亲们如果对Http协议不熟悉，可以先看我的这篇文章Http协议简介

  public Request followUpRequest() throws IOException {    if (userResponse == null) throw new IllegalStateException();    Proxy selectedProxy = getRoute() != null        ? getRoute().getProxy()        : client.getProxy();    int responseCode = userResponse.code();    // 利用responseCode来分析是否需要自动发送后续request    switch (responseCode) {      // 未认证用户，不能访问server或代理，故需要发送认证的request      case HTTP_PROXY_AUTH:        if (selectedProxy.type() != Proxy.Type.HTTP) {          throw new ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy");        }      case HTTP_UNAUTHORIZED:        return OkHeaders.processAuthHeader(client.getAuthenticator(), userResponse, selectedProxy);      // 永久重定向，暂时重定向，永久移动了等和重定向相关的response,response code中以3打头的都是      // 它们需要重新发送request给新的server，新sever的ip在response中会给出      case HTTP_PERM_REDIRECT:      case HTTP_TEMP_REDIRECT:        if (!userRequest.method().equals("GET") && !userRequest.method().equals("HEAD")) {            return null;        }      case HTTP_MULT_CHOICE:      case HTTP_MOVED_PERM:      case HTTP_MOVED_TEMP:      case HTTP_SEE_OTHER:        // Does the client allow redirects?        if (!client.getFollowRedirects()) return null;        // 新的server的IP地址在response的Location header中给出        String location = userResponse.header("Location");        if (location == null) return null;        HttpUrl url = userRequest.httpUrl().resolve(location);        // Don't follow redirects to unsupported protocols.        if (url == null) return null;        // If configured, don't follow redirects between SSL and non-SSL.        boolean sameScheme = url.scheme().equals(userRequest.httpUrl().scheme());        if (!sameScheme && !client.getFollowSslRedirects()) return null;        // Redirects don't include a request body.        Request.Builder requestBuilder = userRequest.newBuilder();        if (HttpMethod.permitsRequestBody(userRequest.method())) {          requestBuilder.method("GET", null);          requestBuilder.removeHeader("Transfer-Encoding");          requestBuilder.removeHeader("Content-Length");          requestBuilder.removeHeader("Content-Type");        }        // 删掉用户认证信息        if (!sameConnection(url)) {          requestBuilder.removeHeader("Authorization");        }        return requestBuilder.url(url).build();      default:        return null;    }  }

5 总结

OKHttp底层源码还是相当复杂的，毕竟它的功能如此之强大嘛。OKHttp默认采用了Keep-Alive持久连接技术，可支持gzip编码的response。在cache的处理上，如果cache可用，则直接使用cache，否则使用网络数据。OKHttp会做cache过期的判断和过期后的再验证。有了OKHttp，这一切你都不用管，它帮你cover掉了！

当需要做用户验证和重定向时，我们一般需要发送认证request，或向新server发送request，也就是要重新再生成新request并发送出去。有了OKHttp，这一切你都不用管，它又帮你cover掉了！

OKHttp功能实在是强大到爆表，掌握好了它的实现原理和底层流程之后，你就可以在项目中游刃有余的放心使用它了！另外，小编可是花了整个周末才完成了这几篇文章，走过路过的朋友帮忙写写评论吧，谢谢！