Android 开源项目DiskLruCache解析使用

DiskLruCache 硬盘缓存，非Google官方编写，但获得官方承认， 只需要下载下来放到项目中就行。

journal文件

这个日志文件，关系着DiskLruCache的正常使用，里面记录了每条缓存，下面看看里面信息

第一行是固定的字符串，第二行是DiskLruCache的版本号，这个值为1，第三行是APP的版本号，每当更新版本时会清除缓存，第四行是valueCount的值，在open时传入，一般为1，第五行是个空行。在下面就是缓存的信息

分别有几种前缀，DIRTY脏数据，当我们调用DiskLruCache的edit()方法时就会写入一个DIRTY，后面是缓存的key；CLEAN，当调用了commit方法后，会写入一条CLEAN；REMOVE，当调用absort方法，写入缓存失败，会产生一条REMOVE；READ，当读取一条缓存时会写入一条READ。

open获得实例

DiskLruCache 不是new出来的，而是通过一个open函数获得实例

public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)
            throws IOException {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        if (valueCount <= 0) {
            throw new IllegalArgumentException("valueCount <= 0");
        }

        //根据参数创建对象赋值
        DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        //判断日志文件是否存在
        if (cache.journalFile.exists()) {
            try {
                //读取日志文件
                cache.readJournal();
                cache.processJournal();
                //写日志文件的Writer
                cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true),
                        IO_BUFFER_SIZE);
                return cache;
            } catch (IOException journalIsCorrupt) {
//                System.logW("DiskLruCache " + directory + " is corrupt: "
//                        + journalIsCorrupt.getMessage() + ", removing");
                //删除所有缓存数据
                cache.delete();
            }
        }

        // create a new empty cache
        directory.mkdirs();
        cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        //创建日志文件
        cache.rebuildJournal();
        return cache;

    }

主要就是创建对象，读取或者创建日志文件。

看看void readJournal()

 private void readJournal() throws IOException {
        InputStream in = new BufferedInputStream(new FileInputStream(journalFile), IO_BUFFER_SIZE);
        try {
           //这一段一般是文件头的信息
            String magic = readAsciiLine(in);
            String version = readAsciiLine(in);
            String appVersionString = readAsciiLine(in);
            String valueCountString = readAsciiLine(in);
            String blank = readAsciiLine(in);
            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 + "]");
            }

            //开始读日志信息
            while (true) {
                try {
                    //解析每一行的具体信息
                    readJournalLine(readAsciiLine(in));
                } catch (EOFException endOfJournal) {
                    break;
                }
            }
        } finally {
            //最后关闭输入流
            closeQuietly(in);
        }
    }

这个函数就是读取日志文件，前几行是日志的一些头信息，后面while循环解析日志，就是缓存的信息，解析出来放到了一个hash链表里面存储。

void rebuildJournal()

private synchronized void rebuildJournal() throws IOException {
        if (journalWriter != null) {
            journalWriter.close();
        }
        //writer指向的journalFileTmp
        Writer writer = new BufferedWriter(new FileWriter(journalFileTmp), IO_BUFFER_SIZE);
        writer.write(MAGIC);
        writer.write("\n");
        writer.write(VERSION_1);
        writer.write("\n");
        writer.write(Integer.toString(appVersion));
        writer.write("\n");
        writer.write(Integer.toString(valueCount));
        writer.write("\n");
        writer.write("\n");

        for (Entry entry : lruEntries.values()) {
            if (entry.currentEditor != null) {
                writer.write(DIRTY + ' ' + entry.key + '\n');
            } else {
                writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');
            }
        }

        writer.close();
        journalFileTmp.renameTo(journalFile);
        journalWriter = new BufferedWriter(new FileWriter(journalFile, true), IO_BUFFER_SIZE);
    }

主要就是创建journal

写入缓存

private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
        //校验journalWriter是否为空
        checkNotClosed();
        //校验key的合法性
        validateKey(key);
        Entry entry = lruEntries.get(key);
        if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER
                && (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {
            return null; // snapshot is stale
        }
        //如果entry为空，创建一个并加入map里面
        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;

        // 写一条DIRTY
        journalWriter.write(DIRTY + ' ' + key + '\n');
        journalWriter.flush();
        return editor;
    }

获得输出流

public OutputStream newOutputStream(int index) throws IOException {
            synchronized (DiskLruCache.this) {
                if (entry.currentEditor != this) {
                    throw new IllegalStateException();
                }
                return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
            }
        }

commit()操作

 public void commit() throws IOException {
        if (hasErrors) {
            completeEdit(this, false);
            remove(entry.key); // the previous entry is stale
        } else {
            completeEdit(this, true);
        }
    }

    private synchronized void completeEdit(Editor editor, boolean success) throws IOException {
        Entry entry = editor.entry;
        if (entry.currentEditor != editor) {
            throw new IllegalStateException();
        }

        // if this edit is creating the entry for the first time, every index must have a value
        if (success && !entry.readable) {
            for (int i = 0; i < valueCount; i++) {
                //不存在dirty类型的，则停止，抛出异常
                if (!entry.getDirtyFile(i).exists()) {
                    editor.abort();
                    throw new IllegalStateException("edit didn't create file " + i);
                }
            }
        }

        for (int i = 0; i < valueCount; i++) {
            //获得dirty类型的File
            File dirty = entry.getDirtyFile(i);
            if (success) {
                if (dirty.exists()) {
                    //dirty转化为clean
                    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;
                }
            } else {
                deleteIfExists(dirty);
            }
        }

        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');
        }

        //当缓存过大时，重新创建
        if (size > maxSize || journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }
    }

获取缓存

 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.
         */
        InputStream[] ins = new InputStream[valueCount];
        try {
            for (int i = 0; i < valueCount; i++) {
                ins[i] = new FileInputStream(entry.getCleanFile(i));
            }
        } catch (FileNotFoundException e) {
            // a file must have been deleted manually!
            return null;
        }
        
        redundantOpCount++;
        //取出缓存后添加一条READ
        journalWriter.append(READ + ' ' + key + '\n');
        //检查是否需要重构journal
        if (journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }

        return new Snapshot(key, entry.sequenceNumber, ins);
    }

返回SnapShot对象，通过这个对象就可以获得缓存的输入流。 

其他一些方法

 remove(String key) 

移除特定的缓存，一般不使用，因为当缓存到达一定大小时，会去自定清理长期没用过的缓存
flush

同步内存的操作到journal文件中

delete()

删除所有缓存数据

close()

关闭DiskLruCache

小Demo

通过网络获取一张图片，缓存起来，点击按钮，通过缓存加载图片。