最近在研究ImageLoader的源码，发现一个硬盘缓存比较通用的类，这个类不属于谷歌官方却受官方亲睐，基本硬盘缓存都可以利用这个类来实现。
我们先来说一下缓存记录文件journal文件：
journal文件
作用：记录缓存的文件的行为：删除、读取、正在编辑等状态。
libcore.io.DiskLruCache
1
1
1
DIRTY c3bac86f2e7a291a1a200b853835b664
CLEAN c3bac86f2e7a291a1a200b853835b664 4698
READ c3bac86f2e7a291a1a200b853835b664
DIRTY c59f9eec4b616dc6682c7fa8bd1e061f
CLEAN c59f9eec4b616dc6682c7fa8bd1e061f 4698
READ c59f9eec4b616dc6682c7fa8bd1e061f
DIRTY be8bdac81c12a08e15988555d85dfd2b
CLEAN be8bdac81c12a08e15988555d85dfd2b 99
READ be8bdac81c12a08e15988555d85dfd2b
DIRTY 536788f4dbdffeecfbb8f350a941eea3
REMOVE 536788f4dbdffeecfbb8f350a941eea3
大家这个journal文件，
首先看前五行：
1.第一行固定常量libcore.io.DiskLruCache
2.第二行DiskLruCache的版本号，源码中为常量1
3.第三行app版本号
4.第四行标记一个key对应几个缓存文件，一般也为1.
5.第五行空行
以下为journal文件的一些规则：
6.REMOVE（删除） 、READ（读） 、DIRTY（脏）都是以 执行标记+空格+ key+空格 的规范写入
7.CLEAN （清理） 以 执行标记+空格+ key+空格+写入缓存字节 规范写入
8.REMOVE 是我们删除一条缓存文件（条目）时记录。
9.READ 是我们每读一个缓存文件（条目）时记录。
10.CLEAN 清理状态，缓存文件写入正确记录。
10.DIRTY 是缓存文件正在编辑写入时的状态，我们开始写入缓存文件时就记录为DIRTY 状态，写入完成后会紧跟着CLEAN 状态或者REMOVE状态。如果缓存的文件编辑完成记录CLEAN 状态，如果写入时出现IO异常则把缓存文件删除并且记录REMOVE状态。
以上就是所有关于journal文件的规则。
重要的全局变量
静态常量：
String JOURNAL_FILE：日志文件名
String JOURNAL_FILE_TEMP：临时日志文件名
String JOURNAL_FILE_BACKUP：备份日志文件名
Pattern LEGAL_KEY_PATTERN：key需要配置的正则表达式
全局变量：
Writer journalWriter：日志文件的操作流
LinkedHashMap lruEntries：缓存条目的链式列表
int redundantOpCount：冗余的操作数
long nextSequenceNumber:用来标识被成功提交的序号
long size :已经保存的字节大小
int fileCount：记录已经保存的文件数
初始化
构造方法
private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount) {
this.directory = directory;
this.appVersion = appVersion;
this.journalFile = new File(directory, JOURNAL_FILE);
this.journalFileTmp = new File(directory, JOURNAL_FILE_TEMP);
this.journalFileBackup = new File(directory, JOURNAL_FILE_BACKUP);
this.valueCount = valueCount;
this.maxSize = maxSize;
this.maxFileCount = maxFileCount;
}
构造方法是私有的，说明我们不能直接new得出DiskLrucache对象。构造方法就是初始化一些传入的文件夹路径，app版本、日志临时、备份、原文件等。其中valueCount 是相同key相对应保存的文件数，maxSize是我们维护的最大字节数，maxFileCount 是我们维护的最大文件数。
open方法
public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize, int maxFileCount)
throws IOException
是我们唯一创建DiskLruCache的方法，抛出异常，传入我们构造方法需要的参数。
判断可能出现的错误
if (maxSize <= 0) {
throw new IllegalArgumentException("maxSize <= 0");
}
if (maxFileCount <= 0) {
throw new IllegalArgumentException("maxFileCount <= 0");
}
if (valueCount <= 0) {
throw new IllegalArgumentException("valueCount <= 0");
}
说明一下规则：
1.maxSize最大字节数不能少于等于0.
2.maxFileCount 最大文件数不能少于等于0
3.valueCount相同key维护的文件数不能少于等于0
日志备份文件处理
File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
if (backupFile.exists()) {
File journalFile = new File(directory, JOURNAL_FILE);
//如果journal文件也存在，仅需要删除备份文件 否则备份文件重命名。
if (journalFile.exists()) {
backupFile.delete();
} else {
renameTo(backupFile, journalFile, false);
}
}
代码流程如下：
1.取出日志备份文件判断，如果没有日志备份文件直接下一步
2.存在备份文件，如果也存在原日志文件，删除备份文件
3.存在备份文件，如果不存在原日志文件，日志备份文件重命名为原文件
如果日志文件已经存在，对日志文件进行处理
DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
if (cache.journalFile.exists()) {
//如果日志文件存在 直接返回读取后返回当前新建的DiskLruCache对象
try {
//读日志文件
cache.readJournal();
//处理日志文件
cache.processJournal();
//创建写文件的流
cache.journalWriter = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(cache.journalFile, true), Util.US_ASCII));
return cache;
} catch (IOException journalIsCorrupt) {
System.out
.println("DiskLruCache "
+ directory
+ " is corrupt: "
+ journalIsCorrupt.getMessage()
+ ", removing");
cache.delete();
}
}
代码说明：
1.调用构造方法获取DiskLruCache对象。
2.判断如果存在日志文件对日志进行如下操作
3.读日志文件内容
4.处理日志文件
5.创建日志文件的写入流
6.返回DiskLruCache对象或者报异常删除文件夹
如果不存在日志文件则新建一个新的日志文件
directory.mkdirs();
cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);
//重建日志文件
cache.rebuildJournal();
1.如果目录不存在新建目录
2.新建持有的对象
3.重建日志文件
我先给大家说下一下流程，然后再深入详细的解析日志文件的产生以及重建。
日志文件的创建管理流程
读取日志文件 readJournal()和readJournalLine(String line)
readJournal()
作用：初始化缓存条目和redundantOpCount、校验版本信息。
private void readJournal() throws IOException {
//日志文件的输入流 一行行读取数据
StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile), Util.US_ASCII);
try {
//校验文件头是否异常
String magic = reader.readLine();
String version = reader.readLine();
String appVersionString = reader.readLine();
String valueCountString = reader.readLine();
String blank = reader.readLine();
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 {
//读入日志文件的每一行进行处理
readJournalLine(reader.readLine());
lineCount++;
} catch (EOFException endOfJournal) {
break;
}
}
//操作数
redundantOpCount = lineCount - lruEntries.size();
} finally {
Util.closeQuietly(reader);
}
}
1.先创建StrictLineReader 对象，StrictLineReader 对象是一个封装输入流的类，调用reader.readLine()会一行行的读取数据。
2.校验日志文件前五行的正确性，如果检验不通过会抛出异常，抛出异常后会删除文件夹重建。所以每个版本的APP传入的值如果不一样，会导致日志文件删除，然后重建建立缓存文件夹，缓存文件夹的直接删除也说明，我们的文件夹必须的缓存该类文件所专属的，不能放置其他文件，以防误删。
3.读取每一行数据进行解析处理
4.记录redundantOpCount=所有操作行-有效操作行。redundantOpCount 会在执行删除、读、添加文件时自增。
5.关闭文件流
readJournalLine(String line)
// 读每一行，根据每行的字符串构建Entry
private void readJournalLine(String line) throws IOException {
//找到第一个空格的位置
int firstSpace = line.indexOf(' ');
//如果为-1肯定为异常
if (firstSpace == -1) {
throw new IOException("unexpected journal line: " + line);
}
int keyBegin = firstSpace + 1;
int secondSpace = line.indexOf(' ', keyBegin);
final String key;
//取出 key
if (secondSpace == -1) {
//如果第二个空格为-1 是这样的形势
//DIRTY 335c4c6028171cfddfbaae1a9c313c52
//REMOVE 335c4c6028171cfddfbaae1a9c313c52
//READ 335c4c6028171cfddfbaae1a9c313c52
key = line.substring(keyBegin);
if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
//删除
lruEntries.remove(key);
return;
}
} else {
key = line.substring(keyBegin, secondSpace);
}
//根据 key 取出 Entry
Entry entry = lruEntries.get(key);
//如果为null 就新建
if (entry == null) {
entry = new Entry(key);
lruEntries.put(key, entry);
}
if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
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)) {
entry.currentEditor = new Editor(entry);
} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
// This work was already done by calling lruEntries.get().
// 如果为READ则什么都不需要做。上面这句翻译一下就是说这里要做的工作已经在调用lruEntries.get()时做过了
// 遇到READ其实就是再次访问该key，因此上面调用get的时候已经将其移动到最近使用的位置了
} else {
throw new IOException("unexpected journal line: " + line);
}
}
下面我们逐步解析，日志文件是如何转化成缓存条目的呢？因为这个方法很重要，着重讲解：
1.取出key值
//找到第一个空格的位置
int firstSpace = line.indexOf(' ');
//如果为-1肯定为异常
if (firstSpace == -1) {
throw new IOException("unexpected journal line: " + line);
}
int keyBegin = firstSpace + 1;
int secondSpace = line.indexOf(' ', keyBegin);
final String key;
//取出 key
if (secondSpace == -1) {
//如果第二个空格为-1 是这样的形势
//DIRTY 335c4c6028171cfddfbaae1a9c313c52
//REMOVE 335c4c6028171cfddfbaae1a9c313c52
//READ 335c4c6028171cfddfbaae1a9c313c52
key = line.substring(keyBegin);
if (firstSpace == REMOVE.length() && line.startsWith(REMOVE)) {
//删除
lruEntries.remove(key);
return;
}
} else {
key = line.substring(keyBegin, secondSpace);
}
上面代码就是取出key的过程代码，我们知道四种状态，只有CLEAN状态存在第二个空格键，所以我们取出第一个空格键的位置firstSpace，再取出第二个空格键的位置secondSpace，如果secondSpace为-1说明是DIRTY 、REMOVE 、READ 三种状态，直接使用line.substring(keyBegin)第一个空格键到结束就能截取出key,同时如果是REMOVE就使用key索引删除缓存条目。CLEAN需要使用第一个空格键和第二个空格键完成key的截取。
2.如果不存在缓存条目就创建新的：
//根据 key 取出 Entry
Entry entry = lruEntries.get(key);
//如果为null 就新建
if (entry == null) {
entry = new Entry(key);
lruEntries.put(key, entry);
}
我们知道只有REMOVE状态不会存在缓存条目，所以REMOVE状态删除之后直接reture,其他三个状态都存在缓存条目，所以，无论那种状态，我们都初始化新建一个key缓存条目。
3.对相应状态值进行处理：
if (secondSpace != -1 && firstSpace == CLEAN.length() && line.startsWith(CLEAN)) {
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)) {
entry.currentEditor = new Editor(entry);
} else if (secondSpace == -1 && firstSpace == READ.length() && line.startsWith(READ)) {
// This work was already done by calling lruEntries.get().
// 如果为READ则什么都不需要做。上面这句翻译一下就是说这里要做的工作已经在调用lruEntries.get()时做过了
// 遇到READ其实就是再次访问该key，因此上面调用get的时候已经将其移动到最近使用的位置了
} else {
throw new IOException("unexpected journal line: " + line);
}
如果是CLEAN状态，我们把缓存条目设置为已读，这说明文件完整，可以进行访问，设置为currentEditor =null，说明已经写入数据完毕，然后就是读取出文件的字节进行设置setLengths(parts)。
如果是DIRTY状态，是一种脏的状态，也可以理解为是一种正在写入数据流的编辑状态，设置当前.currentEditor = new Editor(entry)标记该缓存条目正在被编辑，其他线程不能再编辑，其后必须紧跟相同key的CLEAN或者REMOVE状态。
如果是READ，我们什么也不做。
最后是读完所有行数据后抛出异常中断循环。
处理日志文件processJournal()
作用：计算size和filecount的值。假设正在编辑状态的写入不一致，直接删除。
private void processJournal() throws IOException {
deleteIfExists(journalFileTmp);
for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {
Entry entry = i.next();
if (entry.currentEditor == null) {
for (int t = 0; t < valueCount; t++) {
size += entry.lengths[t];
fileCount++;
}
} else {
// 当前条目正在被编辑，删除正在编辑的文件并将currentEditor赋值为null
entry.currentEditor = null;
for (int t = 0; t < valueCount; t++) {
deleteIfExists(entry.getCleanFile(t));
deleteIfExists(entry.getDirtyFile(t));
}
i.remove();
}
}
}
valueCount一般为1.
1.删除临时文件
2.编立lruEntries缓存条目，如果entry.currentEditor == null说明不在编辑状态，计算遍历相同key的所有文件大小合并到size和fileCount.
3.如果是正在编辑的状态，先设置当前编辑为null，然后删除CleanFile和DirtyFile,最后删除缓存条目。
重建日志文件
private synchronized void rebuildJournal() throws IOException {
//先关闭之前的写的流
if (journalWriter != null) {
journalWriter.close();
}
//创建一个临时的写入流
Writer writer = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(journalFileTmp), Util.US_ASCII));
try {
//写入一个常量
writer.write(MAGIC);
writer.write("\n");
//写入一个缓存版本号 默认为1
writer.write(VERSION_1);
writer.write("\n");
//写入APP的版本号
writer.write(Integer.toString(appVersion));
writer.write("\n");
//写入值计数
writer.write(Integer.toString(valueCount));
writer.write("\n");
//写入一个空行
writer.write("\n");
// 遍历Map写入日志文件
for (Entry entry : lruEntries.values()) {
if (entry.currentEditor != null) {
writer.write(DIRTY + ' ' + entry.key + '\n');
} else {
writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
}
}
} finally {
writer.close();
}
if (journalFile.exists()) {
//如果日志文件存在 就重命名为临备份日志文件 并且先把之前的日志文件删除掉
renameTo(journalFile, journalFileBackup, true);
}
//备份文件重命名为日志文件
renameTo(journalFileTmp, journalFile, false);
//删除备份文件
journalFileBackup.delete();
//新建日志文件的写入流
journalWriter = new BufferedWriter(
new OutputStreamWriter(new FileOutputStream(journalFile, true), Util.US_ASCII));
}
重建日志文件步骤如下：
1.新建一个临时文件流。
2.把五行固定格式写入，然后遍历现有的缓存lruEntries列表。
3.关闭流
4.存在日志文件，就把之前的日志文件重命名为备份文件。
5.临时文件再改名为正式文件
6.不出现异常就删除备份文件
7.创建流
处罚重建日志文件有两个地方：
1.初始化的时候检验出现异常等。
2.符合如下条件，因为日志文件大庞大，进行删减一些无用记录
private boolean journalRebuildRequired() {
final int redundantOpCompactThreshold = 2000;
return redundantOpCount >= redundantOpCompactThreshold //
&& redundantOpCount >= lruEntries.size();
}
ImageLoader中重要的几个内部类
Entry缓存条目
上面就是Entry类的构造以及函数方法，因为常量比较简单 ，这里就不说了，这个类，就是把缓存条目记录起来，进行快速检索。因为相同key是支持多个文件的，所以这里的文件数量是数组，而且文件想以key.index等方式命名存储的，以完全写入的清洁文件为列子：
public File getCleanFile(int i) {
return new File(directory, key + "." + i);
}
就是通过名字key和index来进行检索文件的。
Editor编辑对象
说到Editor对象，我们先来看看以下使用的代码：
public boolean save(String imageUri, InputStream imageStream, IoUtils.CopyListener listener) throws IOException {
DiskLruCache.Editor editor = cache.edit(getKey(imageUri));
if (editor == null) {
return false;
}
OutputStream os = new BufferedOutputStream(editor.newOutputStream(0), bufferSize);
boolean copied = false;
try {
copied = IoUtils.copyStream(imageStream, os, listener, bufferSize);
} finally {
IoUtils.closeSilently(os);
if (copied) {
editor.commit();
} else {
editor.abort();
}
}
return copied;
}
通过代码我们知道，Editor其实就是用来封装，记录写入文件流的编辑过程，文件流正常写入，就提交Clean，失败就强制删除，其实就是一个事务处理机制。
常量：
boolean committed：是否提交完成
boolean hasErrors:是否存在异常
boolean[] written：记录是否需要写
Entry entry编辑的缓存条目
主要方法有：
public InputStream newInputStream(int index) throws IOException {
synchronized (DiskLruCache.this) {
if (entry.currentEditor != this) {
throw new IllegalStateException();
}
if (!entry.readable) {
return null;
}
try {
return new FileInputStream(entry.getCleanFile(index));
} catch (FileNotFoundException e) {
return null;
}
}
}
获取一个输入流，输入流文件以缓存条目的entry.getCleanFile(index) 完整文件命名。
public OutputStream newOutputStream(int index) throws IOException {
synchronized (DiskLruCache.this) {
if (entry.currentEditor != this) {
throw new IllegalStateException();
}
//如果还没有被提交过
if (!entry.readable) {
//设置编辑类的 写入初始值为true
written[index] = true;
}
//获取索引下的脏文件
File dirtyFile = entry.getDirtyFile(index);
FileOutputStream outputStream;
try {
outputStream = new FileOutputStream(dirtyFile);
} catch (FileNotFoundException e) {
// Attempt to recreate the cache directory.
directory.mkdirs();
try {
outputStream = new FileOutputStream(dirtyFile);
} catch (FileNotFoundException e2) {
// We are unable to recover. Silently eat the writes.
return NULL_OUTPUT_STREAM;
}
}
return new FaultHidingOutputStream(outputStream);
}
}
获取一个输出流，!entry.readable这个条件说明之前这个文件从来没有被写入完整过，把写入权限设置为true,
然后先取脏文件的输入出流，封装成FaultHidingOutputStream这个对象，这个对象比较简单，就是出现IO异常不抛出，设置hasErrors为true.
public void commit() throws IOException {
if (hasErrors) {
completeEdit(this, false);
remove(entry.key); // The previous entry is stale.
} else {
completeEdit(this, true);
}
committed = true;
}
提交事务的方法，没有错误，直接调用completeEdit(this, true)，有出现IO异常就completeEdit(this, false)，并且删除这个缓存条目。
而abort()事务回掉，其实就是调用DiskLruCache方法的completeEdit(this, false)。
我们先放下completeEdit(this, false)这个方法，我们来聊聊DiskLruCache中的edit(String key)方法，也就是我们获取到Editor事务的方法。
public Editor edit(String key) throws IOException {
return edit(key, ANY_SEQUENCE_NUMBER);
}
private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
checkNotClosed();
validateKey(key);
Entry entry = lruEntries.get(key);
if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
|| entry.sequenceNumber != expectedSequenceNumber)) {
return null; // Snapshot is stale.
}
if (entry == null) {
entry = new Entry(key);
lruEntries.put(key, entry);
} else if (entry.currentEditor != null) {
return null; // Another edit is in progress.
}
Editor editor = new Editor(entry);
entry.currentEditor = editor;
// Flush the journal before creating files to prevent file leaks.
journalWriter.write(DIRTY + ' ' + key + '\n');
journalWriter.flush();
return editor;
}
上面两个方法，最终都会调用edit(String key, long expectedSequenceNumber)，默认序列号为-1，我们可以看到，第一步是先检验日志文件的流是否关闭，第二部是检验Key是否匹配Pattern.compile("[a-z0-9_-]{1,64}")的正则表达式，第三部检验序列号，当我们只调用单个key不传入序列号是检验序列号是恒成立的，我们需要关注的是(entry == null|| entry.sequenceNumber != expectedSequenceNumber))，这个方法主要是确保，我们的Snapshot 是最新的。
然后下面就是创建Entry，Editor ，并且保证相同key，是不会同时写入数据的，也就是说entry.currentEditor代表我们的文件流正在写入，其中一个线程正在写入，另一个线程是无法获取到Editor的，最后写入日志文件。
下面我们来说说DiskLruCache中的 completeEdit(Editor editor, boolean success)方法，这个方法是Editor做提交事务后进行事务回滚和完成事务调用的。
Entry entry = editor.entry;
if (entry.currentEditor != editor) {
throw new IllegalStateException();
}
判断正在编辑的Editor是否是正操作的。
if (success && !entry.readable) {
for (int i = 0; i < valueCount; i++) {
if (!editor.written[i]) {
editor.abort();
throw new IllegalStateException("Newly created entry didn't create value for index " + i);
}
if (!entry.getDirtyFile(i).exists()) {
editor.abort();
return;
}
}
}
entry.readable为true说明不是首次提交，entry.readable为false说明是首次提交，也即是满足，写入成功，但是文件标记为不能写，或者dirty文件不存在，就强制回滚事务，但是一般不会触发。
for (int i = 0; i < valueCount; i++) {
File dirty = entry.getDirtyFile(i);
//提交成功
if (success) {
if (dirty.exists()) {
//如果是成功的 就把临时文件转成
File clean = entry.getCleanFile(i);
dirty.renameTo(clean);
long oldLength = entry.lengths[i];
long newLength = clean.length();
entry.lengths[i] = newLength;
size = size - oldLength + newLength;
fileCount++;
}
} else {
//提交失败直接删除掉
deleteIfExists(dirty);
}
}
遍历获取dirty文件，一般情况valueCount为1,就是说提交失败删除dirty文件，提交成功就重命名文件，并把size，fileCount值做统计。
然后：
redundantOpCount++;
entry.currentEditor = null;
if (entry.readable | success) {
entry.readable = true;
journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
if (success) {
entry.sequenceNumber = nextSequenceNumber++;
}
} else {
lruEntries.remove(entry.key);
journalWriter.write(REMOVE + ' ' + entry.key + '\n');
}
journalWriter.flush();
这一段代码就是把事务置为null，并且判断是写入日志文件Remove状态还是clean状态。
最后
if (size > maxSize || fileCount > maxFileCount || journalRebuildRequired()) {
executorService.submit(cleanupCallable);
}
判断文件大小 ，文件数量，以及日志文件是否超标，超标就启动任务重构日志文件。
关于Editor,既可以理解为事务的方法就说完了。
Snapshot快照对象
我们先来看看，ImageLoader对快照的使用：
public File get(String imageUri) {
DiskLruCache.Snapshot snapshot = null;
try {
snapshot = cache.get(getKey(imageUri));
return snapshot == null ? null : snapshot.getFile(0);
} catch (IOException e) {
L.e(e);
return null;
} finally {
if (snapshot != null) {
snapshot.close();
}
}
}
从这个方法中，我们知道，其实就是取出快照，然后返回文件流。那我们的快照做了什么处理呢。其实就在通过key，索引到一些数据，然后把数据封装到Snapshot 中，我们来看看取快照的方法cache.get(getKey(imageUri))：
public synchronized Snapshot get(String key) throws IOException {
checkNotClosed();
validateKey(key);
Entry entry = lruEntries.get(key);
if (entry == null) {
return null;
}
if (!entry.readable) {
return null;
}
// Open all streams eagerly to guarantee that we see a single published
// snapshot. If we opened streams lazily then the streams could come
// from different edits.
File[] files = new File[valueCount];
InputStream[] ins = new InputStream[valueCount];
try {
File file;
for (int i = 0; i < valueCount; i++) {
file = entry.getCleanFile(i);
files[i] = file;
ins[i] = new FileInputStream(file);
}
} catch (FileNotFoundException e) {
// A file must have been deleted manually!
for (int i = 0; i < valueCount; i++) {
if (ins[i] != null) {
Util.closeQuietly(ins[i]);
} else {
break;
}
}
return null;
}
redundantOpCount++;
journalWriter.append(READ + ' ' + key + '\n');
if (journalRebuildRequired()) {
executorService.submit(cleanupCallable);
}
return new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);
}
流程很简单：
1.检验
2.从缓存条目中取出文件和文件流数组，
3.把操作写入日志文件
4.达到某程序的冗余数后重建的日志文件
5.封装new Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);
也就是说，一切就是为了把我们需要的数据装到快照里面。
结构如下：
也不复杂 这里我就不说了，其他还有的方法，各位可以参考源码。
