Java HttpMethod.invalidatesCache方法代码示例

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
private CacheRequest maybeCache(Response userResponse, Request networkRequest,
    InternalCache responseCache) throws IOException {
  if (responseCache == null) return null;

  // Should we cache this response for this request?
  if (!CacheStrategy.isCacheable(userResponse, networkRequest)) {
    if (HttpMethod.invalidatesCache(networkRequest.method())) {
      try {
        responseCache.remove(networkRequest);
      } catch (IOException ignored) {
        // The cache cannot be written.
      }
    }
    return null;
  }

  // Offer this request to the cache.
  return responseCache.put(userResponse);
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
private CacheRequest maybeCache(Response userResponse, Request networkRequest,
                                InternalCache responseCache) throws IOException {
    if (responseCache == null) return null;

    // Should we cache this response for this request?
    if (!CacheStrategy.isCacheable(userResponse, networkRequest)) {
        //根据请求方式判断是否需要缓存
        if (HttpMethod.invalidatesCache(networkRequest.method())) {
            try {
                responseCache.remove(networkRequest);
            } catch (IOException ignored) {
                // The cache cannot be written.
            }
        }
        return null;
    }

    // Offer this request to the cache.
    return responseCache.put(userResponse);
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
protected Response execute(Request request) throws IOException {
    if (Http.sCache != null) {
        if (HttpMethod.invalidatesCache(request.method())) {
            try {
                Http.sCache.remove(getUrl());
            } catch (IOException ignore) {
            }
        }
        if (!"GET".equals(request.method())) {
            setShouldCache(false);
        }
    }
    OkHttpClient client = getClient();
    Call call = client.newCall(request);
    long start = System.currentTimeMillis();
    Response response = call.execute();
    if (LOG.isLoggable(Log.INFO))
        LOG.i("Took " + (System.currentTimeMillis() - start) + "ms to execute request (" + getLogKey() + ")");
    if (Http.sCache != null && HttpHeaders.hasVaryAll(response)) {
        setShouldCache(false);
    }
    return response;
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
@Override
public Response intercept(@NonNull final Chain chain) throws IOException {
    Request request = chain.request();
    // Verify that the HTTP method is for loading data only and doesn't have any side-effects,
    // and that the request doesn't contain the 'only-if-cached' Cache-Control directive to
    // force loading from the cache.
    if (!HttpMethod.invalidatesCache(request.method()) &&
            !request.cacheControl().onlyIfCached()) {
        // If the request already has the 'stale-if-error' Cache-Control directive, then proceed
        // the request chain without interference.
        for (final String cacheControlValue : request.headers("Cache-Control")) {
            if (PATTERN_STALE_IF_ERROR.matcher(cacheControlValue).matches()) {
                return chain.proceed(request);
            }
        }
        // Otherwise add a 'stale-if-error' Cache-Control directive, with the maximum stale
        // value set to a very high value.
        request = request.newBuilder()
                .addHeader("Cache-Control", "stale-if-error=" + Integer.MAX_VALUE)
                .build();
    }
    return chain.proceed(request);
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
CacheRequest put(Response response) {
  String requestMethod = response.request().method();

  if (HttpMethod.invalidatesCache(response.request().method())) {
    try {
      remove(response.request());
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
    return null;
  }
  if (!requestMethod.equals("GET")) {
    // Don't cache non-GET responses. We're technically allowed to cache
    // HEAD requests and some POST requests, but the complexity of doing
    // so is high and the benefit is low.
    return null;
  }

  if (HttpHeaders.hasVaryAll(response)) {
    return null;
  }

  Entry entry = new Entry(response);
  DiskLruCache.Editor editor = null;
  try {
    editor = cache.edit(key(response.request().url()));
    if (editor == null) {
      return null;
    }
    entry.writeTo(editor);
    return new CacheRequestImpl(editor);
  } catch (IOException e) {
    abortQuietly(editor);
    return null;
  }
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
@Nullable CacheRequest put(Response response) {
  String requestMethod = response.request().method();

  if (HttpMethod.invalidatesCache(response.request().method())) {
    try {
      remove(response.request());
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
    return null;
  }
  if (!requestMethod.equals("GET")) {
    // Don't cache non-GET responses. We're technically allowed to cache
    // HEAD requests and some POST requests, but the complexity of doing
    // so is high and the benefit is low.
    return null;
  }

  if (HttpHeaders.hasVaryAll(response)) {
    return null;
  }

  Entry entry = new Entry(response);
  DiskLruCache.Editor editor = null;
  try {
    editor = cache.edit(key(response.request().url()));
    if (editor == null) {
      return null;
    }
    entry.writeTo(editor);
    return new CacheRequestImpl(editor);
  } catch (IOException e) {
    abortQuietly(editor);
    return null;
  }
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
private CacheRequest put(Response response) throws IOException {
  String requestMethod = response.request().method();

  if (HttpMethod.invalidatesCache(response.request().method())) {
    try {
      remove(response.request());
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
    return null;
  }
  if (!requestMethod.equals("GET")) {
    // Don't cache non-GET responses. We're technically allowed to cache
    // HEAD requests and some POST requests, but the complexity of doing
    // so is high and the benefit is low.
    return null;
  }

  if (OkHeaders.hasVaryAll(response)) {
    return null;
  }

  Entry entry = new Entry(response);
  DiskLruCache.Editor editor = null;
  try {
    editor = cache.edit(urlToKey(response.request()));
    if (editor == null) {
      return null;
    }
    entry.writeTo(editor);
    return new CacheRequestImpl(editor);
  } catch (IOException e) {
    abortQuietly(editor);
    return null;
  }
}
 

import okhttp3.internal.http.HttpMethod; //导入方法依赖的package包/类
private CacheRequest put(Response response) {
    String requestMethod = response.request().method();

    if (HttpMethod.invalidatesCache(response.request().method())) {
        try {
            remove(response.request());
        } catch (IOException ignored) {
            // The cache cannot be written.
        }
        return null;
    }
    if (!requestMethod.equals("GET")) {
        // Don't cache non-GET responses. We're technically allowed to cache
        // HEAD requests and some POST requests, but the complexity of doing
        // so is high and the benefit is low.
        return null;
    }

    if (HttpHeaders.hasVaryAll(response)) {
        return null;
    }

    Entry entry = new Entry(response);
    DiskLruCache.Editor editor = null;
    try {
        editor = cache.edit(urlToKey(response.request()));
        if (editor == null) {
            return null;
        }
        entry.writeTo(editor);
        return new CacheRequestImpl(editor);
    } catch (IOException e) {
        abortQuietly(editor);
        return null;
    }
}