OkHttp 知识梳理(4) - OkHttp 之缓存源码解析
2018-03-26 本文已影响452人
泽毛
一、基础
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或者缓存没有命中，但是网络请求失败的时候，其实是得不到任何的返回结果的，如果我们需要在这种情况下返回缓存，那么还需要额外的处理逻辑。
