一、基础

1.1 使用缓存的场景

对于一个联网应用来说，当设计网络部分的逻辑时，不可避免的要使用到缓存，目前我们项目中使用缓存的场景如下：

• 当请求数据的时候，先判断本地是否有缓存，或者本地的缓存是否过期，如果有缓存并且没有过期，那么就直接返回给接口的调用者，这部分称为 客户端缓存 或者 强制缓存。
• 假如不满足第一步的场景，那么就需要发起网络请求，但是服务器为了减少用户的流量，中间的代理服务器也会有自己的一套缓存机制，但这需要客户端和服务器协商好请求头部与缓存相关的字段，也就是我们在 OkHttp 知识梳理(3) - OkHttp 之缓存基础 中提到的缓存相关字段，这部分称为 服务器缓存。
• 假如服务器请求失败或者告知客户端缓存仍然可用，那么为了优化用户的体验，我们可以继续使用客户端的缓存，如果没有缓存，那么可以先展示默认的数据。

1.2 为什么要学习 OkHttp 缓存的实现逻辑

在OkHttp中，我们可以通过以下两点来对缓存的策略进行配置：

• 在创建OkHttpClient的过程中，通过.cache(Cache)配置缓存的位置。
• 在构造Request的过程中通过.cacheControl(CacheControl)来配置缓存逻辑。

OkHttp的缓存框架并不能完全满足我们的定制需求，我们有必要去了解它内部的实现逻辑，才能知道如何设计出符合1.1中谈到的使用场景。

二、源码解析

对于OkHttp缓存的内部实现，我们分为以下四点来介绍：

• Cache类：存储部分逻辑的实现，决定了缓存的数据如何保存及查找。
• CacheControl：单次请求的逻辑实现，决定了在发起请求后，在什么情况下直接返回缓存。
• CacheInterceptor：在本系列的第一篇文章中，我们分析了OkHttp从调用.call接口到真正发起请求，经过了一系列的拦截器，CacheInterceptor就是其中预置的一个拦截器。
• CacheStragy：它是CacheInterceptor负责缓存判断的具体实现类，其最终的目的就是构造出networkRequest和cacheResponse这两个成员变量。

2.1 Cache 类

Cache类的用法如下：

//分别对应缓存的目录，以及缓存的大小。
Cache mCache = new Cache(new File(CACHE_DIRECTORY), CACHE_SIZE);
//在构造 OkHttpClient 时，通过 .cache 配置。
OkHttpClient client = new OkHttpClient.Builder().cache(mCache).build();

在其内部采用DiskLruCache实现了LRU算法的磁盘缓存，对于一般的使用场景，不需要过多的关心，只需要指定缓存的位置和大小就可以了。

2.2 CacheControl

CacheControl是对HTTP的Cache-Control头部的描述，通过Builder方法我们可以对其进行配置，下面我们简单地介绍几个常用的配置：

• noCache()：如果出现在 请求头部，那么表示不适用于缓存响应，从网络获取结果；如果出现在 响应头部，表示不允许对响应进行缓存，而是客户端需要与服务器再次验证，进行一个额外的GET请求得到最新的响应。
• noStore()：如果出现在 响应头部，则表明该响应不能被缓存。
• maxAge(int maxAge, TimeUnit timeUnit)：设置缓存的 最大存活时间，假如当前时间与自身的Age时间差不在这个范围内，那么需要发起网络请求。
• maxStale(int maxStale,TimeUnit timeUnit)：设置缓存的 最大过期时间，假如当前时间与自身的Age时间差超过了 最大存活时间，但是超过部分的值小于过期时间，那么仍然可以使用缓存。
• minFresh(int minFresh,TimeUnit timeUnit)：如果当前时间加上minFresh的值，超过了该缓存的过期时间，那么就发起网络请求。
• onlyIfCached：表示只接受缓存中的响应，如果缓存不存在，那么返回一个状态码为504的响应。

CacheControl的配置项将会影响到我们后面在CacheStragy中 命中缓存的策略。

2.3 CacheInterceptor

CacheInterceptor的源码地址为 CacheInterceptor ，正如我们在 OkHttp 知识梳理(1) - OkHttp 源码解析之入门 中分析过的，它是内置拦截器。下面，我们先来看一下主要的流程，它在CacheInterceptor的intercept方法中：

  @Override public Response intercept(Chain chain) throws IOException {
    //1.通过 cache 找到之前缓存的响应，但是该缓存如他的名字一样，仅仅是一个候选人。
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;
    //2.获取当前的系统时间。
    long now = System.currentTimeMillis();
    //3.通过 CacheStrategy 的工厂方法构造出 CacheStrategy 对象，并通过 get 方法返回。
    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    //4.在 CacheStrategy 的构造过程中，会初始化 networkRequest 和 cacheResponse 这两个变量，分别表示要发起的网络请求和确定的缓存。
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;

    if (cache != null) {
      cache.trackResponse(strategy);
    }
    //5.如果曾经有候选的缓存，但是经过处理后 cacheResponse 不存在，那么关闭候选的缓存资源。
    if (cacheCandidate != null && cacheResponse == null) {
      closeQuietly(cacheCandidate.body());
    }

    //6.如果要发起的请求为空，并且没有缓存，那么直接返回 504 给调用者。
    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();
    }

    //7.如果不需要发起网络请求，那么直接将缓存返回给调用者。
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }

    Response networkResponse = null;
    try {
      //8.继续调用链的下一个步骤，按常理来说，走到这里就会真正地发起网络请求了。
      networkResponse = chain.proceed(networkRequest);
    } finally {
      //9.保证在发生了异常的情况下，候选的缓存可以正常关闭。
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }

    //10.网络请求完成之后，假如之前有缓存，那么首先进行一些额外的处理。
    if (cacheResponse != null) {
      //10.1 假如是 304，那么根据缓存构造出返回的结果给调用者。
      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 {
        //10.2 关闭缓存。
        closeQuietly(cacheResponse.body());
      }
    }
    //11.构造出返回结果。
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();

    if (cache != null) {
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        //12.如果符合缓存的要求，那么就缓存该结果。
        CacheRequest cacheRequest = cache.put(response);
        return cacheWritingResponse(cacheRequest, response);
      }
      //13.对于某些请求方法，需要移除缓存，例如 PUT/PATCH/POST/DELETE/MOVE
      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }
    return response;
  }

调用的流程图如下所示：

CacheInterceptor 调用流程图

2.4 CacheStrategy

通过上面的这段代码，我们可以对OkHttp整个缓存的实现有一个大概的了解，其实关键的实现还是在于这句，因为它决定了过滤的缓存和最终要发起的请求究竟是怎么样的：

CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();

    public Factory(long nowMillis, Request request, Response cacheResponse) {
      this.nowMillis = nowMillis;
      this.request = request;
      //1.从磁盘中直接读取出来的原始缓存，没有对头部的字段进行校验。
      this.cacheResponse = cacheResponse;

      if (cacheResponse != null) {
        //读取发送请求和收到结果的时间。
        this.sentRequestMillis = cacheResponse.sentRequestAtMillis();
        this.receivedResponseMillis = cacheResponse.receivedResponseAtMillis();
        //遍历头部字段，解析完毕后赋值给成员变量。
        Headers headers = cacheResponse.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)) {
            servedDate = HttpDate.parse(value);
            servedDateString = value;
          } else if ("Expires".equalsIgnoreCase(fieldName)) {
            expires = HttpDate.parse(value);
          } else if ("Last-Modified".equalsIgnoreCase(fieldName)) {
            lastModified = HttpDate.parse(value);
            lastModifiedString = value;
          } else if ("ETag".equalsIgnoreCase(fieldName)) {
            etag = value;
          } else if ("Age".equalsIgnoreCase(fieldName)) {
            ageSeconds = HttpHeaders.parseSeconds(value, -1);
          }
        }
      }
    }

    public CacheStrategy get() {
      //接下来的重头戏就是通过 getCandidate 方法来对 networkRequest 和 cacheResponse 赋值。
      CacheStrategy candidate = getCandidate();
      //如果网络请求不为空，但是 request 设置了 onlyIfCached 标志位，那么把两个请求都赋值为空。
      if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {
        return new CacheStrategy(null, null);
      }
      return candidate;
    }

    private CacheStrategy getCandidate() {
      //1.如果缓存为空，那么直接返回带有网络请求的策略。
      if (cacheResponse == null) {
        return new CacheStrategy(request, null);
      }

      //2.请求是 Https 的，但是 cacheResponse 的 handshake 为空。
      if (request.isHttps() && cacheResponse.handshake() == null) {
        return new CacheStrategy(request, null);
      }

      //3.根据缓存的状态判断是否需要该缓存，在规则一致的时候一般不会在这一步返回。
      if (!isCacheable(cacheResponse, request)) {
        return new CacheStrategy(request, null);
      }

      //4.获得当前请求的 cacheControl，如果配置了不缓存，或者当前的请求配置了 If-Modified-Since/If-None-Match 字段。
      CacheControl requestCaching = request.cacheControl();
      if (requestCaching.noCache() || hasConditions(request)) {
        return new CacheStrategy(request, null);
      }

      //5.获取缓存的 cacheControl，如果是可变的，那么就直接返回该缓存。
      CacheControl responseCaching = cacheResponse.cacheControl();
      if (responseCaching.immutable()) {
        return new CacheStrategy(null, cacheResponse);
      }

      //6.1 计算缓存的年龄。
      long ageMillis = cacheResponseAge();
      //6.2 计算刷新的时机。
      long freshMillis = computeFreshnessLifetime();
      
      //7.请求所允许的最大年龄。
      if (requestCaching.maxAgeSeconds() != -1) {
        freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));
      }
      
      //8.请求所允许的最小年龄。
      long minFreshMillis = 0;
      if (requestCaching.minFreshSeconds() != -1) {
        minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());
      }
      
      //9.最大的 Stale() 时间。
      long maxStaleMillis = 0;
      if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {
        maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());
      }
      
      //10.根据几个时间点确定是否返回缓存，并且去掉网络请求，如果客户端需要强行去掉网络请求，那么就是修改这个条件。
      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\"");
        }
        return new CacheStrategy(null, builder.build());
      }

      //填入条件请求的字段。
      String conditionName;
      String conditionValue;
      if (etag != null) {
        conditionName = "If-None-Match";
        conditionValue = etag;
      } else if (lastModified != null) {
        conditionName = "If-Modified-Since";
        conditionValue = lastModifiedString;
      } else if (servedDate != null) {
        conditionName = "If-Modified-Since";
        conditionValue = servedDateString;
      } else {
        //如果不是条件请求，那么去掉原始缓存。
        return new CacheStrategy(request, null); // No condition! Make a regular request.
      }

      Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
      Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);

      Request conditionalRequest = request.newBuilder()
          .headers(conditionalRequestHeaders.build())
          .build();
      //返回带有条件请求的 conditionalRequest，和原始的缓存，这样在出现 304 的时候就可以处理。
      return new CacheStrategy(conditionalRequest, cacheResponse);
    }

下图是这个请求的流程图，为了方便大家理解，采用四种颜色标志了(networkRequest, cacheResponse)的四种情况：

• 红色：networkRequest为原始request，cacheResponse为null
• 绿色：networkRequest为原始request，cacheResponse为cacheCandicate
• 紫色：networkRequest为原始request加上缓存相关的头部，cacheResponse为cacheCandicate
• 棕色：networkRequest和cacheResponse都为null

CacheStragy 流程图

三、小结

经过我们对于以上代码的分析，可以知道，当我们基于OkHttp来实现定制的缓存逻辑的时候，需要处理以下三个方面的问题：

• 对 客户端缓存 进行设计，调整cacheControl的maxStale、minFresh的参数，我们在下一篇文章中，将根据cacheControl来完成缓存的设计。
• 对 服务器缓存 进行设计，那么就需要服务端去处理If-None-Match、If-Modified-Since和If-Modified-Since这三个字段。当返回304的时候，OkHttp这边已经帮我们处理好了，所以客户端这边并不需要做什么。
• 异常情况 的处理，通过CacheInterceptor的源码，我们可以发现，当发生504或者缓存没有命中，但是网络请求失败的时候，其实是得不到任何的返回结果的，如果我们需要在这种情况下返回缓存，那么还需要额外的处理逻辑。