Java ResponseSource.CONDITIONAL_CACHE属性代码示例

/**
 * Figures out what the response source will be, and opens a socket to that
 * source if necessary. Prepares the request headers and gets ready to start
 * writing the request body if it exists.
 */
public final void sendRequest() throws IOException {
  if (responseSource != null) {
    return;
  }

  prepareRawRequestHeaders();
  initResponseSource();
  OkResponseCache responseCache = client.getOkResponseCache();
  if (responseCache != null) {
    responseCache.trackResponse(responseSource);
  }

  // The raw response source may require the network, but the request
  // headers may forbid network use. In that case, dispose of the network
  // response and use a GATEWAY_TIMEOUT response instead, as specified
  // by http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.4.
  if (requestHeaders.isOnlyIfCached() && responseSource.requiresConnection()) {
    if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
      Util.closeQuietly(cachedResponseBody);
    }
    this.responseSource = ResponseSource.CACHE;
    this.cacheResponse = GATEWAY_TIMEOUT_RESPONSE;
    RawHeaders rawResponseHeaders = RawHeaders.fromMultimap(cacheResponse.getHeaders(), true);
    setResponse(new ResponseHeaders(uri, rawResponseHeaders), cacheResponse.getBody());
  }

  if (responseSource.requiresConnection()) {
    sendSocketRequest();
  } else if (connection != null) {
    client.getConnectionPool().recycle(connection);
    connection = null;
  }
}
 

/**
 * Initialize the source for this response. It may be corrected later if the
 * request headers forbids network use.
 */
private void initResponseSource() throws IOException {
  responseSource = ResponseSource.NETWORK;
  if (!policy.getUseCaches()) return;

  OkResponseCache responseCache = client.getOkResponseCache();
  if (responseCache == null) return;

  CacheResponse candidate = responseCache.get(
      uri, method, requestHeaders.getHeaders().toMultimap(false));
  if (candidate == null) return;

  Map<String, List<String>> responseHeadersMap = candidate.getHeaders();
  cachedResponseBody = candidate.getBody();
  if (!acceptCacheResponseType(candidate)
      || responseHeadersMap == null
      || cachedResponseBody == null) {
    Util.closeQuietly(cachedResponseBody);
    return;
  }

  RawHeaders rawResponseHeaders = RawHeaders.fromMultimap(responseHeadersMap, true);
  cachedResponseHeaders = new ResponseHeaders(uri, rawResponseHeaders);
  long now = System.currentTimeMillis();
  this.responseSource = cachedResponseHeaders.chooseResponseSource(now, requestHeaders);
  if (responseSource == ResponseSource.CACHE) {
    this.cacheResponse = candidate;
    setResponse(cachedResponseHeaders, cachedResponseBody);
  } else if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
    this.cacheResponse = candidate;
  } else if (responseSource == ResponseSource.NETWORK) {
    Util.closeQuietly(cachedResponseBody);
  } else {
    throw new AssertionError();
  }
}
 

/** Returns the source to satisfy {@code request} given this cached response. */
public ResponseSource chooseResponseSource(long nowMillis, RequestHeaders request) {
  // 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
  // persistence store is well-behaved and the rules are constant.
  if (!isCacheable(request)) {
    return ResponseSource.NETWORK;
  }

  if (request.isNoCache() || request.hasConditions()) {
    return ResponseSource.NETWORK;
  }

  long ageMillis = computeAge(nowMillis);
  long freshMillis = computeFreshnessLifetime();

  if (request.getMaxAgeSeconds() != -1) {
    freshMillis = Math.min(freshMillis, TimeUnit.SECONDS.toMillis(request.getMaxAgeSeconds()));
  }

  long minFreshMillis = 0;
  if (request.getMinFreshSeconds() != -1) {
    minFreshMillis = TimeUnit.SECONDS.toMillis(request.getMinFreshSeconds());
  }

  long maxStaleMillis = 0;
  if (!mustRevalidate && request.getMaxStaleSeconds() != -1) {
    maxStaleMillis = TimeUnit.SECONDS.toMillis(request.getMaxStaleSeconds());
  }

  if (!noCache && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
    if (ageMillis + minFreshMillis >= freshMillis) {
      headers.add("Warning", "110 HttpURLConnection \"Response is stale\"");
    }
    long oneDayMillis = 24 * 60 * 60 * 1000L;
    if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
      headers.add("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
    }
    return ResponseSource.CACHE;
  }

  if (lastModified != null) {
    request.setIfModifiedSince(lastModified);
  } else if (servedDate != null) {
    request.setIfModifiedSince(servedDate);
  }

  if (etag != null) {
    request.setIfNoneMatch(etag);
  }

  return request.hasConditions() ? ResponseSource.CONDITIONAL_CACHE : ResponseSource.NETWORK;
}
 

/**
 * Flushes the remaining request header and body, parses the HTTP response
 * headers and starts reading the HTTP response body if it exists.
 */
public final void readResponse() throws IOException {
  if (hasResponse()) {
    responseHeaders.setResponseSource(responseSource);
    return;
  }

  if (responseSource == null) {
    throw new IllegalStateException("readResponse() without sendRequest()");
  }

  if (!responseSource.requiresConnection()) {
    return;
  }

  if (sentRequestMillis == -1) {
    if (requestBodyOut instanceof RetryableOutputStream) {
      int contentLength = ((RetryableOutputStream) requestBodyOut).contentLength();
      requestHeaders.setContentLength(contentLength);
    }
    transport.writeRequestHeaders();
  }

  if (requestBodyOut != null) {
    requestBodyOut.close();
    if (requestBodyOut instanceof RetryableOutputStream) {
      transport.writeRequestBody((RetryableOutputStream) requestBodyOut);
    }
  }

  transport.flushRequest();

  responseHeaders = transport.readResponseHeaders();
  responseHeaders.setLocalTimestamps(sentRequestMillis, System.currentTimeMillis());
  responseHeaders.setResponseSource(responseSource);

  if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
    if (cachedResponseHeaders.validate(responseHeaders)) {
      release(false);
      ResponseHeaders combinedHeaders = cachedResponseHeaders.combine(responseHeaders);
      this.responseHeaders = combinedHeaders;

      // Update the cache after applying the combined headers but before initializing the content
      // stream, otherwise the Content-Encoding header (if present) will be stripped from the
      // combined headers and not end up in the cache file if transparent gzip compression is
      // turned on.
      OkResponseCache responseCache = client.getOkResponseCache();
      responseCache.trackConditionalCacheHit();
      responseCache.update(cacheResponse, policy.getHttpConnectionToCache());

      initContentStream(cachedResponseBody);
      return;
    } else {
      Util.closeQuietly(cachedResponseBody);
    }
  }

  if (hasResponseBody()) {
    maybeCache(); // reentrant. this calls into user code which may call back into this!
  }

  initContentStream(transport.getTransferStream(cacheRequest));
}