1. 首先我们先要介绍一下什么是缓存

缓存就是用户快速获取值的一种方式，暂时性存储数据的一种载体，用一定的时效性，一般在缓存中那中会有一种相对性的算法如FIFO LRU 等。

2.缓存类型：

按照使用者分类可以分为：
服务器缓存：在碰到的公司里面一般都是使用radius搭建缓存服务器
客户端缓存：客户端需要保存一些有时效性的东西，节省用户流量和请求此时
按照是否想向服务器分类可以分为强制缓存和对比缓存
强制缓存请求：

image.png

对比缓存请求：

image.png

3.如何设置缓存

3.1强制缓存

一般设置缓存是需要在header头面设置Cache-Control
其中Cache-Control 的值一般在移动端使用的就
no-cache：不进行缓存
max-age=xxx: 设置缓存时间为xxx

3.2 对比缓存

我们在拿到缓存信息之后需要服务器进行对比，由服务器判断是否使用缓存

3.2.1 Last-Modified/If-Modified-Since

Last-Modified：服务器在响应请求时，告诉浏览器资源的最后修改时间。

image.png

If-Modified-Since：
再次请求服务器时，通过此字段通知服务器上次请求时，服务器返回的资源最后修改时间。

服务器收到请求后发现有头If-Modified-Since 则与被请求资源的最后修改时间进行比对。

若资源的最后修改时间大于If-Modified-Since，说明资源又被改动过，则响应整片资源内容，返回状态码200；
若资源的最后修改时间小于或等于If-Modified-Since，说明资源无新修改，则响应HTTP 304，告知浏览器继续使用所保存的cache。

3.2.2 Etag / If-None-Match（优先级高于Last-Modified / If-Modified-Since）

服务器响应请求时，告诉浏览器当前资源在服务器的唯一标识（生成规则由服务器决定）。

image.png

If-None-Match：

再次请求服务器时，通过此字段通知服务器客户段缓存数据的唯一标识。
服务器收到请求后发现有头If-None-Match 则与被请求资源的唯一标识进行比对，
不同，说明资源又被改动过，则响应整片资源内容，返回状态码200；
相同，说明资源无新修改，则响应HTTP 304，告知浏览器继续使用所保存的cache。

CacheInterceptor 核心代码
public Response intercept(Chain chain) throws IOException {
//这部分是请求部分的缓存
//如果配置缓存，则从缓存中取一次，不保证存在
Response cacheCandidate = cache != null
? cache.get(chain.request())
: null;
long now = System.currentTimeMillis();
//创建缓存策略(强制缓存，对比缓存等);
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();
}

// If we don't need the network, we're done.
//在没有网络 但是又缓存的情况下  直接去缓存中的数据并返回
if (networkRequest == null) {
  return cacheResponse.newBuilder()
      .cacheResponse(stripBody(cacheResponse))
      .build();
}

Response networkResponse = null;
try {
  //进入下一个拦截器
  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();

if (cache != null) {
  //8. 对数据进行缓存；
  if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
    // Offer this request to the cache.
    CacheRequest cacheRequest = cache.put(response);
    return cacheWritingResponse(cacheRequest, response);
  }

  if (HttpMethod.invalidatesCache(networkRequest.method())) {
    try {
      cache.remove(networkRequest);
    } catch (IOException ignored) {
      // The cache cannot be written.
    }
  }
}

return response;

}
在这里总结一下主要流程
1.如果配置缓存，则从缓存中取一次，不保证存在
2.创建缓存策略(强制缓存，对比缓存等);
3.在没有网络没有缓存的情况下返回504
4.在没有网络但是有缓存的情况下直接去缓存中的数据并返回
5.进入下一个拦截器
6.接收到的网络结果，如果是code 304, 使用缓存，返回缓存结果（对比缓存）
7.获取网络结果
8.对数据进行缓存

最后献上一份添加了注释的源码 https://github.com/525642022/okhttpTest/blob/master/README.md
哈哈