OKhttp源码学习（六）—— 拦截器_CacheInterceptor

最新推荐文章于 2021-12-15 12:01:17 发布

上冲鸭

最新推荐文章于 2021-12-15 12:01:17 发布

阅读量110

点赞数

分类专栏： Android 技术文章标签： Android okhttp 源码学习

本文链接：https://blog.csdn.net/u011623470/article/details/96332785

版权

Android 技术专栏收录该内容

24 篇文章 0 订阅

订阅专栏

CacheInterceptor缓存拦截器分析

源码地址：https://github.com/square/okhttp

不知不觉来到了第三个拦截器，经过前面的两个拦截器：
RetryAndFollowUpInterceptor（初始化连接，重连）；
BridgeInterceptor（头处理，Gzip, cookie处理）。

而这个 CacheInterceptor，是处理缓存相关的拦截器。

缓存知识

对于http 缓存的相关知识，可以参考：
http://www.cnblogs.com/chenqf/p/6386163.html
这文章中比较详细的讲解了，http中的缓存机制，以及一些基本的原理。如果你对缓存已经了解，可以忽略。

缓存拦截器基本流程

读取候选缓存；
创建缓存策略（根据头信息，判断强制缓存，对比缓存等策略)；
根据策略，不使用网络，缓存又没有直接报错；
根据策略，不使用网络，有缓存就直接返回；
前面个都没有返回，读取网络结果（跑下一个拦截器）；
接收到的网络结果，如果是code 304, 使用缓存，返回缓存结果（对比缓存）
读取网络结果；
对数据进行缓存；
返回网络读取的结果。

源码解读

  @Override public Response intercept(Chain chain) throws IOException {
   //1. 读取候选缓存；
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();

    //2. 创建缓存策略（强制缓存，对比缓存等策略)；
    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 we're forbidden from using the network and the cache is insufficient, fail.
    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();
    }

    // 4. 根据策略，不使用网络，有缓存就直接返回；
    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }

    Response networkResponse = null;
    try {
     // 5. 前面个都没有返回，读取网络结果（跑下一个拦截器）；
      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());
      }
    }

   //6. 接收到的网络结果，如果是code 304, 使用缓存，返回缓存结果（对比缓存）
    // If we have a cache response too, then we're doing a conditional get.
    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());
      }
    }

   //7. 读取网络结果；
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    //8. 对数据进行缓存；
    if (HttpHeaders.hasBody(response)) {
      CacheRequest cacheRequest = maybeCache(response, networkResponse.request(), cache);
      response = cacheWritingResponse(cacheRequest, response);
    }
    //9. 返回网络读取的结果。
    return response;
  }