在讲解CacheInterceptor之前，我们先了解一下OkHttp的缓存机制，主要是Cache这个类，演示下如何使用OkHttp的缓存：
private void cacheOkHttpRequest(){
OkHttpClient okHttpClient = new OkHttpClient
.Builder()
.cache(new Cache(new File(Environment.getExternalStorageDirectory()+ "/okttp_caches"),24*1024*1024))
.build();
Request request = new Request
.Builder()
.url("http://www.ifeng.com")
.build();
Call call = okHttpClient.newCall(request);
try {
Response response = call.execute();
Log.e(TAG,"response: " + response.body().string());
} catch (IOException e) {
e.printStackTrace();
}
}
上述代码中在OkHttpClient的Builder中配置了cache，传入缓存目录的File对象以及缓存最大容量(单位字节)，这里请求了凤凰网，请求成功后，OkHttp会将请求的相关数据进行缓存，当下次请求无法链接到网络的时候，它会读取缓存并将数据返回。
根据缓存的流程，我们可以猜测到Cache类会有保存和读取缓存的方法，我们通过查看Cache类的源码，果然发现了put()和get()方法，分别用于保存缓存和读取缓存：
@Nullable CacheRequest put(Response response) {
//获取请求方法
String requestMethod = response.request().method();
//一、传入请求方法，判断是否要缓存
if (HttpMethod.invalidatesCache(response.request().method())) {
try {
remove(response.request());
} catch (IOException ignored) {
// The cache cannot be written.
}
return null;
}
//二、非GET请求的方法不进行缓存
if (!requestMethod.equals("GET")) {
// Don't cache non-GET responses. We're technically allowed to cache
// HEAD requests and some POST requests, but the complexity of doing
// so is high and the benefit is low.
return null;
}
if (HttpHeaders.hasVaryAll(response)) {
return null;
}
//三、创建缓存实体
Entry entry = new Entry(response);
//四、使用 DiskLruCache缓存策略
DiskLruCache.Editor editor = null;
try {
editor = cache.edit(key(response.request().url()));
if (editor == null) {
return null;
}
entry.writeTo(editor);
return new CacheRequestImpl(editor);
} catch (IOException e) {
abortQuietly(editor);
return null;
}
}
在分析这个方法之前，需要先知道的是，OkHttp默认只会对get请求进行缓存，post请求是不会进行缓存，这也是有道理的，因为get请求的数据一般是比较持久的，而post一般是交互操作，没太大意义进行缓存；当然，也可以自己实现post请求的缓存操作，这个需要根据自己的项目需求来。
回到put()方法的分析，上述代码中，先是对请求方法进行了判断，是否需要缓存下来。
注释一处，调用了HttpMethod的invalidatesCache():
public final class HttpMethod {
public static boolean invalidatesCache(String method) {
return method.equals("POST")
|| method.equals("PATCH")
|| method.equals("PUT")
|| method.equals("DELETE")
|| method.equals("MOVE"); // WebDAV
}
...
}
如果请求方法是POST、PATCH、PUT、DELETE以及MOVE中一个，就会将当前请求的缓存移除。
接着判断是否是非GET请求，如果是则不进行缓存。
最后，开始进行缓存的操作，注释三处创建了一个Entry类，传入Response对象，查看其构造方法：
Entry(Response response) {
this.url = response.request().url().toString();
this.varyHeaders = HttpHeaders.varyHeaders(response);
this.requestMethod = response.request().method();
this.protocol = response.protocol();
this.code = response.code();
this.message = response.message();
this.responseHeaders = response.headers();
this.handshake = response.handshake();
this.sentRequestMillis = response.sentRequestAtMillis();
this.receivedResponseMillis = response.receivedResponseAtMillis();
}
Entry会将请求url、头部、请求方式、协议、响应码等一系列参数保存下来。
注释四处，创建缓存策略，OkHttp的缓存策略使用的是DiskLruCache，DiskLruCache是用于磁盘缓存的一套解决框架，OkHttp对DiskLruCache稍微做了点修改，并且OkHttp内部维护着清理内存的线程池，通过这个线程池完成缓存的自动清理和管理工作，本篇不做过多介绍。
获取到DiskLruCache的Editor对象后，通过它的edit方法创建缓存文件，传入缓存的文件名，文件名的生成是通过key()方法将请求url进行MD5加密并获取它的十六进制表示形式。
接着执行Entry对象的writeTo()方法并传入Editor对象，writeTo()方法是将缓存信息存储在本地：
public void writeTo(DiskLruCache.Editor editor) throws IOException {
BufferedSink sink = Okio.buffer(editor.newSink(ENTRY_METADATA));
//缓存请求的url
sink.writeUtf8(url)
.writeByte('\n');
//缓存请求方法
sink.writeUtf8(requestMethod)
.writeByte('\n');
//缓存请求头部大小
sink.writeDecimalLong(varyHeaders.size())
.writeByte('\n');
//缓存请求头部信息
//缓存协议，响应码
//缓存响应头部信息
//缓存发送请求时间以及响应时间
...
//判断是否是https请求
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();
}
上述代码中并没有对响应主体的body进行缓存，在调用Entry的writeTo()方法之后，返回了一个CacheRequestImpl对象：
private final class CacheRequestImpl implements CacheRequest {
private final DiskLruCache.Editor editor;
private Sink cacheOut;
private Sink body;
boolean done;
CacheRequestImpl(final DiskLruCache.Editor editor) {
this.editor = editor;
this.cacheOut = editor.newSink(ENTRY_BODY);
this.body = new ForwardingSink(cacheOut) {
@Override public void close() throws IOException {
synchronized (Cache.this) {
if (done) {
return;
}
done = true;
writeSuccessCount++;
}
super.close();
editor.commit();
}
};
}
这里我们可以看到Repsonse的body是在这里被写入缓存的，CacheRequestImpl实现CacheRequest接口，用于暴露给缓存拦截器，缓存拦截器可以通过这个类来写入或更新缓存的数据。
接下来分析获取缓存的get()方法：
@Nullable Response get(Request request) {
String key = key(request.url());
DiskLruCache.Snapshot snapshot;
Entry entry;
try {
snapshot = cache.get(key);
if (snapshot == null) {
return null;
}
} catch (IOException e) {
// Give up because the cache cannot be read.
return null;
}
try {
entry = new Entry(snapshot.getSource(ENTRY_METADATA));
} catch (IOException e) {
Util.closeQuietly(snapshot);
return null;
}
Response response = entry.response(snapshot);
if (!entry.matches(request, response)) {
Util.closeQuietly(response.body());
return null;
}
return response;
}
显示通过请求的url获取到缓存对应的文件名key，然后创建一个DiskLruCache.Snapshot缓存快照对象，根据key获取对应的缓存快照，如果获取到的为null，则说明没有找到缓存，直接返回null；如果找到对应的缓存快照，则根据快照生成Entry对象，再通过调用Entry的response()方法获取到缓存的Response对象。
response()方法:
public Response response(DiskLruCache.Snapshot snapshot) {
String contentType = responseHeaders.get("Content-Type");
String contentLength = responseHeaders.get("Content-Length");
Request cacheRequest = new Request.Builder()
.url(url)
.method(requestMethod, null)
.headers(varyHeaders)
.build();
return new Response.Builder()
.request(cacheRequest)
.protocol(protocol)
.code(code)
.message(message)
.headers(responseHeaders)
.body(new CacheResponseBody(snapshot, contentType, contentLength))
.handshake(handshake)
.sentRequestAtMillis(sentRequestMillis)
.receivedResponseAtMillis(receivedResponseMillis)
.build();
}
}
这里实际上根据缓存的数据创建了Request请求，并返回生成的Response对象。
获取到缓存的Response对象后，get()方法里将其与传入的request进行比对，如果二者不是成对的，则关闭流且返回null，如果是的话，则返回由缓存数据生成的Response对象。
关于OkHttpClient的缓存机制，这里已经初步介绍完了，本篇主要是为介绍CacheInterceptor做铺垫，下一篇我们将了解第三个拦截器CacheInterceptor缓存拦截器，感兴趣的朋友可以继续阅读：
