Okhttp 的缓存机制，原理讲解

判定字段

Etag

资源的唯一标识，类似于人们的身份证号码，资源的内容一旦发生改动，Etag 就会发生改变。客户端发送请求的时候格式为 If-None-Match +Etag，服务器收到后则会与缓存的 Etag 进行比对

Last-Modified

字面意思，最近修改的时间，由服务器所决定，客户端在发送请求的时候使用 If-Modified-Since + 指定时间，若客户端所存的数据≤该时间则说明资源没有改动

To put into a nutshell :

Okhttp 的缓存机制

可以看到，http 本身协议的缓存机制较为简单，不能很好的满足实际的需求。okhttp 相对来说便更加复杂。先说结论：

1. 缓存基于文件存储

2. 内部维护基于 LRU 算法的缓存清理线程

Okhttp 读取缓存流程

![](https://p3-juejin.byteimg.com/tos-cn-i

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开：qq.cn.hn/FTe 免费领取

-k3u1fbpfcp/3920c01fb4b440b7bf3af4a9224ef7e1~tplv-k3u1fbpfcp-zoom-1.image)

Okhttp 存储缓存流程

源码解析

CacheControl

用于指定缓存的规则

public final class CacheControl {

//表示这是一个优先使用网络验证，验证通过之后才可以使用缓存的缓存控制，设置了 noCachepublic static final CacheControl FORCE_NETWORK = new Builder().noCache().build();

//表示这是一个优先先使用缓存的缓存控制，设置了 onlyIfCached 和 maxStale 的最大值 public static final CacheControl FORCE_CACHE = new Builder().onlyIfCached().maxStale(Integer.MAX_VALUE, TimeUnit.SECONDS).build();

//以下的字段都是 HTTP 中 Cache-Control 字段相关的值 private final boolean noCache;private final boolean noStore;private final int maxAgeSeconds;private final int sMaxAgeSeconds;private final boolean isPrivate;private final boolean isPublic;private final boolean mustRevalidate;private final int maxStaleSeconds;private final int minFreshSeconds;private final boolean onlyIfCached;private final boolean noTransform;

//解析头文件中的相关字段，得到该缓存控制类 public static CacheControl parse(Headers headers) {...}

}

CacheStrategy

主要用于判断是否使用缓存数据

public final class CacheStrategy {

public Factory(long nowMillis, Request request, Response cacheResponse) {this.nowMillis = nowMillis;//网络请求和缓存响应 this.request = request;this.cacheResponse = cacheResponse;

if (cacheResponse != null) {//找到缓存响应的响应头信息 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 = HeaderParser.parseSeconds(value, -1);} else if (OkHeaders.SENT_MILLIS.equalsIgnoreCase(fieldName)) {sentRequestMillis = Long.parseLong(value);} else if (OkHeaders.RECEIVED_MILLIS.equalsIgnoreCase(fieldName)) {receivedResponseMillis = Long.parseLong(value);}}}}

public CacheStrategy get() {//获取判定的缓存策略 CacheStrategy candidate = getCandidate();

if (candidate.networkRequest != null && request.cacheControl().onlyIfCached()) {// 如果判定的缓存策略的网络请求不为空，但是只使用缓存，则返回两者都为空的缓存策略。return new CacheStrategy(null, null);}

return candidate;}

/** Returns a strategy to use assuming the request can use the network. */private CacheStrategy getCandidate() {// No cached response.//如果没有缓存响应，则返回没有缓存响应的策略 if (cacheResponse == null) {return new CacheStrategy(request, null);}

// Drop the cached response if it's missing a required handshake.//如果请求是 https，而缓存响应的握手信息为空，则返回没有缓存响应的策略 if (request.isHttps() && cacheResponse.handshake() == null) {return new CacheStrategy(request, null);}

// If this response shouldn't have been stored, it should never be used// as a response source. This check should be redundant as long as the// persistence store is well-behaved and the rules are constant.//如果请求对应的响应不能被缓存，则返回没有缓存响应的策略 if (!isCacheable(cacheResponse, request)) {return new CacheStrategy(request, null);}

//获取请求头中的 CacheControl 信息 CacheControl requestCaching = request.cacheControl();//如果请求头中的 CacheControl 信息是不缓存的，则返回没有缓存响应的策略 if (requestCaching.noCache() || hasConditions(request)) {return new CacheStrategy(request, null);}

//获取响应的年龄 long ageMillis = cacheResponseAge();//计算上次响应刷新的时间 long freshMillis = computeFreshnessLifetime();//如果请求里有最大持续时间要求，则取较小的值作为上次响应的刷新时间 if (requestCaching.maxAgeSeconds() != -1) {freshMillis = Math.min(freshMillis, SECONDS.toMillis(requestCaching.maxAgeSeconds()));}

//如果请求里有最短刷新时间要求，则用它来作为最短刷新时间 long minFreshMillis = 0;if (requestCaching.minFreshSeconds() != -1) {minFreshMillis = SECONDS.toMillis(requestCaching.minFreshSeconds());}

//最大过期时间 long maxStaleMillis = 0;//获取缓存响应头中的 CacheControl 信息 CacheControl responseCaching = cacheResponse.cacheControl();//如果缓存响应不是必须要再验证，并且请求有最大过期时间，则用请求的最大过期时间作为最大过期时间 if (!responseCaching.mustRevalidate() && requestCaching.maxStaleSeconds() != -1) {maxStaleMillis = SECONDS.toMillis(requestCaching.maxStaleSeconds());}

//如果支持缓存，并且持续时间+最短刷新时间<上次刷新时间+最大验证时间 则可以缓存 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());}

//构造一个新的有条件的 Request，添加 If-None-Match，If-Modified-Since 等信息 Request.Builder conditionalRequestBuilder = request.newBuilder();

if (etag != null) {conditionalRequestBuilder.header("If-None-Match", etag);} else if (lastModified != null) {conditionalRequestBuilder.header("If-Modified-Since", lastModifiedString);} else if (servedDate != null) {conditionalRequestBuilder.header("If-Modified-Since", servedDateString);}

Request conditionalRequest = conditionalRequestBuilder.build();//根据是否有 If-None-Match，If-Modified-Since 信息，返回不同的缓存策略 return hasConditions(conditionalRequest)? new CacheStrategy(conditionalRequest, cacheResponse): new CacheStrategy(conditionalRequest, null);}

/**

• Returns true if the request contains conditions that save the server from sending a response

• that the client has locally. When a request is enqueued with its own conditions, the built-in

• response cache won't be used.*/private static boolean hasConditions(Request request) {return request.header("If-Modified-Since") != null || request.header("If-None-Match") != null;}}

Cache

对外开放的缓存类，类似数据库能够增删改查

1. 增添缓存

CacheRequest put(Response response) {String requestMethod = response.request().method();//如果请求是"POST","PUT","PATCH","PROPPATCH","REPORT"则移除这些缓存

if (HttpMethod.invalidatesCache(response.request().method())) {try {remove(response.request());} catch (IOException ignored) {}return null;}//仅支持 GET 的请求缓存，其他请求不缓存 if (!requestMethod.equals("GET")) {return null;}//判断请求中的 http 数据包中 headers 是否有符号"*"的通配符，有则不缓存

if (HttpHeaders.hasVaryAll(response)) {return null;}//把 response 构建成一个 Entry 对象 Entry entry = new Entry(response);DiskLruCache.Editor editor = null;try {//生成 DiskLruCache.Editor 对象 editor = cache.edit(key(response.request().url()));if (editor == null) {return null;}//对缓存进行写入 entry.writeTo(editor);//构建一个 CacheRequestImpl 类，包含 Ok.io 的 Sink 对象 return new CacheRequestImpl(editor);} catch (IOException e) {abortQuietly(editor);return null;}}

2. 查找缓存

Response get(Request request) {//获取 url 转换过来的 keyString key = key(request.url());DiskLruCache.Snapshot snapshot;Entry entry;try {//根据 key 获取对应的 snapshotsnapshot = cache.get(key);if (snapshot == null) {return null;}} catch (IOException e) {return null;}try {//创建一个 Entry 对象,并由 snapshot.getSource()获取 Sinkentry = new Entry(snapshot.getSource(ENTRY_METADATA));} catch (IOException e) {Util.closeQuietly(snapshot);return null;}//通过 entry 和 response 生成 respson，通过 Okio.buffer 获取请求体，然后封装各种请求信息 Response response = entry.response(snapshot);if (!entry.matches(request, response)) {//对 request 和 Response 进行比配检查，成功则返回该 Response。Util.closeQuietly(response.body());return null;}return response;}

3. 更新缓存

void update(Response cached, Response network) {//用 Respon 构建一个 EntryEntry entry = new Entry(network);//从缓存中获取 DiskLruCache.SnapshotDiskLruCache.Snapshot snapshot = ((CacheResponseBody) cached.body()).snapshot;DiskLruCache.Editor editor = null;try {//获取 DiskLruCache.Snapshot.edit 对象 editor = snapshot.edit(); // Returns null if snapshot is not current.if (editor != null) {//将 entry 写入 editor 中 entry.writeTo(editor);editor.commit();}} catch (IOException e) {abortQuietly(editor);}}

4. 删除缓存

主体位于 DiskLruCache 之中

void remove(Request request) throws IOException {//通过 url 转化成的 key 去删除缓存 cache.remove(key(request.url()));}

5. writeTo [ok.io](

)

public void writeTo(DiskLruCache.Editor editor) throws IOException {BufferedSink sink = Okio.buffer(editor.newSink(ENTRY_METADATA));

sink.writeUtf8(url).writeByte('\n');sink.writeUtf8(requestMethod).writeByte('\n');sink.writeDecimalLong(varyHeaders.size()).writeByte('\n');for (int i = 0, size = varyHeaders.size(); i < size; i++) {sink.writeUtf8(varyHeaders.name(i)).writeUtf8(": ").writeUtf8(varyHeaders.value(i)).writeByte('\n');}

sink.writeUtf8(new StatusLine(protocol, code, message).toString()).writeByte('\n');sink.writeDecimalLong(responseHeaders.size() + 2).writeByte('\n');for (int i = 0, size = responseHeaders.size(); i < size; i++) {sink.writeUtf8(responseHeaders.name(i)).writeUtf8(": ").writeUtf8(responseHeaders.value(i)).writeByte('\n');}sink.writeUtf8(SENT_MILLIS).writeUtf8(": ").writeDecimalLong(sentRequestMillis).writeByte('\n');sink.writeUtf8(RECEIVED_MILLIS).writeUtf8(": ").writeDecimalLong(receivedResponseMillis).writeByte('\n');

if (isHttps()) {sink.writeByte('\n');sink.writeUtf8(handshake.cipherSuite().javaName()).writeByte('\n');writeCertList(sink, handshake.peerCertificates());writeCertList(sink, handshake.localCertificates());sink.writeUtf8(handshake.tlsVersion().javaName()).writeByte('\n');}sink.close();}

DiskLruCache

真实存储（文件格式）的缓存功能类，使用了基于 LinkedHashedMap。可以看到除了一些关键的方法之外其主要包括了三个重要的内部类。

1. Entry

用于存储缓存数据的实体类，一个 url 对应一个实体,在 Entry 还有 Snapshot 对象

private final class Entry {final String key;

/** Lengths of this entry's files. */final long[] lengths;final File[] cleanFiles;final File[] dirtyFiles;

/** True if this entry has ever been published. */boolean readable;

/** The ongoing edit or null if this entry is not being edited. */Editor currentEditor;

/** The sequence number of the most recently committed edit to this entry. */long sequenceNumber;

Entry(String key) {this.key = key;

lengths = new long[valueCount];cleanFiles = new File[valueCount];dirtyFiles = new File[valueCount];

// The names are repetitive so re-use the same builder to avoid allocations.StringBuilder fileBuilder = new StringBuilder(key).append('.');int truncateTo = fileBuilder.length();for (int i = 0; i < valueCount; i++) {fileBuilder.append(i);cleanFiles[i] = new File(directory, fileBuilder.toString());fileBuilder.append(".tmp");dirtyFiles[i] = new File(directory, fileBuilder.toString());fileBuilder.setLength(truncateTo);}}

/** Set lengths using decimal numbers like "10123". */void setLengths(String[] strings) throws IOException {if (strings.length != valueCount) {throw invalidLengths(strings);