okhttp源码分析(三)-CacheInterceptor过滤器

1.okhttp源码分析(一)——基本流程(超详细)
2.okhttp源码分析(二)——RetryAndFollowUpInterceptor过滤器
3.okhttp源码分析(三)——CacheInterceptor过滤器
4.okhttp源码分析(四)——ConnectInterceptor过滤器
5.okhttp源码分析(五)——CallServerInterceptor过滤器

前言

前一篇博客分析了RetryAndFollowUpInterceptor过滤器,紧接着下一个过滤器应该是BridgeInterceptor,但是这个过滤器的作用主要是在对Request和Resposne的封装,源码理解起来也比较好理解,所以就没有分析这个过滤器。直接分析下一个过滤器CacheInterceptor,其实从名字就可以看出这个过滤器的主要作用就是缓存。

分析

1.宏观流程

和上一篇博客的分析相同,按照我的理解,我将过滤器中最关键的方法删减了一下,有助于从宏观上大体对这个过滤器进行理解。

@Override public Response intercept(Chain chain) throws IOException {
    //1
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;
    //2
    if (networkRequest == null && cacheResponse == null) {
      return new Response;
    }
    //3
    if (networkRequest == null) {
      return cacheResponse;
    }
    //4
      networkResponse = chain.proceed(networkRequest);
    //5
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
        return response;
      } 
    }
    //6
    Response response = networkResponse;
    //7
    cache.put(response);

    return response;
  }

好吧,删了点还是比较多的,但是剩下的代码已经比较直白了,很好理解了。其实看过滤器看多了也基本上掌握了基本法,找最关键的那行代码chain.proceed(networkRequest);,上面就是请求前过滤器做的事,下面就是请求后过滤器做的事。
总体上看:

//1
Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

1.尝试通过这个Request拿缓存。

//2
    if (networkRequest == null && cacheResponse == null) {
      return new Response.code(504);
    }

2.如果不允许使用网络并且缓存为空,新建一个504的Resposne返回。

//3
    if (networkRequest == null) {
      return cacheResponse;
    }

3.如果不允许使用网络,但是有缓存,返回缓存。

//4
      networkResponse = chain.proceed(networkRequest);

4.链式调用下一个过滤器。

//5
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        Response response = cacheResponse.newBuilder()
        return response;
      } 
    }

5.如果缓存不为空,但是网络请求得来的返回码是304(如果返回码是304,客户端有缓冲的文档并发出了一个条件性的请求(一般是提供If-Modified-Since头表示客户只想比指定日期更新的文档)。服务器告诉客户,原来缓冲的文档还可以继续使用。)则使用缓存的响应。

//6
    Response response = networkResponse;
    //7
    cache.put(response);

    return response;

6、7.使用网络请求得到的Resposne,并且将这个Resposne缓存起来(前提当然是能缓存)。
接下来就是脑袋都大的细节了,我也不敢说分析的十分详细,只能就我的理解总体分析,学习。

2.过程细节

@Override public Response intercept(Chain chain) throws IOException {
    //默认cache为null,可以配置cache,不为空尝试获取缓存中的response
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();
    //根据response,time,request创建一个缓存策略,用于判断怎样使用缓存
    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.
    //如果缓存策略中禁止使用网络,并且缓存又为空,则构建一个Resposne直接返回,注意返回码=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 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());
      }
    }

    // If we have a cache response too, then we're doing a conditional get.
    //当缓存响应和网络响应同时存在的时候,选择用哪个
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        //如果返回码是304,客户端有缓冲的文档并发出了一个条件性的请求(一般是提供If-Modified-Since头表示客户
        // 只想比指定日期更新的文档)。服务器告诉客户,原来缓冲的文档还可以继续使用。
        //则使用缓存的响应
        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());
      }
    }
    //使用网络响应
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    //所以默认创建的OkHttpClient是没有缓存的
    if (cache != null) {
      //将响应缓存
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        //缓存Resposne的Header信息
        CacheRequest cacheRequest = cache.put(response);
        //缓存body
        return cacheWritingResponse(cacheRequest, response);
      }
      //只能缓存GET....不然移除request
      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

    return response;
  }

首先看第一行代码,一开始以为很简单,但看了后才发现里面涉及的流程非常麻烦。

Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

从逻辑上看,这里还是比较好理解的,通过Request尝试从缓存成功拿对应的缓存Resposne,如果拿到了则赋值,没有则为null。这里重点就要看怎么取缓存了。其实CacheInterceptor重点比较难以理解的就是:拿缓存,缓存策略,存缓存

public final class CacheInterceptor implements Interceptor {
  final InternalCache cache;

  public CacheInterceptor(InternalCache cache) {
    this.cache = cache;
  }
}

//======================RealCall.java======================
interceptors.add(new CacheInterceptor(client.internalCache()));

首先可以看到这里的cache是InternalCache类型,而且是在构造函数的时候调用的。并且通过RealCall也可以看到,构造这个过滤器的时候传入的是我们构造的OkHttpClient中设置的interanlCache,而当我们用默认方式构造OkHttpClient的时候是不会创建缓存的,也就是internalCache=null的

public interface InternalCache {
  Response get(Request request) throws IOException;
  CacheRequest put(Response response) throws IOException;
  void remove(Request request) throws IOException;
  void update(Response cached, Response network);
  void trackConditionalCacheHit();

  void trackResponse(CacheStrategy cacheStrategy);
}

不出意外,InternalCache是一个接口,OkHttp充分贯彻了面向接口编程。接着查找OkHttp中哪个实现了或者说使用了这个接口,对应找到了Cache这个类。

public final class Cache implements Closeable, Flushable {
  final InternalCache internalCache = new InternalCache() {
    @Override public Response get(Request request) throws IOException {
      return Cache.this.get(request);
    }
  };

@Nullable Response get(Request request) {
    String key = key(request.url());
    DiskLruCache.Snapshot snapshot;
    Entry entry;
    try {
      snapshot = cache.get(key);
      if (snapshot == null) {
        //没拿到,返回null
        return null;
      }
    } catch (IOException e) {
      // Give up because the cache cannot be read.
      return null;
    }

    try {
      //创建一个Entry,这里其实传入的是CleanFiles数组的第一个(ENTRY_METADATA = 0)得到是头信息,也就是key.0
      entry = new Entry(snapshot.getSource(ENTRY_METADATA));
    } catch (IOException e) {
      Util.closeQuietly(snapshot);
      return null;
    }
    //得到缓存构建得到的response
    Response response = entry.response(snapshot);

    if (!entry.matches(request, response)) {
      Util.closeQuietly(response.body());
      return null;
    }

    return response;
  }

可以看到,Cache中实现了InternalCache这个接口,get()方法对应调用的是Cache类中的get方法。所以现在就要看get方法了。

String key = key(request.url());

首先,通过这行代码我们了解到,缓存的Key是和request的url直接相关的。这里通过url,得到了缓存的key。

final DiskLruCache cache;
=============================
DiskLruCache.Snapshot snapshot;
    Entry entry;
    try {
      snapshot = cache.get(key);
      if (snapshot == null) {
        //没拿到,返回null
        return null;
      }
    } catch (IOException e) {
      // Give up because the cache cannot be read.
      return null;
    }

下面刚开始看到的时候对各种变量是很难理解的,这里就先不要管,随着后面分析的深入,会理解这里的snapshot变量。可以看到这里得到key后,又会走cache.get()方法,好吧,又要再进入看了。首先要明白,这里的cache对应的类型是DiskLruCache。

public synchronized Snapshot get(String key) throws IOException {
    //总结来说就是对journalFile文件的操作,有则删除无用冗余的信息,构建新文件,没有则new一个新的
    initialize();
    //判断是否关闭,如果缓存损坏了,会被关闭
    checkNotClosed();
    //检查key是否满足格式要求,正则表达式
    validateKey(key);
    //获取key对应的entry
    Entry entry = lruEntries.get(key);
    if (entry == null || !entry.readable) return null;
    //获取entry里面的snapshot的值
    Snapshot snapshot = entry.snapshot();
    if (snapshot == null) return null;
    //有则计数器+1
    redundantOpCount++;
    //把这个内容写入文档中
    journalWriter.writeUtf8(READ).writeByte(' ').writeUtf8(key).writeByte('\n');
    //判断是否达清理条件
    if (journalRebuildRequired()) {

      executor.execute(cleanupRunnable);
    }

    return snapshot;
  }

进入到DisLruCache内部,首先执行的是initialize()方法。

public synchronized void initialize() throws IOException {
    //断言,当持有自己锁的时候。继续执行,没有持有锁,直接抛异常
    assert Thread.holdsLock(this);
    //如果初始化过,则直接跳出
    if (initialized) {
      return; // Already initialized.
    }

    // If a bkp file exists, use it instead.
    //如果有journalFileBackup这个文件
    if (fileSystem.exists(journalFileBackup)) {
      // If journal file also exists just delete backup file.
      //如果有journalFile这个文件
      if (fileSystem.exists(journalFile)) {
        //删除journalFileBackup这个文件
        fileSystem.delete(journalFileBackup);
      } else {
        //没有journalFile这个文件,并且有journalFileBackup这个文件,则将journalFileBackup改名为journalFile
        fileSystem.rename(journalFileBackup, journalFile);
      }
    }
    //最后的结果只有两种:1.什么都没有2.有journalFile文件

    // Prefer to pick up where we left off.
    if (fileSystem.exists(journalFile)) {
      //如果有journalFile文件
      try {
        readJournal();
        processJournal();
        //标记初始化完成
        initialized = true;
        return;
      } catch (IOException journalIsCorrupt) {
        Platform.get().log(WARN, "DiskLruCache " + directory + " is corrupt: "
            + journalIsCorrupt.getMessage() + ", removing", journalIsCorrupt);
      }

      // The cache is corrupted, attempt to delete the contents of the directory. This can throw and
      // we'll let that propagate out as it likely means there is a severe filesystem problem.
      try {
        //有缓存损坏导致异常,则删除缓存目录下所有文件
        delete();
      } finally {
        closed = false;
      }
    }
    //如果没有则重新创建一个
    rebuildJournal();
    //标记初始化完成,无论有没有journal文件,initialized都会标记为true,只执行一遍
    initialized = true;
  }

总算不用再进入看了,这里assert断言保证这个方法是线程安全的。接着通过对initialized变量来判断,如果初始化过,则直接return。

//如果有journalFileBackup这个文件
    if (fileSystem.exists(journalFileBackup)) {
      // If journal file also exists just delete backup file.
      //如果有journalFile这个文件
      if (fileSystem.exists(journalFile)) {
        //删除journalFileBackup这个文件
        fileSystem.delete(journalFileBackup);
      } else {
        //没有journalFile这个文件,并且有journalFileBackup这个文件,则将journalFileBackup改名为journalFile
        fileSystem.rename(journalFileBackup, journalFile);
      }
    }

这里首先说明一下journalFile指的是日志文件,是对缓存一系列操作的记录,不影响缓存的执行流程。
可以看到这里有两个文件journalFile和journalFileBackup,从名字上可以确定,一个是备份文件,一个是记录文件,随着后面的分析,会发现缓存中充分利用的两个文件,这种形式,一个用于保存,一个用于编辑操作。
这里的判断就很好理解了,如果有journalFileBackup这个文件,并且有journalFile这个文件,则删除journalFileBackup这个没用的文件;如果没有journalFile但是有journalFileBackup这个文件,则将journalFileBackup命名为journalFile。最终可以得出,最后用于保存的其实是journalFile文件。这里执行完后最后的结果只有两种:1.什么都没有2.有journalFile文件

if (fileSystem.exists(journalFile)) {
      //如果有journalFile文件
      try {
        readJournal();
        processJournal();
        //标记初始化完成
        initialized = true;
        return;
      } catch (IOException journalIsCorrupt) {
        Platform.get().log(WARN, "DiskLruCache " + directory + " is corrupt: "
            + journalIsCorrupt.getMessage() + ", removing", journalIsCorrupt);
      }

      // The cache is corrupted, attempt to delete the contents of the directory. This can throw and
      // we'll let that propagate out as it likely means there is a severe filesystem problem.
      try {
        //有缓存损坏导致异常,则删除缓存目录下所有文件
        delete();
      } finally {
        closed = false;
      }
    }

当存在journalFile,执行readJournal(),读取journalFile文件。

private void readJournal() throws IOException {
    //利用Okio读取journalFile文件
    BufferedSource source = Okio.buffer(fileSystem.source(journalFile));
    try {
      String magic = source.readUtf8LineStrict();
      String version = source.readUtf8LineStrict();
      String appVersionString = source.readUtf8LineStrict();
      String valueCountString = source.readUtf8LineStrict();
      String blank = source.readUtf8LineStrict();
      //保证和默认值相同
      if (!MAGIC.equals(magic)
          || !VERSION_1.equals(version)
          || !Integer.toString(appVersion).equals(appVersionString)
          || !Integer.toString(valueCount).equals(valueCountString)
          || !"".equals(blank)) {
        throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
            + valueCountString + ", " + blank + "]");
      }

      int lineCount = 0;
      while (true) {
        try {
          //逐行读取,并根据每行的开头,不同的状态执行不同的操作,主要就是往lruEntries里面add,或者remove
          readJournalLine(source.readUtf8LineStrict());
          lineCount++;
        } catch (EOFException endOfJournal) {
          break;
        }
      }
      //日志操作的记录数=总行数-lruEntries中实际add的行数
      redundantOpCount = lineCount - lruEntries.size();
      //source.exhausted()表示是否还多余字节,如果没有多余字节,返回true,有多余字节返回false
      // If we ended on a truncated line, rebuild the journal before appending to it.
      if (!source.exhausted()) {
        //如果有多余的字节,则重新构建下journal文件
        rebuildJournal();
      } else {
        //获取这个文件的Sink,以便Writer
        journalWriter = newJournalWriter();
      }
    } finally {
      Util.closeQuietly(source);
    }
  }

可以看到这里用到了使用OkHttp必须要依赖的库Okio,这个库内部对输入输出流进行了很多优化,分帧读取写入,帧还有池的概念,具体原理可以网上去学习。

String magic = source.readUtf8LineStrict();
      String version = source.readUtf8LineStrict();
      String appVersionString = source.readUtf8LineStrict();
      String valueCountString = source.readUtf8LineStrict();
      String blank = source.readUtf8LineStrict();
      //保证和默认值相同
      if (!MAGIC.equals(magic)
          || !VERSION_1.equals(version)
          || !Integer.toString(appVersion).equals(appVersionString)
          || !Integer.toString(valueCount).equals(valueCountString)
          || !"".equals(blank)) {
        throw new IOException("unexpected journal header: [" + magic + ", " + version + ", "
            + valueCountString + ", " + blank + "]");
      }

这里利用Okio读取journalFile,前面主要是逐行读取一些参数,进行校验,保证这些参数的正确性。

int lineCount = 0;
      while (true) {
        try {
          //逐行读取,并根据每行的开头,不同的状态执行不同的操作,主要就是往lruEntries里面add,或者remove
          readJournalLine(source.readUtf8LineStrict());
          lineCount++;
        } catch (EOFException endOfJournal) {
          break;
        }
      }

校验成功了,就进行逐行读取,所以这里需要看一下readJournalLine()方法。

private void readJournalLine(String line) throws IOException {
    //记录第一个空串的位置
    int firstSpace = line.indexOf(' ');
    if (firstSpace == -1) {
      throw new IOException("unexpected journal line: " + line);
    }

    int keyBegin = firstSpace + 1;
    //记录第二个空串的位置
    int secondSpace = line.indexOf(' ', keyBegin);
    final String key;
    if (secondSpace == -1) {
      //如果中间没有空串,则直接截取得到key
      key = line.substring(keyBegin);
      //如果解析出来的是"REMOVE skjdglajslkgjl"这样以REMOVE开头
      if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
        //移除这个key,lruEntries是LinkedHashMap
        lruEntries.remove(key);
        return;
      }
    } else {
      //解析两个空格间的字符串为key
      key = line.substring(keyBegin, secondSpace);
    }
    //取出Entry对象
    Entry entry = lruEntries.get(key);
    //如果Enty对象为null
    if (entry == null) {
      //new一个Entry,put进去
      entry = new Entry(key);
      lruEntries.put(key, entry);
    }
    //如果是“CLEAN 1 2”这样的以CLAEN开头
    if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
      //取第二个空格后面的字符串,parts变成[1,2]
      String[] parts = line.substring(secondSpace + 1).split(" ");
      //可读
      entry.readable = true;
      //不被编辑
      entry.currentEditor = null;
      //设置长度
      entry.setLengths(parts);
    } else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
      //如果是“DIRTY lskdjfkl”这样以DIRTY开头,新建一个Editor
      entry.currentEditor = new Editor(entry);
    } else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
      //如果是“READ slkjl”这样以READ开头,不需要做什么事
      // This work was already done by calling lruEntries.get().
    } else {
      throw new IOException("unexpected journal line: " + line);
    }
  }

这里一开始可能比较难以理解,说明一下journalFile每一行的保存格式是这样的:REMOVE sdkjlg 2341 1234
第一个空格前面代表这条日志的操作内容,后面的第一个个保存的是key,后面这两个内容根据前面的操作存入缓存内容对应的length...

if (secondSpace == -1) {
      //如果中间没有空串,则直接截取得到key
      key = line.substring(keyBegin);
      //如果解析出来的是"REMOVE skjdglajslkgjl"这样以REMOVE开头
      if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
        //移除这个key,lruEntries是LinkedHashMap
        lruEntries.remove(key);
        return;
      }
    } else {
      //解析两个空格间的字符串为key
      key = line.substring(keyBegin, secondSpace);
    }

如果没有第二个空格,那么数据格式就是这样的REMOVE skjdglajslkgjl
截取第一个空格后面的内容作为key,如果是以REMOVE开头,则从lruEntries中移除这个key对应的缓存。

final LinkedHashMap<String, Entry> lruEntries = new LinkedHashMap<>(0, 0.75f, true);

这里说明一下,使用一个LinkedHashMap保存的。
如果有第二个空格,则还是去第一个和第二个空格之间的内容当做key。

//取出Entry对象
    Entry entry = lruEntries.get(key);
    //如果Enty对象为null
    if (entry == null) {
      //new一个Entry,put进去
      entry = new Entry(key);
      lruEntries.put(key, entry);
    }

并且尝试取这个key对应的Entry,如果没有,则new一个put进入。

//如果是“CLEAN jklldsg 2 5”这样的以CLAEN开头
    if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
      //取第二个空格后面的字符串,parts变成[1,2]
      String[] parts = line.substring(secondSpace + 1).split(" ");
      //可读
      entry.readable = true;
      //不被编辑
      entry.currentEditor = null;
      //设置长度
      entry.setLengths(parts);
    }

CLEAN jklldsg 2 5如果是以CLEAN开头的话,则将取出key后面的数组,设置可读,不可编辑,设置entry的长度。这里先说明一下Entry类。

private final class Entry {
    final String key;

    /** Lengths of this entry's files. */
    final long[] lengths;
    //用于保存持久数据,作用是读取 最后的格式:key.0
    final File[] cleanFiles;
    //用于保存编辑的临时数据,作用是写,最后的格式:key.0.tmp
    final File[] dirtyFiles;
}

我的理解是,Entry中有两个数组,cleanFile是用于保存持久性数据,用于读取,dirtyFiles是用于进行编辑,当编辑完成后会执行commit操作,将dirtyFile赋值给cleanFile。length适用于保存Entry中每个数组对应的file的数量。
所以当CLEAN jklldsg 2 5如果是以CLEAN开头的话,cleanFiles对应的size就是2,dirtyFiles对应的数量是5(默认都是2个)

else if (secondSpace == -1 && firstSpace == DIRTY.length() && line.startsWith(DIRTY)) {
      //如果是“DIRTY lskdjfkl”这样以DIRTY开头,新建一个Editor
      entry.currentEditor = new Editor(entry);
    } else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
      //如果是“READ slkjl”这样以READ开头,不需要做什么事
      // This work was already done by calling lruEntries.get().
    } else {
      throw new IOException("unexpected journal line: " + line);
    }

上面理解了,后面其实也就对应很好理解了,如果是以DIRTY开头,则新建一个Editor表示这个Entry可以编辑。如果是READ开头,则不需要做任何事。
到此结束了对readJournalLine()方法的分析,总结一下这个方法的作用:逐行读取,并根据每行的开头,不同的状态执行不同的操作,主要就是往lruEntries里面add,或者remove。接着返回到readJournal()方法中。

while (true) {
        try {
          //逐行读取,并根据每行的开头,不同的状态执行不同的操作,主要就是往lruEntries里面add,或者remove
          readJournalLine(source.readUtf8LineStrict());
          lineCount++;
        } catch (EOFException endOfJournal) {
          break;
        }
      }

可以看到这里,利用lineCount记录读取的行数。

//日志中操作的记录数=总行数-lruEntries中实际add的行数
      redundantOpCount = lineCount - lruEntries.size();
      //source.exhausted()表示是否还多余字节,如果没有多余字节,返回true,有多余字节返回false
      // If we ended on a truncated line, rebuild the journal before appending to it.
      if (!source.exhausted()) {
        //如果有多余的字节,则重新构建下journal文件
        rebuildJournal();
      } else {
        //获取这个文件的Sink,以便Writer
        journalWriter = newJournalWriter();
      }

读取完毕后会计算日志中操作的记录数,日志中操作的记录数=读取的总行数-lruEntries中实际保存的行数。
接下来source.exhausted()是表示是否还多余字节,如果没有多余字节,返回true,有多余字节返回false,如果有多余的字节则需要执行rebuildJournal(),没有则获得这个文件的Sink,用于Write操作。

synchronized void rebuildJournal() throws IOException {
    if (journalWriter != null) {
      journalWriter.close();
    }

    BufferedSink writer = Okio.buffer(fileSystem.sink(journalFileTmp));
    try {
      //写入校验信息
      writer.writeUtf8(MAGIC).writeByte('\n');
      writer.writeUtf8(VERSION_1).writeByte('\n');
      writer.writeDecimalLong(appVersion).writeByte('\n');
      writer.writeDecimalLong(valueCount).writeByte('\n');
      writer.writeByte('\n');
      //利用刚才逐行读的内容按照格式重新构建
      for (Entry entry : lruEntries.values()) {
        if (entry.currentEditor != null) {
          writer.writeUtf8(DIRTY).writeByte(' ');
          writer.writeUtf8(entry.key);
          writer.writeByte('\n');
        } else {
          writer.writeUtf8(CLEAN).writeByte(' ');
          writer.writeUtf8(entry.key);
          entry.writeLengths(writer);
          writer.writeByte('\n');
        }
      }
    } finally {
      writer.close();
    }
    //用新构建的journalFileTmp替换当前的journalFile文件
    if (fileSystem.exists(journalFile)) {
      fileSystem.rename(journalFile, journalFileBackup);
    }
    fileSystem.rename(journalFileTmp, journalFile);
    fileSystem.delete(journalFileBackup);

    journalWriter = newJournalWriter();
    hasJournalErrors = false;
    mostRecentRebuildFailed = false;
  }

可以看到这里主要是将lruEntries中保存的内容逐行写成一个journalFileTmp,将新构建的journalFileTmp替换当前包含冗余信息的journalFile文件,达到重新构建的效果。
到这里readJournal()方法分析完了,总结下这个方法的作用:主要是读取journalFile,根据日志文件中的日志信息,过滤无用冗余的信息,有冗余的则重新构建,最后保证journalFile日志文件没有冗余信息。

执行完readJournal()方法,回到initialize()方法中。

    try {
        readJournal();
        processJournal();
        //标记初始化完成
        initialized = true;
        return;
      } catch (IOException journalIsCorrupt) {
        Platform.get().log(WARN, "DiskLruCache " + directory + " is corrupt: "
            + journalIsCorrupt.getMessage() + ", removing", journalIsCorrupt);
      }

这里需要看一下processJournal()方法

private void processJournal() throws IOException {
    //删除journalFileTmp文件
    fileSystem.delete(journalFileTmp);
    for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
      Entry entry = i.next();
      if (entry.currentEditor == null) {
        //表明数据是CLEAN,循环记录SIZE
        for (int t = 0; t < valueCount; t++) {
          size += entry.lengths[t];
        }
      } else {
        //表明数据是DIRTY,删除
        entry.currentEditor = null;
        for (int t = 0; t < valueCount; t++) {
          fileSystem.delete(entry.cleanFiles[t]);
          fileSystem.delete(entry.dirtyFiles[t]);
        }
        //移除Entry
        i.remove();
      }
    }
  }

可以看到,这里删除了刚才创建的journalFileTmp文件,并且遍历lruEntries,记录不可编辑的数据长度size(也就是CLEAN),删除DIRTY数据,也就是只保留CLEAN持久性数据,删除编辑的数据。

    try {
        readJournal();
        processJournal();
        //标记初始化完成
        initialized = true;
        return;
      } catch (IOException journalIsCorrupt) {
        Platform.get().log(WARN, "DiskLruCache " + directory + " is corrupt: "
            + journalIsCorrupt.getMessage() + ", removing", journalIsCorrupt);
      }

可以看到到这里,接下来的就是将initialized标记为true,表示初始化完成。到这里其实initialize已经完成了,继续看initialize()方法。
后面就比较简单了,当没有journalFile,则会调用我们刚才分析过的方法rebuildJournal()重新创建一个日志文件,仍然将initialized标记为true,说明无论有没有journal文件,initialized都会标记为true,只执行一遍。
到这里总算将initialize()分析完了,这里总结一下这个方法:

1.这个方法线程安全
2.如果初始化过了,则什么都不干,只初始化一遍
3.如果有journalFile日志文件,则对journalFile文件和lruEntries进行初始化操作,主要是删除冗余信息,和DIRTY信息。
4.没有则构建一个journalFile文件。

到这initialize()方法总算分析完了,接下来回到get()方法中,剩下的其实就容易点了。
接下来这些都没有什么重要的地方,我注释都写的很清楚,总结一下get()方法的主要操作:

1.初始化日志文件和lruEntries
2.检查保证key正确后获取缓存中保存的Entry。
3.操作计数器+1
4.往日志文件中写入这次的READ操作。
5.根据redundantOpCount判断是否需要清理日志信息。
6.需要则开启线程清理。
7.不需要则返回缓存。

这里看一下两个地方,第一个journalRebuildRequired()用于判断是否需要清理缓存。

boolean journalRebuildRequired() {
    final int redundantOpCompactThreshold = 2000;
    //清理的条件是当前redundantOpCount大于2000,并且redundantOpCount的值大于linkedList里面的size
    return redundantOpCount >= redundantOpCompactThreshold
        && redundantOpCount >= lruEntries.size();
  }

可以看到清理的条件是当前redundantOpCount大于2000,并且redundantOpCount的值大于linkedList里面的size。
下面一个需要看的地方就是清理线程cleanupRunnable。

private final Runnable cleanupRunnable = new Runnable() {
    public void run() {
      synchronized (DiskLruCache.this) {
        //如果没有初始化或者已经关闭了,则不需要清理,这里注意|和||的区别,|会两个条件都检查
        if (!initialized | closed) {
          return; // Nothing to do
        }

        try {
          //清理
          trimToSize();
        } catch (IOException ignored) {
          mostRecentTrimFailed = true;
        }

        try {
          if (journalRebuildRequired()) {
            //如果还要清理,重新构建
            rebuildJournal();
            //计数器置0
            redundantOpCount = 0;
          }
        } catch (IOException e) {
          //如果抛异常了,设置最近的一次构建失败
          mostRecentRebuildFailed = true;
          journalWriter = Okio.buffer(Okio.blackhole());
        }
      }
    }
  };

这里先总结一下这里的操作流程:

1.如果还没有初始化或者缓存关闭了,则不清理。
2.执行清理操作。
3.如果清理完了还是判断后还需要清理,只能重新构建日志文件,并且日志记录器记0。

这里主要就需要看一下清理操作trimToSize()

void trimToSize() throws IOException {
    //遍历直到满足大小
    while (size > maxSize) {
      Entry toEvict = lruEntries.values().iterator().next();
      removeEntry(toEvict);
    }
    mostRecentTrimFailed = false;
  }

可以看到这里就是一个遍历,知道满足maxSize条件,这里的maxSize是可以设置的。

boolean removeEntry(Entry entry) throws IOException {
    if (entry.currentEditor != null) {
      //结束editor
      entry.currentEditor.detach(); // Prevent the edit from completing normally.
    }

    for (int i = 0; i < valueCount; i++) {
      //清除用于保存文件的cleanFiles
      fileSystem.delete(entry.cleanFiles[i]);
      size -= entry.lengths[i];
      entry.lengths[i] = 0;
    }
    //计数器加1
    redundantOpCount++;
    //增加一条删除日志
    journalWriter.writeUtf8(REMOVE).writeByte(' ').writeUtf8(entry.key).writeByte('\n');
    //移除entry
    lruEntries.remove(entry.key);
    //如果需要重新清理一下,边界情况
    if (journalRebuildRequired()) {
      //清理
      executor.execute(cleanupRunnable);
    }

    return true;
  }

这里的执行流程:

1.停止编辑操作
2.清楚用于保存的cleanFiles
3.增加一条清楚日志记录,计数器+1
4.移除对应key的entry
5.由于增加了一条日志,判断是否需要清理,不然可能会越清越多...

至此,get()方法终于分析完成了,接着就要返回Cache中的get()方法继续看。

@Nullable Response get(Request request) {
    String key = key(request.url());
    DiskLruCache.Snapshot snapshot;
    Entry entry;
    try {
      snapshot = cache.get(key);
      if (snapshot == null) {
        //没拿到,返回null
        return null;
      }
    } catch (IOException e) {
      // Give up because the cache cannot be read.
      return null;
    }

    try {
      //创建一个Entry,这里其实传入的是CleanFiles数组的第一个(ENTRY_METADATA = 0)得到是头信息,也就是key.0
      entry = new Entry(snapshot.getSource(ENTRY_METADATA));
    } catch (IOException e) {
      Util.closeQuietly(snapshot);
      return null;
    }
    //得到缓存构建得到的response
    Response response = entry.response(snapshot);

    if (!entry.matches(request, response)) {
      Util.closeQuietly(response.body());
      return null;
    }

    return response;
  }

这里一样,先总结一下get()方法的具体流程。

1.通过执行DiskLruCache的get方法拿到snapshot信息。
2.通过拿到的snapshot信息,取cleanFiles[0]中保存的头信息,构建头相关的信息的Entry.
3.通过snapshot中的cleanFiles[1]构建body信息,最终构建成缓存中保存的Response。
4.返回缓存中保存的Resposne。

可以看到这里的重点是先构建header,再构建body,最后组合成Resposne。对应的两个流程这里分析一下,

try {
      //创建一个Entry,这里其实传入的是CleanFiles数组的第一个(ENTRY_METADATA = 0)得到是头信息,也就是key.0
      entry = new Entry(snapshot.getSource(ENTRY_METADATA));
    } catch (IOException e) {
      Util.closeQuietly(snapshot);
      return null;
    }

可以看到,这里通过得到的snapshot.getSource构建了Entry(这个Entry是Cache的内部类,不是DiskLruCache的内部类)。这里注意一个地方,这里的ENTRY_METADATA = 0。

public final class Snapshot implements Closeable {
    private final String key;
    private final long sequenceNumber;
    private final Source[] sources;
    private final long[] lengths;

    Snapshot(String key, long sequenceNumber, Source[] sources, long[] lengths) {
      this.key = key;
      this.sequenceNumber = sequenceNumber;
      this.sources = sources;
      this.lengths = lengths;
    }
    public Source getSource(int index) {
      return sources[index];
    }
}

可以看到这里的getSource其实就是返回Source数组中的元素,而Source数组是在Snapshot的构造函数的时候赋值,所以对应的可以找构造Snapshot的地方。

Snapshot snapshot() {
      if (!Thread.holdsLock(DiskLruCache.this)) throw new AssertionError();

      Source[] sources = new Source[valueCount];
      long[] lengths = this.lengths.clone(); // Defensive copy since these can be zeroed out.
      try {
        for (int i = 0; i < valueCount; i++) {
          //可以看到这里其实是将cleanFiles传给了sources
          sources[i] = fileSystem.source(cleanFiles[i]);
        }
        return new Snapshot(key, sequenceNumber, sources, lengths);
      } catch (FileNotFoundException e) {
        // A file must have been deleted manually!
        for (int i = 0; i < valueCount; i++) {
          if (sources[i] != null) {
            Util.closeQuietly(sources[i]);
          } else {
            break;
          }
        }
        // Since the entry is no longer valid, remove it so the metadata is accurate (i.e. the cache
        // size.)
        try {
          removeEntry(this);
        } catch (IOException ignored) {
        }
        return null;
      }
    }

看到这个方法,其实应该注意到这个就是我们在调用DiskLruCache中的get()方法时最后返回Snapshot调用的方法,具体下方代码贴出了,这时候可以看到source数组其实是将entry中的cleanfile数组对应的保存到source数组中,这也验证了我们前面说的clean数组是用来保存持久性数据,也就是真正用来存东西的地方,而且记得前面提到ENTRY_METADATA = 0,所以对应的取的也是clean数组中的第一个文件,也验证了前面说的clean数组分两部分,第一部分保存头,第二部分保存body

public synchronized Snapshot get(String key) throws IOException {
    ...
    Snapshot snapshot = entry.snapshot();
    ...
  }

getSource看完了,这时候来看一下Cache中Entry这个内部类,注意不是DiskLruCache中的Entry

Entry(Source in) throws IOException {
      try {
        BufferedSource source = Okio.buffer(in);
        url = source.readUtf8LineStrict();
        requestMethod = source.readUtf8LineStrict();
        //得到cleanfiles[0]来构建头信息
        Headers.Builder varyHeadersBuilder = new Headers.Builder();
        int varyRequestHeaderLineCount = readInt(source);
        for (int i = 0; i < varyRequestHeaderLineCount; i++) {
          varyHeadersBuilder.addLenient(source.readUtf8LineStrict());
        }
        varyHeaders = varyHeadersBuilder.build();

        StatusLine statusLine = StatusLine.parse(source.readUtf8LineStrict());
        protocol = statusLine.protocol;
        code = statusLine.code;
        message = statusLine.message;
        Headers.Builder responseHeadersBuilder = new Headers.Builder();
        int responseHeaderLineCount = readInt(source);
        for (int i = 0; i < responseHeaderLineCount; i++) {
          responseHeadersBuilder.addLenient(source.readUtf8LineStrict());
        }
        String sendRequestMillisString = responseHeadersBuilder.get(SENT_MILLIS);
        String receivedResponseMillisString = responseHeadersBuilder.get(RECEIVED_MILLIS);
        responseHeadersBuilder.removeAll(SENT_MILLIS);
        responseHeadersBuilder.removeAll(RECEIVED_MILLIS);
        sentRequestMillis = sendRequestMillisString != null
            ? Long.parseLong(sendRequestMillisString)
            : 0L;
        receivedResponseMillis = receivedResponseMillisString != null
            ? Long.parseLong(receivedResponseMillisString)
            : 0L;
        //构建了header
        responseHeaders = responseHeadersBuilder.build();

        if (isHttps()) {
          String blank = source.readUtf8LineStrict();
          if (blank.length() > 0) {
            throw new IOException("expected \"\" but was \"" + blank + "\"");
          }
          String cipherSuiteString = source.readUtf8LineStrict();
          CipherSuite cipherSuite = CipherSuite.forJavaName(cipherSuiteString);
          List<Certificate> peerCertificates = readCertificateList(source);
          List<Certificate> localCertificates = readCertificateList(source);
          TlsVersion tlsVersion = !source.exhausted()
              ? TlsVersion.forJavaName(source.readUtf8LineStrict())
              : TlsVersion.SSL_3_0;
          handshake = Handshake.get(tlsVersion, cipherSuite, peerCertificates, localCertificates);
        } else {
          handshake = null;
        }
      } finally {
        in.close();
      }
    }

这里通过Entry的构造方法更能说明clean数组中的第一项是用来保存header信息的,从代码中可以看到利用Header.builder对传入进来的Source(也就是clean[0])进行构建,最后利用build()方法构建了header信息。

头构建完了,现在就需要找构建body的地方,因为剩下的代码只剩下

//得到缓存构建得到的response
    Response response = entry.response(snapshot);

//Entry内部类
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();
    }

大体上一看,这个方法的作用基本上就是利用Resposne.builder构建缓存中的Resposne了,但是没有找到明显的写入Body的地方,唯一由body的就是
.body(new CacheResponseBody(snapshot, contentType, contentLength)),所以只能进入CacheResponseBody的构造函数中。

CacheResponseBody(final DiskLruCache.Snapshot snapshot,
        String contentType, String contentLength) {
      this.snapshot = snapshot;
      this.contentType = contentType;
      this.contentLength = contentLength;
      //这里ENTRY_BODY=1,同样拿的是CleanFiles数组,构建Responsebody
      Source source = snapshot.getSource(ENTRY_BODY);
      bodySource = Okio.buffer(new ForwardingSource(source) {
        @Override public void close() throws IOException {
          snapshot.close();
          super.close();
        }
      });
    }

可以看到终于发现了和刚才Header一样的代码,这里ENTRY_BODY=1,对应的还是取source数组中的下标为1的地方,构建body。到现在可以看出来,clean数组的0对应保存的Header信息,1对应保存的BODY信息。

这里分析完构建header和body得到对应的缓存的Resposne后,对应非常长长长的从缓存中拿缓存的Resposne流程终于结束。
其实到这里,缓存的主要思想其实已经理解大概了后面的的其实就比较好理解了。这里get()方法结束了,也终于要回到CacheInterceptor的主要方法中了。这里再放一遍代码,因为翻上去太长了。。。

@Override public Response intercept(Chain chain) throws IOException {
    //默认cache为null,可以配置cache,不为空尝试获取缓存中的response
    Response cacheCandidate = cache != null
        ? cache.get(chain.request())
        : null;

    long now = System.currentTimeMillis();
    //根据response,time,request创建一个缓存策略,用于判断怎样使用缓存
    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.
    //如果缓存策略中禁止使用网络,并且缓存又为空,则构建一个Resposne直接返回,注意返回码=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 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());
      }
    }

    // If we have a cache response too, then we're doing a conditional get.
    //当缓存响应和网络响应同时存在的时候,选择用哪个
    if (cacheResponse != null) {
      if (networkResponse.code() == HTTP_NOT_MODIFIED) {
        //如果返回码是304,客户端有缓冲的文档并发出了一个条件性的请求(一般是提供If-Modified-Since头表示客户
        // 只想比指定日期更新的文档)。服务器告诉客户,原来缓冲的文档还可以继续使用。
        //则使用缓存的响应
        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());
      }
    }
    //使用网络响应
    Response response = networkResponse.newBuilder()
        .cacheResponse(stripBody(cacheResponse))
        .networkResponse(stripBody(networkResponse))
        .build();
    //所以默认创建的OkHttpClient是没有缓存的
    if (cache != null) {
      //将响应缓存
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        //缓存Resposne的Header信息
        CacheRequest cacheRequest = cache.put(response);
        //缓存body
        return cacheWritingResponse(cacheRequest, response);
      }
      //只能缓存GET....不然移除request
      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

    return response;
  }

这里就可以分析CacheInterceptor的主要流程了。

1.通过Request尝试到Cache中拿缓存(里面非常多流程),当然前提是OkHttpClient中配置了缓存,默认是不支持的。
2.根据response,time,request创建一个缓存策略,用于判断怎样使用缓存。
3.如果缓存策略中设置禁止使用网络,并且缓存又为空,则构建一个Resposne直接返回,注意返回码=504
4.缓存策略中设置不使用网络,但是又缓存,直接返回缓存
5.接着走后续过滤器的流程,chain.proceed(networkRequest)
6.当缓存存在的时候,如果网络返回的Resposne为304,则使用缓存的Resposne。
7.构建网络请求的Resposne
8.当在OKHttpClient中配置了缓存,则将这个Resposne缓存起来。
9.缓存起来的步骤也是先缓存header,再缓存body。
10.返回Resposne。

这里要注意的是2,9两个点。其中2对应的是CacheStrategy这个类,里面主要涉及Http协议中缓存的相关设置,具体的我也没太搞明白,准备入手一本Http的书好好研究研究。但是这里不影响理解主要流程。
下面就是对9,也就是存缓存这个步骤的分析了,其实前面的取缓存的分析结束后,这里对存缓存不难猜测其实是想对应的,也就比较好理解了,对应的大体应该是header存入clean[0],body存入clean[1]。这里详细看一下。

if (cache != null) {
      //将响应缓存
      if (HttpHeaders.hasBody(response) && CacheStrategy.isCacheable(response, networkRequest)) {
        // Offer this request to the cache.
        //缓存Resposne的Header信息
        CacheRequest cacheRequest = cache.put(response);
        //缓存body
        return cacheWritingResponse(cacheRequest, response);
      }
      //只能缓存GET....不然移除request
      if (HttpMethod.invalidatesCache(networkRequest.method())) {
        try {
          cache.remove(networkRequest);
        } catch (IOException ignored) {
          // The cache cannot be written.
        }
      }
    }

当可以缓存的时候,这里用了cache.put(response)方法。

@Nullable CacheRequest put(Response response) {
    String requestMethod = response.request().method();

    if (HttpMethod.invalidatesCache(response.request().method())) {
      //OKhttp只能缓存GET请求!。。。
      try {
        remove(response.request());
      } catch (IOException ignored) {
        // The cache cannot be written.
      }
      return null;
    }
    if (!requestMethod.equals("GET")) {
      //OKhttp只能缓存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.Editor editor = null;
    try {
      editor = cache.edit(key(response.request().url()));
      if (editor == null) {
        return null;
      }
      //缓存了Header信息
      entry.writeTo(editor);
      return new CacheRequestImpl(editor);
    } catch (IOException e) {
      abortQuietly(editor);
      return null;
    }
  }

可以看到这里先有几种可能返回null,也就是对应的不能缓存,这里会惊讶的发现!OkHttpClient源码中支持GET形式的缓存

 if (!requestMethod.equals("GET")) {
      //OKhttp只能缓存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;
    }

public static boolean invalidatesCache(String method) {
    return method.equals("POST")
        || method.equals("PATCH")
        || method.equals("PUT")
        || method.equals("DELETE")
        || method.equals("MOVE");     // WebDAV
  }

通过注释其实也可以看到,这里okHttp的开发者认为,从效率角度考虑,最好不要支持POST请求的缓存,暂时只要支持GET形式的缓存。(如果需要支持,对应的其实也就是修改源码,将这里的判断给删除,其实还有一处判断,具体方法Google,Baidu)

//缓存了Header信息
      entry.writeTo(editor);
//Entry的writeTo方法===============================
public void writeTo(DiskLruCache.Editor editor) throws IOException {
      //往dirty中写入header信息,ENTRY_METADATA=0,所以是dirtyFiles[0]
      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();
    }

对应写缓存的地方可以看到调用了Entry的writeTo方法,这里别看那么长,其实主要看到一行代码就了解了这个方法的功能了。

//往dirty中写入header信息,ENTRY_METADATA=0,所以是dirtyFiles[0]
      BufferedSink sink = Okio.buffer(editor.newSink(ENTRY_METADATA));

还是原来的配方,还是原来的味道,又看到了刚才的参数ENTRY_METADATA=0,可以看到这里对应的其实就是往dirtyFiles[0]中写入header信息,这里其实可以根据前面的分析对应,dirty是用于保存编辑更新等不是持久的数据,而对应的0对应的header,1对应的body。

    //缓存了Header信息
      entry.writeTo(editor);
      return new CacheRequestImpl(editor);

写完header后,继续找写body的地方,这里返回了一个CacheRequestImpl对象,一定不要忽略,不然就找不到写body的地方了。

CacheRequestImpl(final DiskLruCache.Editor editor) {
      this.editor = editor;
        //ENTRY_BODY = 1
      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();
        }
      };
    }

看到ENTRY_BODY就放心, 这里对应的ENTRY_BODY=1对应的就是数组的第二个位置。那到了数据源,接着就要找写入的地方,这里还要注意一个地方editor.commit();

//CacheIntercetor中==========================
        //缓存Resposne的Header信息
        CacheRequest cacheRequest = cache.put(response);
        //缓存body
        return cacheWritingResponse(cacheRequest, response);

可以看到返回了一个CacheRequestImpl对象后,最终执行了一个cacheWritingResponse方法。

private Response cacheWritingResponse(final CacheRequest cacheRequest, Response response)
      throws IOException {
    // Some apps return a null body; for compatibility we treat that like a null cache request.
    if (cacheRequest == null) return response;
    Sink cacheBodyUnbuffered = cacheRequest.body();
    if (cacheBodyUnbuffered == null) return response;
    //获得body
    final BufferedSource source = response.body().source();
    final BufferedSink cacheBody = Okio.buffer(cacheBodyUnbuffered);

    Source cacheWritingSource = new Source() {
      boolean cacheRequestClosed;

      @Override public long read(Buffer sink, long byteCount) throws IOException {
        long bytesRead;
        try {
          bytesRead = source.read(sink, byteCount);
        } catch (IOException e) {
          if (!cacheRequestClosed) {
            cacheRequestClosed = true;
            cacheRequest.abort(); // Failed to write a complete cache response.
          }
          throw e;
        }

        if (bytesRead == -1) {
          if (!cacheRequestClosed) {
            cacheRequestClosed = true;
            cacheBody.close(); // The cache response is complete!
          }
          return -1;
        }
        //读的时候会将body写入
        sink.copyTo(cacheBody.buffer(), sink.size() - bytesRead, bytesRead);
        cacheBody.emitCompleteSegments();
        return bytesRead;
      }

      @Override public Timeout timeout() {
        return source.timeout();
      }

      @Override public void close() throws IOException {
        if (!cacheRequestClosed
            && !discard(this, HttpCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)) {
          cacheRequestClosed = true;
          //关闭的时候会执行commit操作,最终合并header和body,完成缓存
          cacheRequest.abort();
        }
        source.close();
      }
    };

    String contentType = response.header("Content-Type");
    long contentLength = response.body().contentLength();
    return response.newBuilder()
        .body(new RealResponseBody(contentType, contentLength, Okio.buffer(cacheWritingSource)))
        .build();
  }

这里分析一下主要主要流程。
1.获得Resposne中的body

//获得body
    final BufferedSource source = response.body().source();

2.将Resposne中获得的body写入缓存中,也就是刚在拿到的dirtyfile[1]

//读的时候会将body写入
        sink.copyTo(cacheBody.buffer(), sink.size() - bytesRead, bytesRead);

可以看到这里bytesRead就是读的Body,最后利用sink.copyTo,写入cacheBody.buffer()中,也就是刚在拿到的dirtyfile[1]。
3.在close中会执行abort操作,对应的里面会执行commit的操作,会将dirtyfile写入cleanfile中,完成持久化保存。

@Override public void close() throws IOException {
        if (!cacheRequestClosed
            && !discard(this, HttpCodec.DISCARD_STREAM_TIMEOUT_MILLIS, MILLISECONDS)) {
          cacheRequestClosed = true;
          //关闭的时候会执行commit操作,最终合并header和body,完成缓存
          cacheRequest.abort();
        }
        source.close();
      }

可以看到这里再关闭时会执行abort方法。

@Override public void abort() {
      synchronized (Cache.this) {
        if (done) {
          return;
        }
        done = true;
        writeAbortCount++;
      }
      Util.closeQuietly(cacheOut);
      try {
        editor.abort();
      } catch (IOException ignored) {
      }
    }

对应执行了editor的abort()方法。

public void abort() throws IOException {
      synchronized (DiskLruCache.this) {
        if (done) {
          throw new IllegalStateException();
        }
        if (entry.currentEditor == this) {
          completeEdit(this, false);
        }
        done = true;
      }
    }

可以看到这里执行了completeEdite方法。

synchronized void completeEdit(Editor editor, boolean success) throws IOException {
    ...

    for (int i = 0; i < valueCount; i++) {
      File dirty = entry.dirtyFiles[i];
      if (success) {
        if (fileSystem.exists(dirty)) {
          File clean = entry.cleanFiles[i];
          fileSystem.rename(dirty, clean);
          long oldLength = entry.lengths[i];
          long newLength = fileSystem.size(clean);
          entry.lengths[i] = newLength;
          size = size - oldLength + newLength;
        }
      } else {
        fileSystem.delete(dirty);
      }
    }

    ...
  }

这里删点代码吧,贴的代码太多了,这里只放了最重要的一条,可以看到将dirtyFiles数组保存赋值到cleanFiles数组中,完成了最终的持久化保存。

数一下这里的重点吧

1.缓存中是有日志文件用于保存操作记录
2.缓存中的Entry有用CleanFiles和DirtyFiles,其中Clean是用于保存持久性数据的,也就是真正保存数据的地方,Dirty是用于保存编辑过程中的数据的。
3.CleanFiles[]大小为2,第一个保存Header,第二个保存Body,最终保存缓存。

到此。。。结束了。。。没有结束语。

推荐阅读更多精彩内容