你的位置:首页 > Java教程

[Java教程]安卓开发笔记——关于图片的三级缓存策略(内存LruCache+磁盘DiskLruCache+网络Volley)


  在开发安卓应用中避免不了要使用到网络图片,获取网络图片很简单,但是需要付出一定的代价——流量。对于少数的图片而言问题不大,但如果手机应用中包含大量的图片,这势必会耗费用户的一定流量,如果我们不加以处理,每次打开应用都去网络获取图片,那么用户可就不乐意了,这里的处理就是指今天要讲的缓存策略(缓存层分为三层:内存层,磁盘层,网络层)。

  关于缓存层的工作,当我们第一次打开应用获取图片时,先到网络去下载图片,然后依次存入内存缓存,磁盘缓存,当我们再一次需要用到刚才下载的这张图片时,就不需要再重复的到网络上去下载,直接可以从内存缓存和磁盘缓存中找,由于内存缓存速度较快,我们优先到内存缓存中寻找该图片,如果找到则运用,如果没有找到(内存缓存大小有限),那么我们再到磁盘缓存中去找。只要我们合理的去协调这三层缓存运用,便可以提升应用性能和用户体验。

 

1、内存层:(手机内存)

内存缓存相对于磁盘缓存而言,速度要来的快很多,但缺点容量较小且会被系统回收,这里的实现我用到了LruCache。

LruCache这个类是Android3.1版本中提供的,如果你是在更早的Android版本中开发,则需要导入android-support-v4的jar包。

 

磁盘层:(SD卡)

相比内存缓存而言速度要来得慢很多,但容量很大,这里的实现我用到了DiskLruCache类。

DiskLruCache是非Google官方编写,但获得官方认证的硬盘缓存类,该类没有限定在Android内,所以理论上java应用也可以使用DiskLreCache来缓存。

 

网络层:(移动网络,无线网络)

这个就没什么解释的了,就是我们上网用的流量。这里的网络访问实现我用到了开源框架Volley。

开源框架Volley是2013年Google I/O大会发布的,Volley是Android平台上的网络通信库,能使网络通信更快,更简单,更健壮。它的设计目标就是非常适合去进行数据量不大,但通信频繁的网络操作,而对于大数据量的网络操作,比如说下载文件等,Volley的表现就会非常糟糕。

 

先来看下效果图:

正常网络下:                                        断开网络,飞行模式下:

         

Log日志打印:

 

来看下代码实现:

 

1、由于应用中很多地方需要用到上下文对象,这里我自定义了一个全局的Application,用来提供上下文对象

 1 package com.lcw.rabbit.image.utils; 2  3 import android.app.Application; 4 /** 5  * Application类,提供全局上下文对象 6  * @author Rabbit_Lee 7  * 8 */ 9 public class MyApplication extends Application {10 11   public static String TAG;12   public static MyApplication myApplication;13 14   public static MyApplication newInstance() {15     return myApplication;16   }17 18   @Override19   public void onCreate() {20     super.onCreate();21     TAG = this.getClass().getSimpleName();22     myApplication = this;23 24   }25 }

 

2、Volley请求队列处理类,用来管理Rquest请求对象操作

 1 package com.lcw.rabbit.image; 2  3 import com.android.volley.Request; 4 import com.android.volley.RequestQueue; 5 import com.android.volley.toolbox.Volley; 6 import com.lcw.rabbit.image.utils.MyApplication; 7  8 /** 9  * 请求队列处理类10  * 获取RequestQueue对象11 */12 public class VolleyRequestQueueManager {13   // 获取请求队列类14   public static RequestQueue mRequestQueue = Volley.newRequestQueue(MyApplication.newInstance());15 16   //添加任务进任务队列17   public static void addRequest(Request<?> request, Object tag) {18     if (tag != null) {19       request.setTag(tag);20     }21     mRequestQueue.add(request);22   }23   24   //取消任务25   public static void cancelRequest(Object tag){26     mRequestQueue.cancelAll(tag);27   }28   29   30 31 }

 

3、这里附上2个工具类(生成MD5序列帮助类,DiskLruCache磁盘缓存类)

 1 package com.lcw.rabbit.image.utils; 2  3 import java.math.BigInteger; 4 import java.security.MessageDigest; 5 import java.security.NoSuchAlgorithmException; 6  7 public class MD5Utils { 8   /** 9    * 使用md5的算法进行加密10   */11   public static String md5(String plainText) {12     byte[] secretBytes = null;13     try {14       secretBytes = MessageDigest.getInstance("md5").digest(15           plainText.getBytes());16     } catch (NoSuchAlgorithmException e) {17       throw new RuntimeException("没有md5这个算法!");18     }19     String md5code = new BigInteger(1, secretBytes).toString(16);// 16进制数字20     // 如果生成数字未满32位,需要前面补021     for (int i = 0; i < 32 - md5code.length(); i++) {22       md5code = "0" + md5code;23     }24     return md5code;25   }26 27 }

MD5转换类

 

 1 /* 2  * Copyright (C) 2011 The Android Open Source Project 3  * 4  * Licensed under the Apache License, Version 2.0 (the "License"); 5  * you may not use this file except in compliance with the License. 6  * You may obtain a copy of the License at 7  * 8  *   http://www.apache.org/licenses/LICENSE-2.0 9  * 10  * Unless required by applicable law or agreed to in writing, software 11  * distributed under the License is distributed on an "AS IS" BASIS, 12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13  * See the License for the specific language governing permissions and 14  * limitations under the License. 15 */ 16  17 package com.lcw.rabbit.image.utils; 18  19 import java.io.BufferedInputStream; 20 import java.io.BufferedWriter; 21 import java.io.Closeable; 22 import java.io.EOFException; 23 import java.io.File; 24 import java.io.FileInputStream; 25 import java.io.FileNotFoundException; 26 import java.io.FileOutputStream; 27 import java.io.FileWriter; 28 import java.io.FilterOutputStream; 29 import java.io.IOException; 30 import java.io.InputStream; 31 import java.io.InputStreamReader; 32 import java.io.OutputStream; 33 import java.io.OutputStreamWriter; 34 import java.io.Reader; 35 import java.io.StringWriter; 36 import java.io.Writer; 37 import java.lang.reflect.Array; 38 import java.nio.charset.Charset; 39 import java.util.ArrayList; 40 import java.util.Arrays; 41 import java.util.Iterator; 42 import java.util.LinkedHashMap; 43 import java.util.Map; 44 import java.util.concurrent.Callable; 45 import java.util.concurrent.ExecutorService; 46 import java.util.concurrent.LinkedBlockingQueue; 47 import java.util.concurrent.ThreadPoolExecutor; 48 import java.util.concurrent.TimeUnit; 49  50 /** 51  ****************************************************************************** 52  * Taken from the JB source code, can be found in: 53  * libcore/luni/src/main/java/libcore/io/DiskLruCache.java 54  * or direct link: 55  * https://android.googlesource.com/platform/libcore/+/android-4.1.1_r1/luni/src/main/java/libcore/io/DiskLruCache.java 56  ****************************************************************************** 57  * 58  * A cache that uses a bounded amount of space on a filesystem. Each cache 59  * entry has a string key and a fixed number of values. Values are byte 60  * sequences, accessible as streams or files. Each value must be between {@code 61  * 0} and {@code Integer.MAX_VALUE} bytes in length. 62  * 63  * <p>The cache stores its data in a directory on the filesystem. This 64  * directory must be exclusive to the cache; the cache may delete or overwrite 65  * files from its directory. It is an error for multiple processes to use the 66  * same cache directory at the same time. 67  * 68  * <p>This cache limits the number of bytes that it will store on the 69  * filesystem. When the number of stored bytes exceeds the limit, the cache will 70  * remove entries in the background until the limit is satisfied. The limit is 71  * not strict: the cache may temporarily exceed it while waiting for files to be 72  * deleted. The limit does not include filesystem overhead or the cache 73  * journal so space-sensitive applications should set a conservative limit. 74  * 75  * <p>Clients call {@link #edit} to create or update the values of an entry. An 76  * entry may have only one editor at one time; if a value is not available to be 77  * edited then {@link #edit} will return null. 78  * <ul> 79  *   <li>When an entry is being <strong>created</strong> it is necessary to 80  *     supply a full set of values; the empty value should be used as a 81  *     placeholder if necessary. 82  *   <li>When an entry is being <strong>edited</strong>, it is not necessary 83  *     to supply data for every value; values default to their previous 84  *     value. 85  * </ul> 86  * Every {@link #edit} call must be matched by a call to {@link Editor#commit} 87  * or {@link Editor#abort}. Committing is atomic: a read observes the full set 88  * of values as they were before or after the commit, but never a mix of values. 89  * 90  * <p>Clients call {@link #get} to read a snapshot of an entry. The read will 91  * observe the value at the time that {@link #get} was called. Updates and 92  * removals after the call do not impact ongoing reads. 93  * 94  * <p>This class is tolerant of some I/O errors. If files are missing from the 95  * filesystem, the corresponding entries will be dropped from the cache. If 96  * an error occurs while writing a cache value, the edit will fail silently. 97  * Callers should handle other problems by catching {@code IOException} and 98  * responding appropriately. 99 */100 public final class DiskLruCache implements Closeable {101   static final String JOURNAL_FILE = "journal";102   static final String JOURNAL_FILE_TMP = "journal.tmp";103   static final String MAGIC = "libcore.io.DiskLruCache";104   static final String VERSION_1 = "1";105   static final long ANY_SEQUENCE_NUMBER = -1;106   private static final String CLEAN = "CLEAN";107   private static final String DIRTY = "DIRTY";108   private static final String REMOVE = "REMOVE";109   private static final String READ = "READ";110 111   private static final Charset UTF_8 = Charset.forName("UTF-8");112   private static final int IO_BUFFER_SIZE = 8 * 1024;113 114   /*115    * This cache uses a journal file named "journal". A typical journal file116    * looks like this:117    *   libcore.io.DiskLruCache118    *   1119    *   100120    *   2121    *122    *   CLEAN 3400330d1dfc7f3f7f4b8d4d803dfcf6 832 21054123    *   DIRTY 335c4c6028171cfddfbaae1a9c313c52124    *   CLEAN 335c4c6028171cfddfbaae1a9c313c52 3934 2342125    *   REMOVE 335c4c6028171cfddfbaae1a9c313c52126    *   DIRTY 1ab96a171faeeee38496d8b330771a7a127    *   CLEAN 1ab96a171faeeee38496d8b330771a7a 1600 234128    *   READ 335c4c6028171cfddfbaae1a9c313c52129    *   READ 3400330d1dfc7f3f7f4b8d4d803dfcf6130    *131    * The first five lines of the journal form its header. They are the132    * constant string "libcore.io.DiskLruCache", the disk cache's version,133    * the application's version, the value count, and a blank line.134    *135    * Each of the subsequent lines in the file is a record of the state of a136    * cache entry. Each line contains space-separated values: a state, a key,137    * and optional state-specific values.138    *  o DIRTY lines track that an entry is actively being created or updated.139    *   Every successful DIRTY action should be followed by a CLEAN or REMOVE140    *   action. DIRTY lines without a matching CLEAN or REMOVE indicate that141    *   temporary files may need to be deleted.142    *  o CLEAN lines track a cache entry that has been successfully published143    *   and may be read. A publish line is followed by the lengths of each of144    *   its values.145    *  o READ lines track accesses for LRU.146    *  o REMOVE lines track entries that have been deleted.147    *148    * The journal file is appended to as cache operations occur. The journal may149    * occasionally be compacted by dropping redundant lines. A temporary file named150    * "journal.tmp" will be used during compaction; that file should be deleted if151    * it exists when the cache is opened.152   */153 154   private final File directory;155   private final File journalFile;156   private final File journalFileTmp;157   private final int appVersion;158   private final long maxSize;159   private final int valueCount;160   private long size = 0;161   private Writer journalWriter;162   private final LinkedHashMap<String, Entry> lruEntries163       = new LinkedHashMap<String, Entry>(0, 0.75f, true);164   private int redundantOpCount;165 166   /**167    * To differentiate between old and current snapshots, each entry is given168    * a sequence number each time an edit is committed. A snapshot is stale if169    * its sequence number is not equal to its entry's sequence number.170   */171   private long nextSequenceNumber = 0;172 173   /* From java.util.Arrays */174   @SuppressWarnings("unchecked")175   private static <T> T[] copyOfRange(T[] original, int start, int end) {176     final int originalLength = original.length; // For exception priority compatibility.177     if (start > end) {178       throw new IllegalArgumentException();179     }180     if (start < 0 || start > originalLength) {181       throw new ArrayIndexOutOfBoundsException();182     }183     final int resultLength = end - start;184     final int copyLength = Math.min(resultLength, originalLength - start);185     final T[] result = (T[]) Array186         .newInstance(original.getClass().getComponentType(), resultLength);187     System.arraycopy(original, start, result, 0, copyLength);188     return result;189   }190 191   /**192    * Returns the remainder of 'reader' as a string, closing it when done.193   */194   public static String readFully(Reader reader) throws IOException {195     try {196       StringWriter writer = new StringWriter();197       char[] buffer = new char[1024];198       int count;199       while ((count = reader.read(buffer)) != -1) {200         writer.write(buffer, 0, count);201       }202       return writer.toString();203     } finally {204       reader.close();205     }206   }207 208   /**209    * Returns the ASCII characters up to but not including the next "\r\n", or210    * "\n".211    *212    * @throws java.io.EOFException if the stream is exhausted before the next newline213    *   character.214   */215   public static String readAsciiLine(InputStream in) throws IOException {216     // TODO: support UTF-8 here instead217 218     StringBuilder result = new StringBuilder(80);219     while (true) {220       int c = in.read();221       if (c == -1) {222         throw new EOFException();223       } else if (c == '\n') {224         break;225       }226 227       result.append((char) c);228     }229     int length = result.length();230     if (length > 0 && result.charAt(length - 1) == '\r') {231       result.setLength(length - 1);232     }233     return result.toString();234   }235 236   /**237    * Closes 'closeable', ignoring any checked exceptions. Does nothing if 'closeable' is null.238   */239   public static void closeQuietly(Closeable closeable) {240     if (closeable != null) {241       try {242         closeable.close();243       } catch (RuntimeException rethrown) {244         throw rethrown;245       } catch (Exception ignored) {246       }247     }248   }249 250   /**251    * Recursively delete everything in {@code dir}.252   */253   // TODO: this should specify paths as Strings rather than as Files254   public static void deleteContents(File dir) throws IOException {255     File[] files = dir.listFiles();256     if (files == null) {257       throw new IllegalArgumentException("not a directory: " + dir);258     }259     for (File file : files) {260       if (file.isDirectory()) {261         deleteContents(file);262       }263       if (!file.delete()) {264         throw new IOException("failed to delete file: " + file);265       }266     }267   }268 269   /** This cache uses a single background thread to evict entries. */270   private final ExecutorService executorService = new ThreadPoolExecutor(0, 1,271       60L, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());272   private final Callable<Void> cleanupCallable = new Callable<Void>() {273     @Override public Void call() throws Exception {274       synchronized (DiskLruCache.this) {275         if (journalWriter == null) {276           return null; // closed277         }278         trimToSize();279         if (journalRebuildRequired()) {280           rebuildJournal();281           redundantOpCount = 0;282         }283       }284       return null;285     }286   };287 288   private DiskLruCache(File directory, int appVersion, int valueCount, long maxSize) {289     this.directory = directory;290     this.appVersion = appVersion;291     this.journalFile = new File(directory, JOURNAL_FILE);292     this.journalFileTmp = new File(directory, JOURNAL_FILE_TMP);293     this.valueCount = valueCount;294     this.maxSize = maxSize;295   }296 297   /**298    * Opens the cache in {@code directory}, creating a cache if none exists299    * there.300    *301    * @param directory a writable directory302    * @param appVersion303    * @param valueCount the number of values per cache entry. Must be positive.304    * @param maxSize the maximum number of bytes this cache should use to store305    * @throws java.io.IOException if reading or writing the cache directory fails306   */307   public static DiskLruCache open(File directory, int appVersion, int valueCount, long maxSize)308       throws IOException {309     if (maxSize <= 0) {310       throw new IllegalArgumentException("maxSize <= 0");311     }312     if (valueCount <= 0) {313       throw new IllegalArgumentException("valueCount <= 0");314     }315 316     // prefer to pick up where we left off317     DiskLruCache cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);318     if (cache.journalFile.exists()) {319       try {320         cache.readJournal();321         cache.processJournal();322         cache.journalWriter = new BufferedWriter(new FileWriter(cache.journalFile, true),323             IO_BUFFER_SIZE);324         return cache;325       } catch (IOException journalIsCorrupt) {326 //        System.logW("DiskLruCache " + directory + " is corrupt: "327 //            + journalIsCorrupt.getMessage() + ", removing");328         cache.delete();329       }330     }331 332     // create a new empty cache333     directory.mkdirs();334     cache = new DiskLruCache(directory, appVersion, valueCount, maxSize);335     cache.rebuildJournal();336     return cache;337   }338 339   private void readJournal() throws IOException {340     InputStream in = new BufferedInputStream(new FileInputStream(journalFile), IO_BUFFER_SIZE);341     try {342       String magic = readAsciiLine(in);343       String version = readAsciiLine(in);344       String appVersionString = readAsciiLine(in);345       String valueCountString = readAsciiLine(in);346       String blank = readAsciiLine(in);347       if (!MAGIC.equals(magic)348           || !VERSION_1.equals(version)349           || !Integer.toString(appVersion).equals(appVersionString)350           || !Integer.toString(valueCount).equals(valueCountString)351           || !"".equals(blank)) {352         throw new IOException("unexpected journal header: ["353             + magic + ", " + version + ", " + valueCountString + ", " + blank + "]");354       }355 356       while (true) {357         try {358           readJournalLine(readAsciiLine(in));359         } catch (EOFException endOfJournal) {360           break;361         }362       }363     } finally {364       closeQuietly(in);365     }366   }367 368   private void readJournalLine(String line) throws IOException {369     String[] parts = line.split(" ");370     if (parts.length < 2) {371       throw new IOException("unexpected journal line: " + line);372     }373 374     String key = parts[1];375     if (parts[0].equals(REMOVE) && parts.length == 2) {376       lruEntries.remove(key);377       return;378     }379 380     Entry entry = lruEntries.get(key);381     if (entry == null) {382       entry = new Entry(key);383       lruEntries.put(key, entry);384     }385 386     if (parts[0].equals(CLEAN) && parts.length == 2 + valueCount) {387       entry.readable = true;388       entry.currentEditor = null;389       entry.setLengths(copyOfRange(parts, 2, parts.length));390     } else if (parts[0].equals(DIRTY) && parts.length == 2) {391       entry.currentEditor = new Editor(entry);392     } else if (parts[0].equals(READ) && parts.length == 2) {393       // this work was already done by calling lruEntries.get()394     } else {395       throw new IOException("unexpected journal line: " + line);396     }397   }398 399   /**400    * Computes the initial size and collects garbage as a part of opening the401    * cache. Dirty entries are assumed to be inconsistent and will be deleted.402   */403   private void processJournal() throws IOException {404     deleteIfExists(journalFileTmp);405     for (Iterator<Entry> i = lruEntries.values().iterator(); i.hasNext(); ) {406       Entry entry = i.next();407       if (entry.currentEditor == null) {408         for (int t = 0; t < valueCount; t++) {409           size += entry.lengths[t];410         }411       } else {412         entry.currentEditor = null;413         for (int t = 0; t < valueCount; t++) {414           deleteIfExists(entry.getCleanFile(t));415           deleteIfExists(entry.getDirtyFile(t));416         }417         i.remove();418       }419     }420   }421 422   /**423    * Creates a new journal that omits redundant information. This replaces the424    * current journal if it exists.425   */426   private synchronized void rebuildJournal() throws IOException {427     if (journalWriter != null) {428       journalWriter.close();429     }430 431     Writer writer = new BufferedWriter(new FileWriter(journalFileTmp), IO_BUFFER_SIZE);432     writer.write(MAGIC);433     writer.write("\n");434     writer.write(VERSION_1);435     writer.write("\n");436     writer.write(Integer.toString(appVersion));437     writer.write("\n");438     writer.write(Integer.toString(valueCount));439     writer.write("\n");440     writer.write("\n");441 442     for (Entry entry : lruEntries.values()) {443       if (entry.currentEditor != null) {444         writer.write(DIRTY + ' ' + entry.key + '\n');445       } else {446         writer.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');447       }448     }449 450     writer.close();451     journalFileTmp.renameTo(journalFile);452     journalWriter = new BufferedWriter(new FileWriter(journalFile, true), IO_BUFFER_SIZE);453   }454 455   private static void deleteIfExists(File file) throws IOException {456 //    try {457 //      Libcore.os.remove(file.getPath());458 //    } catch (ErrnoException errnoException) {459 //      if (errnoException.errno != OsConstants.ENOENT) {460 //        throw errnoException.rethrowAsIOException();461 //      }462 //    }463     if (file.exists() && !file.delete()) {464       throw new IOException();465     }466   }467 468   /**469    * Returns a snapshot of the entry named {@code key}, or null if it doesn't470    * exist is not currently readable. If a value is returned, it is moved to471    * the head of the LRU queue.472   */473   public synchronized Snapshot get(String key) throws IOException {474     checkNotClosed();475     validateKey(key);476     Entry entry = lruEntries.get(key);477     if (entry == null) {478       return null;479     }480 481     if (!entry.readable) {482       return null;483     }484 485     /*486      * Open all streams eagerly to guarantee that we see a single published487      * snapshot. If we opened streams lazily then the streams could come488      * from different edits.489     */490     InputStream[] ins = new InputStream[valueCount];491     try {492       for (int i = 0; i < valueCount; i++) {493         ins[i] = new FileInputStream(entry.getCleanFile(i));494       }495     } catch (FileNotFoundException e) {496       // a file must have been deleted manually!497       return null;498     }499 500     redundantOpCount++;501     journalWriter.append(READ + ' ' + key + '\n');502     if (journalRebuildRequired()) {503       executorService.submit(cleanupCallable);504     }505 506     return new Snapshot(key, entry.sequenceNumber, ins);507   }508 509   /**510    * Returns an editor for the entry named {@code key}, or null if another511    * edit is in progress.512   */513   public Editor edit(String key) throws IOException {514     return edit(key, ANY_SEQUENCE_NUMBER);515   }516 517   private synchronized Editor edit(String key, long expectedSequenceNumber) throws IOException {518     checkNotClosed();519     validateKey(key);520     Entry entry = lruEntries.get(key);521     if (expectedSequenceNumber != ANY_SEQUENCE_NUMBER522         && (entry == null || entry.sequenceNumber != expectedSequenceNumber)) {523       return null; // snapshot is stale524     }525     if (entry == null) {526       entry = new Entry(key);527       lruEntries.put(key, entry);528     } else if (entry.currentEditor != null) {529       return null; // another edit is in progress530     }531 532     Editor editor = new Editor(entry);533     entry.currentEditor = editor;534 535     // flush the journal before creating files to prevent file leaks536     journalWriter.write(DIRTY + ' ' + key + '\n');537     journalWriter.flush();538     return editor;539   }540 541   /**542    * Returns the directory where this cache stores its data.543   */544   public File getDirectory() {545     return directory;546   }547 548   /**549    * Returns the maximum number of bytes that this cache should use to store550    * its data.551   */552   public long maxSize() {553     return maxSize;554   }555 556   /**557    * Returns the number of bytes currently being used to store the values in558    * this cache. This may be greater than the max size if a background559    * deletion is pending.560   */561   public synchronized long size() {562     return size;563   }564 565   private synchronized void completeEdit(Editor editor, boolean success) throws IOException {566     Entry entry = editor.entry;567     if (entry.currentEditor != editor) {568       throw new IllegalStateException();569     }570 571     // if this edit is creating the entry for the first time, every index must have a value572     if (success && !entry.readable) {573       for (int i = 0; i < valueCount; i++) {574         if (!entry.getDirtyFile(i).exists()) {575           editor.abort();576           throw new IllegalStateException("edit didn't create file " + i);577         }578       }579     }580 581     for (int i = 0; i < valueCount; i++) {582       File dirty = entry.getDirtyFile(i);583       if (success) {584         if (dirty.exists()) {585           File clean = entry.getCleanFile(i);586           dirty.renameTo(clean);587           long oldLength = entry.lengths[i];588           long newLength = clean.length();589           entry.lengths[i] = newLength;590           size = size - oldLength + newLength;591         }592       } else {593         deleteIfExists(dirty);594       }595     }596 597     redundantOpCount++;598     entry.currentEditor = null;599     if (entry.readable | success) {600       entry.readable = true;601       journalWriter.write(CLEAN + ' ' + entry.key + entry.getLengths() + '\n');602       if (success) {603         entry.sequenceNumber = nextSequenceNumber++;604       }605     } else {606       lruEntries.remove(entry.key);607       journalWriter.write(REMOVE + ' ' + entry.key + '\n');608     }609 610     if (size > maxSize || journalRebuildRequired()) {611       executorService.submit(cleanupCallable);612     }613   }614 615   /**616    * We only rebuild the journal when it will halve the size of the journal617    * and eliminate at least 2000 ops.618   */619   private boolean journalRebuildRequired() {620     final int REDUNDANT_OP_COMPACT_THRESHOLD = 2000;621     return redundantOpCount >= REDUNDANT_OP_COMPACT_THRESHOLD622         && redundantOpCount >= lruEntries.size();623   }624 625   /**626    * Drops the entry for {@code key} if it exists and can be removed. Entries627    * actively being edited cannot be removed.628    *629    * @return true if an entry was removed.630   */631   public synchronized boolean remove(String key) throws IOException {632     checkNotClosed();633     validateKey(key);634     Entry entry = lruEntries.get(key);635     if (entry == null || entry.currentEditor != null) {636       return false;637     }638 639     for (int i = 0; i < valueCount; i++) {640       File file = entry.getCleanFile(i);641       if (!file.delete()) {642         throw new IOException("failed to delete " + file);643       }644       size -= entry.lengths[i];645       entry.lengths[i] = 0;646     }647 648     redundantOpCount++;649     journalWriter.append(REMOVE + ' ' + key + '\n');650     lruEntries.remove(key);651 652     if (journalRebuildRequired()) {653       executorService.submit(cleanupCallable);654     }655 656     return true;657   }658 659   /**660    * Returns true if this cache has been closed.661   */662   public boolean isClosed() {663     return journalWriter == null;664   }665 666   private void checkNotClosed() {667     if (journalWriter == null) {668       throw new IllegalStateException("cache is closed");669     }670   }671 672   /**673    * Force buffered operations to the filesystem.674   */675   public synchronized void flush() throws IOException {676     checkNotClosed();677     trimToSize();678     journalWriter.flush();679   }680 681   /**682    * Closes this cache. Stored values will remain on the filesystem.683   */684   public synchronized void close() throws IOException {685     if (journalWriter == null) {686       return; // already closed687     }688     for (Entry entry : new ArrayList<Entry>(lruEntries.values())) {689       if (entry.currentEditor != null) {690         entry.currentEditor.abort();691       }692     }693     trimToSize();694     journalWriter.close();695     journalWriter = null;696   }697 698   private void trimToSize() throws IOException {699     while (size > maxSize) {700 //      Map.Entry<String, Entry> toEvict = lruEntries.eldest();701       final Map.Entry<String, Entry> toEvict = lruEntries.entrySet().iterator().next();702       remove(toEvict.getKey());703     }704   }705 706   /**707    * Closes the cache and deletes all of its stored values. This will delete708    * all files in the cache directory including files that weren't created by709    * the cache.710   */711   public void delete() throws IOException {712     close();713     deleteContents(directory);714   }715 716   private void validateKey(String key) {717     if (key.contains(" ") || key.contains("\n") || key.contains("\r")) {718       throw new IllegalArgumentException(719           "keys must not contain spaces or newlines: \"" + key + "\"");720     }721   }722 723   private static String inputStreamToString(InputStream in) throws IOException {724     return readFully(new InputStreamReader(in, UTF_8));725   }726 727   /**728    * A snapshot of the values for an entry.729   */730   public final class Snapshot implements Closeable {731     private final String key;732     private final long sequenceNumber;733     private final InputStream[] ins;734 735     private Snapshot(String key, long sequenceNumber, InputStream[] ins) {736       this.key = key;737       this.sequenceNumber = sequenceNumber;738       this.ins = ins;739     }740 741     /**742      * Returns an editor for this snapshot's entry, or null if either the743      * entry has changed since this snapshot was created or if another edit744      * is in progress.745     */746     public Editor edit() throws IOException {747       return DiskLruCache.this.edit(key, sequenceNumber);748     }749 750     /**751      * Returns the unbuffered stream with the value for {@code index}.752     */753     public InputStream getInputStream(int index) {754       return ins[index];755     }756 757     /**758      * Returns the string value for {@code index}.759     */760     public String getString(int index) throws IOException {761       return inputStreamToString(getInputStream(index));762     }763 764     @Override public void close() {765       for (InputStream in : ins) {766         closeQuietly(in);767       }768     }769   }770 771   /**772    * Edits the values for an entry.773   */774   public final class Editor {775     private final Entry entry;776     private boolean hasErrors;777 778     private Editor(Entry entry) {779       this.entry = entry;780     }781 782     /**783      * Returns an unbuffered input stream to read the last committed value,784      * or null if no value has been committed.785     */786     public InputStream newInputStream(int index) throws IOException {787       synchronized (DiskLruCache.this) {788         if (entry.currentEditor != this) {789           throw new IllegalStateException();790         }791         if (!entry.readable) {792           return null;793         }794         return new FileInputStream(entry.getCleanFile(index));795       }796     }797 798     /**799      * Returns the last committed value as a string, or null if no value800      * has been committed.801     */802     public String getString(int index) throws IOException {803       InputStream in = newInputStream(index);804       return in != null ? inputStreamToString(in) : null;805     }806 807     /**808      * Returns a new unbuffered output stream to write the value at809      * {@code index}. If the underlying output stream encounters errors810      * when writing to the filesystem, this edit will be aborted when811      * {@link #commit} is called. The returned output stream does not throw812      * IOExceptions.813     */814     public OutputStream newOutputStream(int index) throws IOException {815       synchronized (DiskLruCache.this) {816         if (entry.currentEditor != this) {817           throw new IllegalStateException();818         }819         return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));820       }821     }822 823     /**824      * Sets the value at {@code index} to {@code value}.825     */826     public void set(int index, String value) throws IOException {827       Writer writer = null;828       try {829         writer = new OutputStreamWriter(newOutputStream(index), UTF_8);830         writer.write(value);831       } finally {832         closeQuietly(writer);833       }834     }835 836     /**837      * Commits this edit so it is visible to readers. This releases the838      * edit lock so another edit may be started on the same key.839     */840     public void commit() throws IOException {841       if (hasErrors) {842         completeEdit(this, false);843         remove(entry.key); // the previous entry is stale844       } else {845         completeEdit(this, true);846       }847     }848 849     /**850      * Aborts this edit. This releases the edit lock so another edit may be851      * started on the same key.852     */853     public void abort() throws IOException {854       completeEdit(this, false);855     }856 857     private class FaultHidingOutputStream extends FilterOutputStream {858       private FaultHidingOutputStream(OutputStream out) {859         super(out);860       }861 862       @Override public void write(int oneByte) {863         try {864           out.write(oneByte);865         } catch (IOException e) {866           hasErrors = true;867         }868       }869 870       @Override public void write(byte[] buffer, int offset, int length) {871         try {872           out.write(buffer, offset, length);873         } catch (IOException e) {874           hasErrors = true;875         }876       }877 878       @Override public void close() {879         try {880           out.close();881         } catch (IOException e) {882           hasErrors = true;883         }884       }885 886       @Override public void flush() {887         try {888           out.flush();889         } catch (IOException e) {890           hasErrors = true;891         }892       }893     }894   }895 896   private final class Entry {897     private final String key;898 899     /** Lengths of this entry's files. */900     private final long[] lengths;901 902     /** True if this entry has ever been published */903     private boolean readable;904 905     /** The ongoing edit or null if this entry is not being edited. */906     private Editor currentEditor;907 908     /** The sequence number of the most recently committed edit to this entry. */909     private long sequenceNumber;910 911     private Entry(String key) {912       this.key = key;913       this.lengths = new long[valueCount];914     }915 916     public String getLengths() throws IOException {917       StringBuilder result = new StringBuilder();918       for (long size : lengths) {919         result.append(' ').append(size);920       }921       return result.toString();922     }923 924     /**925      * Set lengths using decimal numbers like "10123".926     */927     private void setLengths(String[] strings) throws IOException {928       if (strings.length != valueCount) {929         throw invalidLengths(strings);930       }931 932       try {933         for (int i = 0; i < strings.length; i++) {934           lengths[i] = Long.parseLong(strings[i]);935         }936       } catch (NumberFormatException e) {937         throw invalidLengths(strings);938       }939     }940 941     private IOException invalidLengths(String[] strings) throws IOException {942       throw new IOException("unexpected journal line: " + Arrays.toString(strings));943     }944 945     public File getCleanFile(int i) {946       return new File(directory, key + "." + i);947     }948 949     public File getDirtyFile(int i) {950       return new File(directory, key + "." + i + ".tmp");951     }952   }953 }

DiskLruCache磁盘缓存类

 

4、图片缓存类,包含(LruCache内存缓存,DiskLruCache磁盘缓存)

 1 package com.lcw.rabbit.image.utils; 2  3 import java.io.File; 4 import java.io.IOException; 5 import java.io.OutputStream; 6  7 import android.content.Context; 8 import android.content.pm.PackageInfo; 9 import android.content.pm.PackageManager.NameNotFoundException; 10 import android.graphics.Bitmap; 11 import android.graphics.Bitmap.CompressFormat; 12 import android.graphics.BitmapFactory; 13 import android.os.Environment; 14 import android.support.v4.util.LruCache; 15 import android.util.Log; 16  17 import com.android.volley.toolbox.ImageLoader.ImageCache; 18 import com.lcw.rabbit.image.utils.DiskLruCache.Snapshot; 19  20 /** 21  * 图片缓存帮助类 22  *  23  * 包含内存缓存LruCache和磁盘缓存DiskLruCache 24  *  25  * @author Rabbit_Lee 26  *  27 */ 28 public class ImageCacheUtil implements ImageCache { 29    30   private String TAG=ImageCacheUtil.this.getClass().getSimpleName(); 31  32   //缓存类 33   private static LruCache<String, Bitmap> mLruCache; 34   private static DiskLruCache mDiskLruCache; 35  36   //磁盘缓存大小 37   private static final int DISKMAXSIZE = 10 * 1024 * 1024; 38  39   public ImageCacheUtil() { 40     // 获取应用可占内存的1/8作为缓存 41     int maxSize = (int) (Runtime.getRuntime().maxMemory() / 8); 42     // 实例化LruCaceh对象 43     mLruCache = new LruCache<String, Bitmap>(maxSize) { 44       @Override 45       protected int sizeOf(String key, Bitmap bitmap) { 46         return bitmap.getRowBytes() * bitmap.getHeight(); 47       } 48     }; 49     try { 50       // 获取DiskLruCahce对象 51       mDiskLruCache = DiskLruCache.open(getDiskCacheDir(MyApplication.newInstance(), "Rabbit"), getAppVersion(MyApplication.newInstance()), 1, DISKMAXSIZE); 52     } catch (IOException e) { 53       e.printStackTrace(); 54     } 55   } 56  57   /** 58    * 从缓存(内存缓存,磁盘缓存)中获取Bitmap 59   */ 60   @Override 61   public Bitmap getBitmap(String url) { 62     if (mLruCache.get(url) != null) { 63       // 从LruCache缓存中取 64       Log.i(TAG,"从LruCahce获取"); 65       return mLruCache.get(url); 66     } else { 67       String key = MD5Utils.md5(url); 68       try { 69         if (mDiskLruCache.get(key) != null) { 70           // 从DiskLruCahce取 71           Snapshot snapshot = mDiskLruCache.get(key); 72           Bitmap bitmap = null; 73           if (snapshot != null) { 74             bitmap = BitmapFactory.decodeStream(snapshot.getInputStream(0)); 75             // 存入LruCache缓存 76             mLruCache.put(url, bitmap); 77             Log.i(TAG,"从DiskLruCahce获取"); 78           } 79           return bitmap; 80         } 81       } catch (IOException e) { 82         e.printStackTrace(); 83       } 84     } 85     return null; 86   } 87  88   /** 89    * 存入缓存(内存缓存,磁盘缓存) 90   */ 91   @Override 92   public void putBitmap(String url, Bitmap bitmap) { 93     // 存入LruCache缓存 94     mLruCache.put(url, bitmap); 95     // 判断是否存在DiskLruCache缓存,若没有存入 96     String key = MD5Utils.md5(url); 97     try { 98       if (mDiskLruCache.get(key) == null) { 99         DiskLruCache.Editor editor = mDiskLruCache.edit(key);100         if (editor != null) {101           OutputStream outputStream = editor.newOutputStream(0);102           if (bitmap.compress(CompressFormat.JPEG, 100, outputStream)) {103             editor.commit();104           } else {105             editor.abort();106           }107         }108         mDiskLruCache.flush();109       }110     } catch (IOException e) {111       e.printStackTrace();112     }113 114   }115 116   /**117    * 该方法会判断当前sd卡是否存在,然后选择缓存地址118    * 119    * @param context120    * @param uniqueName121    * @return122   */123   public static File getDiskCacheDir(Context context, String uniqueName) {124     String cachePath;125     if (Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState()) || !Environment.isExternalStorageRemovable()) {126       cachePath = context.getExternalCacheDir().getPath();127     } else {128       cachePath = context.getCacheDir().getPath();129     }130     return new File(cachePath + File.separator + uniqueName);131   }132 133   /**134    * 获取应用版本号135    * 136    * @param context137    * @return138   */139   public int getAppVersion(Context context) {140     try {141       PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);142       return info.versionCode;143     } catch (NameNotFoundException e) {144       e.printStackTrace();145     }146     return 1;147   }148 149 }

 

5、图片缓存管理类

这里的图片加载运用到了Volley自带的ImageLoader,在它的构造方法中需要一个ImageCache对象,在上面的图片缓存类已实现了该接口。

这里向外部提供了一个loadImage的重载方法,一个传入加载图片的宽高,一个默认加载原图,使得外部不再需要关注任何关于缓存的操作。

 1 package com.lcw.rabbit.image; 2  3 import android.graphics.Bitmap; 4 import android.widget.ImageView; 5  6 import com.android.volley.VolleyError; 7 import com.android.volley.toolbox.ImageLoader; 8 import com.android.volley.toolbox.ImageLoader.ImageCache; 9 import com.android.volley.toolbox.ImageLoader.ImageContainer;10 import com.android.volley.toolbox.ImageLoader.ImageListener;11 import com.lcw.rabbit.image.utils.ImageCacheUtil;12 13 /**14  * 图片缓存管理类 获取ImageLoader对象15  * 16  * @author Rabbit_Lee17  * 18 */19 public class ImageCacheManager {20 21   private static String TAG = ImageCacheManager.class.getSimpleName();22 23   // 获取图片缓存类对象24   private static ImageCache mImageCache = new ImageCacheUtil();25   // 获取ImageLoader对象26   public static ImageLoader mImageLoader = new ImageLoader(VolleyRequestQueueManager.mRequestQueue, mImageCache);27 28   /**29    * 获取ImageListener30    * 31    * @param view32    * @param defaultImage33    * @param errorImage34    * @return35   */36   public static ImageListener getImageListener(final ImageView view, final Bitmap defaultImage, final Bitmap errorImage) {37 38     return new ImageListener() {39 40       @Override41       public void onErrorResponse(VolleyError error) {42         // 回调失败43         if (errorImage != null) {44           view.setImageBitmap(errorImage);45         }46       }47 48       @Override49       public void onResponse(ImageContainer response, boolean isImmediate) {50         // 回调成功51         if (response.getBitmap() != null) {52           view.setImageBitmap(response.getBitmap());53         } else if (defaultImage != null) {54           view.setImageBitmap(defaultImage);55         }56       }57     };58 59   }60 61   /**62    * 提供给外部调用方法63    * 64    * @param url65    * @param view66    * @param defaultImage67    * @param errorImage68   */69   public static void loadImage(String url, ImageView view, Bitmap defaultImage, Bitmap errorImage) {70     mImageLoader.get(url, ImageCacheManager.getImageListener(view, defaultImage, errorImage), 0, 0);71   }72 73   /**74    * 提供给外部调用方法75    * 76    * @param url77    * @param view78    * @param defaultImage79    * @param errorImage80   */81   public static void loadImage(String url, ImageView view, Bitmap defaultImage, Bitmap errorImage, int maxWidth, int maxHeight) {82     mImageLoader.get(url, ImageCacheManager.getImageListener(view, defaultImage, errorImage), maxWidth, maxHeight);83   }84 }

 

6、MainActivity类

 1 package com.lcw.rabbit.image; 2  3 import android.app.Activity; 4 import android.content.res.Resources; 5 import android.graphics.Bitmap; 6 import android.graphics.BitmapFactory; 7 import android.os.Bundle; 8 import android.view.View; 9 import android.view.View.OnClickListener;10 import android.widget.Button;11 import android.widget.ImageView;12 13 public class MainActivity extends Activity {14 15   private Button mButton;16   private ImageView mImageView;17 18   @Override19   protected void onCreate(Bundle savedInstanceState) {20     super.onCreate(savedInstanceState);21     setContentView(R.layout.activity_main);22     mButton = (Button) findViewById(R.id.button);23     mImageView= (ImageView) findViewById(R.id.image);24     25 26     mButton.setOnClickListener(new OnClickListener() {27 28       @Override29       public void onClick(View v) {30         String url = "http://img.blog.csdn.net/20130702124537953?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdDEyeDM0NTY=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast";31         ImageCacheManager.loadImage(url, mImageView, getBitmapFromRes(R.drawable.ic_launcher), getBitmapFromRes(R.drawable.ic_launcher));32 33       }34     });35   }36 37   public Bitmap getBitmapFromRes(int resId) {38     Resources res = this.getResources();39     return BitmapFactory.decodeResource(res, resId);40 41   }42 43 }

 

到这里代码就结束了,由于主要是讲关于缓存层的运用,关于Volley,LruCache,DiskCache的介绍使用,这里就不再阐述了,网上资料很多,大家查阅下便是。

有任何疑问或者建议,大家可以在文章评论给我留言,一起交流!

 

作者:李晨玮
出处:http://www.cnblogs.com/lichenwei/
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文链接。
正在看本人博客的这位童鞋,我看你气度不凡,谈吐间隐隐有王者之气,日后必有一番作为!旁边有“推荐”二字,你就顺手把它点了吧,相得准,我分文不收;相不准,你也好回来找我!




湖北旅游线路报价湖北旅游攻略大全湖北旅游路线推荐湖北自驾游攻略湖北旅游线路大全4月去哪看薰衣草?德庆盘龙峡4月薰衣草好看吗? 2015德庆盘龙峡薰衣草花期多长?盘龙峡薰衣草能开到几月? 德庆盘龙峡薰衣草最佳观赏期?盘龙峡薰衣草什么时候最好看? 2015清明节广州去哪看薰衣草?广州2015清明节哪里有薰衣草? 2015春节澳门环岛游有哪些优惠活动?澳门环岛游风情表演好看吗? 茂名放鸡岛有哪些娱乐项目?放鸡岛海上游乐世界适合多大儿童玩? 2015春节澳门环岛游有什么活动?珠海澳门环岛游春节主题活动介绍? 除了内在美,这些精品酒店有着夺人眼球的外在美[二] 探秘哏儿都治愈系地界儿 哏儿都治愈系地界儿 周五来了周六还远吗 绚烂的红色日光在滨城大连赏最美日落 青岛:一场日出日落的旅行 香港有什么好玩的?香港旅游去哪里好? 香港的劳力士价格会比大陆便宜吗?在哪里买比较好? 去香港买手表哪里好?香港哪里购物好? 香港百老汇在哪里?香港百老汇地址在哪里? SQCAEA220GA1ME Datasheet SQCAEA220GA1ME Datasheet AQ12EA820JAJME Datasheet AQ12EA820JAJME Datasheet 08055U1R6BAT2A Datasheet 08055U1R6BAT2A Datasheet 杭州至香港旅游价格 杭州至香港旅游价格 杭州至香港旅游价格 佳木斯到香港旅游团价格 佳木斯到香港旅游团价格 佳木斯到香港旅游团价格 成都到香港旅游价格 成都到香港旅游价格 成都到香港旅游价格