Android-Universal-Image-Loader --LruDiscCach

[java]  view plain copy

1. privatevoid validateKey(String key) {  
2.         Matcher matcher = LEGAL_KEY_PATTERN.matcher(key);  
3.         if (!matcher.matches()) {  
4.   
5.             thrownew IllegalArgumentException("keys must match regex [a-z0-9_-]{1,64}: \"" + key + "\"");  
6.         }  
7.       

所以Entry,Editor，Snapshot之间的关系通过key串联了起来：  

[java]  view plain copy

1.    
2.   
3. staticfinal String JOURNAL_FILE = "journal";  
4.   
5.     staticfinal String JOURNAL_FILE_TEMP = "journal.tmp";  
6.   
7.     staticfinal String JOURNAL_FILE_BACKUP = "journal.bkp";  
8.   
9.     staticfinal String MAGIC = "libcore.io.DiskLruCache";  
10.   
11.     staticfinal String VERSION_1 = "1";  
12.   
13.     staticfinallongANY_SEQUENCE_NUMBER = -1;  
14.   
15.     staticfinal Pattern LEGAL_KEY_PATTERN = Pattern.compile("[a-z0-9_-]{1,64}");  
16.   
17.     privatestaticfinal String CLEAN = "CLEAN";  
18.   
19.     privatestaticfinal String DIRTY = "DIRTY";  
20.   
21.     privatestaticfinal String REMOVE = "REMOVE";  
22.   
23.     privatestaticfinal String READ = "READ";  
24.   
25.     privatefinal File journalFile;  
26.   
27.     //调用rebuildJorunal重新创建日志文件的时候会把日志信息写入到该文件中去  
28.   
29.     privatefinal File journalFileTmp;  
30.   
31.     privatefinal File journalFileBackup;  
32.   
33.     privatefinalintappVersion;  
34.   
35. private Writer journalWriter;  
36.   
37. private int reduantOpCount;//用来判断是否重建日志的字段  
38.   
39. private int redundantOpCount;  

[java]  view plain copy

1. //检测缓存是否关闭  
2. publicsynchronizedboolean isClosed() {  
3.         returnjournalWriter ==null;  
4.     }  
5.     //检测缓存是否未关闭  
6.     privatevoid checkNotClosed() {  
7.         if (journalWriter ==null) {  
8.             thrownew IllegalStateException("cache is closed");  
9.         }  
10.     }  
11.   
12.    /** 
13.      * 关闭缓存，journalWirter为空的话，说明缓存已经关闭：方法调用结束 
14.      * 否则的话循环遍历lruEntries中的每一个Entry,撤掉正在编辑的Entry。 
15.      * Closes this cache. Stored values will remain on thefilesystem. */  
16.     publicsynchronizedvoid close()throws IOException {  
17.         if (journalWriter ==null) {  
18.             return;//缓存已经关闭，直接退出方法调用  
19.         }  
20.         //对处于编辑中的entry进行撤销编辑操作  
21.         for (Entry entry :new ArrayList<Entry>(lruEntries.values())) {  
22.            if (entry.currentEditor !=null) {  
23.               entry.currentEditor.abort();  
24.             }  
25.         }  
26.         trimToSize();  
27.         trimToFileCount();  
28.         //关闭日志输出流  
29.         journalWriter.close();  
30.         journalWriter =null;  
31.     }  

[java]  view plain copy

1. //判断是否需要重建日志文件当  
2.   
3. privatebooleanjournalRebuildRequired() {  
4.         finalint redundantOpCompactThreshold = 2000;  
5.        returnredundantOpCount >= redundantOpCompactThreshold  
6.                 && redundantOpCount >= lruEntries.size();  
7.     }  

[java]  view plain copy

1. DiskLruCache cache = new DiskLruCache();//第一次初始化  
2. if(cache.journalFile.exists()){  
3.   try{  
4.       对日志文件进行IO操作，具体操作的逻辑下文描述  
5.       return cache;  
6. }catch(IOException journalFileException){  
7.    操作日志出现IO错误  
8.    cache.delete();删除缓存  
9. }  
10. }  
11. cache.makDir();  
12. cache = new DiskLruCache();//第二次初始化  
13. cache.rebuildJournalFile();  
14. return cache;  

[java]  view plain copy

1. //读入日志的一行数据  
2.    privatevoid readJournalLine(String line)throws IOException {  
3.        //获取第一个空格的位置  
4.        int firstSpace = line.indexOf(‘ ‘);  
5.        int keyBegin = firstSpace + 1;  
6.        //获取第二个空格的位置  
7.       int secondSpace = line.indexOf(‘ ‘, keyBegin);  
8.        //获取该行数据代表的所代表的key  
9.        final String key;  
10.        if (secondSpace == -1) {//如果第二个空格不存在            
11.            key = line.substring(keyBegin);  
12.    //如果改行数据是以REMOVE开头的情况下，就从lruEntries中删除该key锁代表的entry  
13.            if (firstSpace ==REMOVE.length() && line.startsWith(REMOVE)) {  
14.                lruEntries.remove(key);  
15.                return;  
16.            }  
17.        } else {  
18.            key = line.substring(keyBegin, secondSpace);  
19.        }  
20.        //得到日志文件当前行锁记录的key  
21.        Entry entry = lruEntries.get(key);  
22.        if (entry ==null) {  
23.            entry = new Entry(key);  
24.            //如果没有就创建一个Entry，并放入lruEntries中  
25.            lruEntries.put(key, entry);  
26.        }  
27.        //如果改行数据已ClEAN开头  
28.        if (secondSpace != -1 && firstSpace ==CLEAN.length() && line.startsWith(CLEAN)) {  
29.           String[] parts = line.substring(secondSpace + 1).split(" ");  
30.            entry.readable =true;//设置给Entry为发布状态  
31.            entry.currentEditor =null;//编辑对象设置为空  
32.            entry.setLengths(parts);//设置该entry中每一个file的大小  
33.        } //如果该行数据已DIRTY开头，那么设置key所对应的entry为编辑状态  
34.        elseif (secondSpace == -1 && firstSpace ==DIRTY.length() && line.startsWith(DIRTY)) {//如果该条数据是以DIRTY开头，就将该entry设置为编辑状态  
35.            entry.currentEditor =new Editor(entry);  
36.        } elseif (secondSpace == -1 && firstSpace ==READ.length() && line.startsWith(READ)) {  
37.            // This work was already done by calling lruEntries.get().  
38.        } else {  
39.            thrownew IOException("unexpected journal line: " + line);  
40.        }  
41.    }  

[java]  view plain copy

1. privatevoidprocessJournal()throws IOException {  
2.         deleteIfExists(journalFileTmp);  
3.         for (Iterator<Entry> i =lruEntries.values().iterator(); i.hasNext(); ) {  
4.             Entry entry = i.next();  
5.             if (entry.currentEditor ==null) {  
6.                 for (int t = 0; t <valueCount; t++) {  
7.                     size += entry.lengths[t];  
8.                     fileCount++;  
9.                 }  
10.             } else {  
11.                 entry.currentEditor =null;  
12.                 for (int t = 0; t <valueCount; t++) {  
13.                     deleteIfExists(entry.getCleanFile(t));  
14.                     deleteIfExists(entry.getDirtyFile(t));  
15.                 }  
16.                 i.remove();  
17.             }  
18.         }  
19.     }  

[java]  view plain copy

1. ache.journalWriter =new BufferedWriter(  
2.                         new OutputStreamWriter(new FileOutputStream(cache.journalFile,true), Util.US_ASCII))  

[java]  view plain copy

1. directory.mkdirs();  
2. cache = new DiskLruCache(directory, appVersion, valueCount, maxSize, maxFileCount);  
3. cache.rebuildJournal();//把原来的日志文件删除，并重新创建一个写入前五行数据的日志文件，以及重新创建journalWirt  

[java]  view plain copy

1. DiskLruCache.Editor editor = cache.edit(getKey(imageUri));//这个editor是一个新的编辑器对象  
2. privatesynchronized Editor edit(String key,long expectedSequenceNumber)throws IOException {  
3.         //检测缓存是否关闭  
4.         checkNotClosed();  
5.         //检测key是否符合规则  
6.         validateKey(key);  
7.         //从lruEntries中获取指定对象的key  
8.         Entry entry = lruEntries.get(key);  
9.         if (expectedSequenceNumber !=ANY_SEQUENCE_NUMBER && (entry ==null  
10.                 || entry.sequenceNumber != expectedSequenceNumber)) {  
11.             returnnull;//快照已经陈旧  
12.         }  
13.         //如果在lruEntries中没有对应的entry对象，则创建并添加  
14.         if (entry ==null) {  
15.             entry = new Entry(key);  
16.             lruEntries.put(key, entry);  
17.         }//如果Entry存在并且还处于编辑状态的话就返回一个null  
18.         elseif (entry.currentEditor != null) {  
19.             returnnull;// Another edit is in progress.  
20.         }  
21.        //创建一个新的编辑器对象  
22.         Editor editor = new Editor(entry);  
23.         entry.currentEditor = editor;  
24.         // Flush the journal before creating files to prevent file leaks.  
25.         //创建新的文件之前刷新Writer以阻止文件泄露  
26.         journalWriter.write(DIRTY +‘ ‘ + key + ‘\n‘);  
27.         journalWriter.flush();  
28.        return editor;  
29.     }  

[java]  view plain copy

1. publicsynchronized Snapshot get(String key)throws IOException {  
2.         checkNotClosed();  
3.         validateKey(key);     
4.         //如果lruEntries中没有该Entry，直接翻译一个null  
5.         Entry entry = lruEntries.get(key);  
6.         if (entry ==null) {  
7.             returnnull;  
8.         }  
9.        //如果该Entry还没有发布，那么也返回一个null  
10.         if (!entry.readable) {  
11.             returnnull;  
12.         }  
13.         // Open all streams eagerly to guarantee that we see a single published  
14.         // snapshot. If we opened streams lazily then the streams could come  
15.         // from different edits.  
16.        //循环遍历Entry中的每一个file,以及每一个file所代表的输入流  
17.         File[] files = new File[valueCount];  
18.         InputStream[] ins = new InputStream[valueCount];  
19.         try {  
20.             File file;  
21.            for (int i = 0; i <valueCount; i++) {  
22.                 file = entry.getCleanFile(i);  
23.                 files[i] = file;  
24.                 ins[i] = new FileInputStream(file);  
25.             }  
26.         } catch (FileNotFoundException e) {  
27.             // A file must have been deleted manually!  
28.             for (int i = 0; i <valueCount; i++) {  
29.                 if (ins[i] !=null) {  
30.                    Util.closeQuietly(ins[i]);  
31.                 } else {  
32.                     break;  
33.                }  
34.             }  
35.             returnnull;  
36.         }  
37.         redundantOpCount++;  
38.         //标记哪一个文件正在读取  
39.         journalWriter.append(READ +‘ ‘ + key + ‘\n‘);  
40.         if (journalRebuildRequired()) {  
41.             executorService.submit(cleanupCallable);  
42.         }  
43.         returnnew Snapshot(key, entry.sequenceNumber, files, ins, entry.lengths);  
44.     }  

[java]  view plain copy

1. //用DiskLruCache来代替，在BasicDiscCache中用File cacheDir来表示  
2.   protected DiskLruCachecache;  
3.   private FilereserveCacheDir;  
4.   protectedfinal FileNameGeneratorfileNameGenerator;  

DiscCache接口提供的方法在LruDiscCache中的核心实现都转移到了cache对象中(或者说是DiskLruCache中)。下面就说说DiskLruCache，然后在掉过头来说LruDiscCache。

[java]  view plain copy

1. //缓存图片的目录  
2.     privatefinal Filedirectory;  
3.     //最大缓存的大小  
4.     privatelongmaxSize;  
5.     //最多缓存多少文件  
6.     privateintmaxFileCount;  
7.     //每一个entry所封装的文件的数目  
8.     privatefinalintvalueCount;  
9.     //缓存的大小  
10.     privatelongsize = 0;  
11.     //缓存文件的数目  
12.     privateintfileCount = 0;  

[java]  view plain copy

1. //最后一个参数设置为true表示访问的顺序  
2. privatefinalLinkedHashMap<String, Entry>lruEntries =  
3.             newLinkedHashMap<String, Entry>(0, 0.75f,true)  

最后还有一个long 类型的nextSequenceNumber：为了对新的和旧的快照做区分，每一个entry对象在每一次编辑被提交的时候会获取一个序列号（nextSequenceNumber），如果这个序列号不等于entry的序列号的话，就说明该快照是旧的快照。（最近最久未使用的快照）

[java]  view plain copy

1. final ThreadPoolExecutorexecutorService =  
2.             new ThreadPoolExecutor(0, 1, 60L, TimeUnit.SECONDS,new LinkedBlockingQueue<Runnable>());  
3.     //对缓存的清理操作  
4.     privatefinal Callable<Void>cleanupCallable =new Callable<Void>() {  
5.         public Void call()throws Exception {  
6.             synchronized (DiskLruCache.this) {  
7.                 //缓存已经关闭  
8.                 if (journalWriter ==null) {  
9.                     returnnull;// Closed.  
10.                 }  
11.                //删除缓存中处于非编辑状态的entry对应的文件，使得缓存大小I小于maxSize  
12.                 trimToSize();  
13.                 //删除对于的文件，使得缓存中的文件数少于maxFileCount  
14.                 trimToFileCount();  
15.                 //判断是否需要开启新的日志  
16.                 if (journalRebuildRequired()) {  
17.                     rebuildJournal();  
18.                     redundantOpCount = 0;  
19.                 }  
20.             }  
21.             returnnull;  
22.         }  
23.     };