OkHttp缓存优化你的应用

class CacheNetworkInterceptor implements Interceptor {
    public Response intercept(Interceptor.Chain chain) throws IOException {
        //无缓存,进行缓存
        return chain.proceed(chain.request()).newBuilder()
                .removeHeader("Pragma")
                //对请求进行最大60秒的缓存
                .addHeader("Cache-Control", "max-age=60")
                .build();
    }
}


static class CacheInterceptor implements Interceptor {
    public Response intercept(Interceptor.Chain chain) throws IOException {
        Response resp;
        Request req;
        if (ok) {
            //有网络,检查10秒内的缓存
            req = chain.request()
                    .newBuilder()
                    .cacheControl(new CacheControl
                            .Builder()
                            .maxAge(10, TimeUnit.SECONDS)
                            .build())
                    .build();
        } else {
            //无网络,检查30天内的缓存,即使是过期的缓存
            req = chain.request().newBuilder()
                    .cacheControl(new CacheControl.Builder()
                            .onlyIfCached()
                            .maxStale(30, TimeUnit.SECONDS)
                            .build())
                    .build();
        }
        resp = chain.proceed(req);
        return resp.newBuilder().build();
    }
}

    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(httpCacheDirectory, cacheSize);
    OkHttpClient client = new OkHttpClient.Builder()
            .cache(cache)
            //加入拦截器,注意Network与非Network的区别
            .addInterceptor(new CacheInterceptor())
            .addNetworkInterceptor(new CacheNetworkInterceptor())
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(10, TimeUnit.SECONDS)
            .build();
            
    //最后通过使用该HTTP Client进行网络请求, 就实现上述需求

Response getResponseWithInterceptorChain() throws IOException {
    // Okhttp获取Response的入口
    // 采用责任链模式,一层层按顺序转交Request并处理Response
    List<Interceptor> interceptors = new ArrayList<>();
    // 用户定义的拦截器
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    //CacheInterceptor主要用于做缓存控制
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
    //用户定义的Network拦截器
      interceptors.addAll(client.networkInterceptors());
    }
    // 发起实际请求的拦截器
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

 @Override public Response intercept(Chain chain) throws IOException {
 
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;
    // 实际上是类似map,将返回内容的URL的MD5的值当key,返回内容当response
    // 然后从cache文件里面查询是否存在该缓存

    long now = System.currentTimeMillis();
    //根据当前的时间,以及缓存策略,来获取response
    CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
    Request networkRequest = strategy.networkRequest;
    Response cacheResponse = strategy.cacheResponse;
    // 根据策略得到cacheReposne 与 NetworkRequest
    // 之后的代码就是根据这两个东西设置返回头

    // 不进行网络请求,且缓存以及过期了,返回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();
    }

    // 不进行网络请求,此时缓存命中,直接返回缓存,后面的拦截器也不会调用了
    if (networkRequest == null) {
      return cacheResponse.newBuilder()
          .cacheResponse(stripBody(cacheResponse))
          .build();
    }
    
    // 否则需要请求网络,继续调用责任链后面的拦截器,请求网络并获取response
    Response networkResponse = null;
    try {
      networkResponse = chain.proceed(networkRequest);
    } finally {
      // 请求异常,关闭缓存避免泄漏
      if (networkResponse == null && cacheCandidate != null) {
        closeQuietly(cacheCandidate.body());
      }
    }
    
    // 请求了网络的同时,缓存其实也找到的情况
    // (比如 需要向服务器确认缓存是否可用的情况)
    if (cacheResponse != null) {
    // 返回了304, 我们都知道304的返回时不带body的,此时必须向获取cache的body
      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());
      }
    }

    //省略---------
    
}

// 缓存策略CacheStrategy主要的策略写在该方法下
  private CacheStrategy getCandidate() {
  // 没有缓存!
   if (cacheResponse == null) {
     return new CacheStrategy(request, null);
   }
   
   // 当请求的协议是https的时候,如果cache没有hansake就丢弃缓存
   if (request.isHttps() && cacheResponse.handshake() == null) {
     return new CacheStrategy(request, null);
   }
   
   /// -- 省略一些代码
   
   // 根据缓存的缓存时间,缓存可接受最大过期时间等等HTTP协议上的规范
   // 来判断缓存是否可用,
         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());
   }
 }