OkHttp3源码解析03-缓存

青旅半醒 2023-10-17 16:25 229阅读 0赞

接着上篇文章，我们来看`RealCall.getResponse()`

Response getResponse(Request request, boolean forWebSocket) throws IOException {
        // Copy body metadata to the appropriate request headers.
        RequestBody body = request.body();
        if (body != null) {
          Request.Builder requestBuilder = request.newBuilder();
    
          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");
          }
    
          request = requestBuilder.build();
        }
    
        // Create the initial HTTP engine. Retries and redirects need new engine for each attempt.
        engine = new HttpEngine(client, request, false, false, forWebSocket, null, null, null);
    
        int followUpCount = 0;
        while (true) {
          if (canceled) {
            engine.releaseStreamAllocation();
            throw new IOException("Canceled");
          }
    
          boolean releaseConnection = true;
          try {
            engine.sendRequest();
            engine.readResponse();
            releaseConnection = false;
          } catch (RequestException e) {
            // The attempt to interpret the request failed. Give up.
            throw e.getCause();
          } catch (RouteException e) {
            // The attempt to connect via a route failed. The request will not have been sent.
            HttpEngine retryEngine = engine.recover(e.getLastConnectException(), null);
            if (retryEngine != null) {
              releaseConnection = false;
              engine = retryEngine;
              continue;
            }
            // Give up; recovery is not possible.
            throw e.getLastConnectException();
          } catch (IOException e) {
            // An attempt to communicate with a server failed. The request may have been sent.
            HttpEngine retryEngine = engine.recover(e, null);
            if (retryEngine != null) {
              releaseConnection = false;
              engine = retryEngine;
              continue;
            }
    
            // Give up; recovery is not possible.
            throw e;
          } finally {
            // We're throwing an unchecked exception. Release any resources.
            if (releaseConnection) {
              StreamAllocation streamAllocation = engine.close();
              streamAllocation.release();
            }
          }
    
          Response response = engine.getResponse();
          Request followUp = engine.followUpRequest();
    
          if (followUp == null) {
            if (!forWebSocket) {
              engine.releaseStreamAllocation();
            }
            return response;
          }
    
          StreamAllocation streamAllocation = engine.close();
    
          if (++followUpCount > MAX_FOLLOW_UPS) {
            streamAllocation.release();
            throw new ProtocolException("Too many follow-up requests: " + followUpCount);
          }
    
          if (!engine.sameConnection(followUp.url())) {
            streamAllocation.release();
            streamAllocation = null;
          }
    
          request = followUp;
          engine = new HttpEngine(client, request, false, false, forWebSocket, streamAllocation, null,
              response);
        }
      }

在`getResponse()`中，主要会执行

engine.sendRequest();
    engine.readResponse();

先来看HttpEngine的sendRequest()  
这里主要就是判断缓存是否可用，，如果缓存不可用且不进行网络请求，则返回504错误。  
如果可用，就优先使用缓存，如果不可用，那么就使用网络来请求。

public void sendRequest() throws RequestException, RouteException, IOException {
        //...
        Request request = networkRequest(userRequest);
        //获得client中的Cache，同时Cache在初始化时会读取缓存目录中曾经请求过的所有信息
        InternalCache responseCache = Internal.instance.internalCache(client);
        //这是一个可以读取缓存Header的Response
        Response cacheCandidate = responseCache != null
            ? responseCache.get(request)
            : null;
    
        long now = System.currentTimeMillis();
        cacheStrategy = new CacheStrategy.Factory(now, request, cacheCandidate).get();
        //网络请求
        networkRequest = cacheStrategy.networkRequest;
        //缓存的响应
        cacheResponse = cacheStrategy.cacheResponse;
    
        if (responseCache != null) {
          //记录cacheStrategy
          responseCache.trackResponse(cacheStrategy);
        }
        //...
    
        //不进行网络请求并且缓存不存在或者过期，则返回504错误
        if (networkRequest == null && cacheResponse == null) {
          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();
          return;
        }
    
        //不进行网络请求而且缓存可以使用，则直接返回缓存
        if (networkRequest == null) {
          userResponse = cacheResponse.newBuilder()
              .request(userRequest)
              .priorResponse(stripBody(priorResponse))
              .cacheResponse(stripBody(cacheResponse))
              .build();
          userResponse = unzip(userResponse);
          return;
        }
    
        //需要访问网络时
        boolean success = false;
        try {
          httpStream = connect();
          httpStream.setHttpEngine(this);
    
          if (writeRequestHeadersEagerly()) {
            long contentLength = OkHeaders.contentLength(request);
            if (bufferRequestBody) {
              if (contentLength > Integer.MAX_VALUE) {
                throw new IllegalStateException("Use setFixedLengthStreamingMode() or "
                    + "setChunkedStreamingMode() for requests larger than 2 GiB.");
              }
    
              if (contentLength != -1) {
                // Buffer a request body of a known length.
                httpStream.writeRequestHeaders(networkRequest);
                requestBodyOut = new RetryableSink((int) contentLength);
              } else {
                // Buffer a request body of an unknown length. Don't write request headers until the
                // entire body is ready; otherwise we can't set the Content-Length header correctly.
                requestBodyOut = new RetryableSink();
              }
            } else {
              httpStream.writeRequestHeaders(networkRequest);
              requestBodyOut = httpStream.createRequestBody(networkRequest, contentLength);
            }
          }
          success = true;
        } finally {
          // If we're crashing on I/O or otherwise, don't leak the cache body.
          if (!success && cacheCandidate != null) {
            closeQuietly(cacheCandidate.body());
          }
        }
    }

，同理，在readResponse()中，会判断缓存是否可用，如果可用，则优先使用缓存，如果不可用，则用网络请求返回的数据。

public void readResponse() throws IOException {
        //...
        Response networkResponse;
        //...
        //读取NetWorkResponse
        networkResponse = readNetworkResponse();
    
        //读取Header
        receiveHeaders(networkResponse.headers());
    
        if (cacheResponse != null) {
          //检查缓存是否可用，如果可用，那么就使用缓存，关闭并释放网络连接(networkResponse)
          if (validate(cacheResponse, networkResponse)) {
            userResponse = cacheResponse.newBuilder()
                .request(userRequest)
                .priorResponse(stripBody(priorResponse))
                .headers(combine(cacheResponse.headers(), networkResponse.headers()))
                .cacheResponse(stripBody(cacheResponse))
                .networkResponse(stripBody(networkResponse))
                .build();
            networkResponse.body().close();
            releaseStreamAllocation();
    
            // Update the cache after combining headers but before stripping the
            // Content-Encoding header (as performed by initContentStream()).
            InternalCache responseCache = Internal.instance.internalCache(client);
            responseCache.trackConditionalCacheHit();
            responseCache.update(cacheResponse, stripBody(userResponse));
            userResponse = unzip(userResponse);
            return;
          } else {
            //关闭并释放缓存Response
            closeQuietly(cacheResponse.body());
          }
        }
    
        userResponse = networkResponse.newBuilder()
            .request(userRequest)
            .priorResponse(stripBody(priorResponse))
            .cacheResponse(stripBody(cacheResponse))
            .networkResponse(stripBody(networkResponse))
            .build();
    
        if (hasBody(userResponse)) {
          maybeCache();
          userResponse = unzip(cacheWritingResponse(storeRequest, userResponse));
        }
      }

同时，可以看到这里判断是否缓存有效的`validate()`方法。  
\- 如果服务器返回304，则缓存有效  
\- 这种情况下，如果缓存过期，服务器会进行判断  
\- LAST-Modified来判断是否是最新数据，缓存是否有效

private static boolean validate(Response cached, Response network) {
        //如果服务器返回304，则缓存有效
        if (network.code() == HTTP_NOT_MODIFIED) {
          return true;
        }
    
        // The HTTP spec says that if the network's response is older than our
        // cached response, we may return the cache's response. Like Chrome (but
        // unlike Firefox), this client prefers to return the newer response.
        //通过cacheResponse和networkResponse中的Last-Modified来判断是否是最新数据，如果是，则缓存有效
        Date lastModified = cached.headers().getDate("Last-Modified");
        if (lastModified != null) {
          Date networkLastModified = network.headers().getDate("Last-Modified");
          if (networkLastModified != null
              && networkLastModified.getTime() < lastModified.getTime()) {
            return true;
          }
        }
    
        return false;
      }

#### 总结 ####

OkHttp在请求和响应前，会判断缓存是否可用，如果缓存不可用且不进行网络请求，则返回504错误，如果可用，就优先使用缓存，如果不可用，则通过网络进行加载。

> 源码分析中的OkHttp版本为com.squareup.okhttp3:okhttp:3.2.0