DiskLruCache简介

/**
*cacheFile 缓存文件的存储路径
*appVersion 应用版本号。DiskLruCache 认为应用版本更新后所有的数据都因该从服务器重新拉取，因此需要版本号进行判断
*1 每条缓存条目对应的值的个数，这里设置为1个。
*10*1024*1014 缓存的最大空间10M
**/
DiskLruCache mDiskLruCache = DiskLruCache.open(cacheFile, appVersion, 1, 10*1024*1014);

    DiskLruCache.Editor edit = mDiskLruCache.edit("xiamin");
    OutputStream os = edit.newOutputStream(0);
    BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
    bw.write("test1");
    edit.commit();//write CLEAN

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

        // If a bkp file exists, use it instead.
        // 首先检查存不存在journal.bkp（journal的备份文件）
        File backupFile = new File(directory, JOURNAL_FILE_BACKUP);
        //如果存在：然后检查journal文件是否存在，如果正主在，bkp文件就可以删除了。
        if (backupFile.exists()) {
            log("backupFile.exists() 存在");
            File journalFile = new File(directory, JOURNAL_FILE);
            // If journal file also exists just delete backup file.
            if (journalFile.exists()) {
                backupFile.delete();
            } else { //如果不存在，将bkp文件重命名为journal文件。
                log("不存在，将bkp文件重命名为journal文件");
                renameTo(backupFile, journalFile, false);
            }
        }

        // Prefer to pick up where we left off.
        DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        // 判断journal文件是否存在, 若存在,读取journal文件
        if (cache.journalFile.exists()) {
            log("journal文件是存在");
            try {
                //若存在
                cache.readJournal();
                cache.processJournal();
                return cache;
            } catch (IOException journalIsCorrupt) {
                System.out
                        .println("DiskLruCache "
                                + directory
                                + " is corrupt: "
                                + journalIsCorrupt.getMessage()
                                + ", removing");
                cache.delete();
            }
        }

        // Create a new empty cache.
        //如果不存在
        //创建directory；重新构造disklrucache；调用rebuildJournal建立journal文件
        log("journal文件是不存在 新构造disklrucache；调用rebuildJournal建立journal文件");
        directory.mkdirs();
        cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);
        cache.rebuildJournal();
        //经过open以后，journal文件肯定存在了；lruEntries里面肯定有值了；size存储了当前所有的实体占据的容量；
        return cache;
    }

    private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {
        checkNotClosed();
        //首先验证key，可以必须是字母、数字、下划线、横线（-）组成，且长度在1-120之间。
        validateKey(key);
        //然后通过key获取实体，
        Entry entry = lruEntries.get(key);
        if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER && (entry == null
                || entry.sequenceNumber != expectedSequenceNumber)) {
            return null; // Snapshot is stale.
        }
        //若还没有entry,返回一个新的,并存到lru里面
        if (entry == null) {
            entry = new Entry(key);
            lruEntries.put(key, entry);

        } else if (entry.currentEditor != null) {    //若存在,且正在编辑,返回null
            return null; // Another edit is in progress.
        }

        //返回一个editor
        Editor editor = new Editor(entry);
        entry.currentEditor = editor;  //并赋值editor

        // Flush the journal before creating files to prevent file leaks.
        journalWriter.write(DIRTY + ' ' + key + '\n');
        journalWriter.flush();
        return editor;
    }

    public synchronized Snapshot get(String key) throws IOException {
        checkNotClosed();
        validateKey(key);
        //如果取到的为null，或者readable=false，则返回null
        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!
            for (int i = 0; i < valueCount; i++) {
                if (ins[i] != null) {
                    Util.closeQuietly(ins[i]);
                } else {
                    break;
                }
            }
            return null;
        }

        redundantOpCount++;
        //写入一条READ语句。
        journalWriter.append(READ + ' ' + key + '\n');
        if (journalRebuildRequired()) {
            executorService.submit(cleanupCallable);
        }
        //然后getInputStream就是返回该FileInputStream了。
        return new Snapshot(key, entry.sequenceNumber, ins, entry.lengths);
    }