android 用LruCache读取大图片并缓存（转）

图片预取缓存策略是内存缓存（硬引用LruCache、软引用SoftReference<Bitmap>）、外部文件缓存（context.getCachedDir（）），缓存中取不到的景象下再向办事端恳求下载图片。同时缓存三张图片（当前预览的这张，前一张以及后一张）。

1.内存缓存

 

•//须要导入外部jar文件 android-support-v4.jar 

•import android.support.v4.util.LruCache; 

•//开辟8M硬缓存空间 

•private final int hardCachedSize = 8*1024*1024; 

•//hard cache 

•private final LruCache<String， Bitmap> sHardBitmapCache = new LruCache<String， Bitmap>（hardCachedSize）{ 

•＠Override 

•public int sizeOf（String key， Bitmap value）{ 

•return value.getRowBytes（） * value.getHeight（）; 

•} 

•＠Override 

•protected void entryRemoved（boolean evicted， String key， Bitmap oldValue， Bitmap newValue）{ 

•Log.v（"tag"， "hard cache is full ， push to soft cache"）; 

•//硬引用缓存区满，将一个最不经常应用的oldvalue推入到软引用缓存区 

•sSoftBitmapCahe.put（key， new SoftReference<Bitmap>（oldValue））; 

•} 

•} 

•//软引用 

•private static final int SOFT_CACHE_CAPACITY = 40; 

•private final static LinkedHashMap<String， SoftReference<Bitmap>> sSoftBitmapCache = 

•new LinkedHashMao<String， SoftReference<Bitmap>>（SOFT_CACHE_CAPACITY， 0.75f， true）{ 

•＠Override 

•public SoftReference<Bitmap> put（String key， SoftReference<Bitmap> value）{ 

•return super.input（key， value）; 

•} 

•＠Override 

•protected boolean removeEldestEntry（LinkedHashMap.Entry<Stirng， SoftReference<Bitmap>> eldest）{ 

•if（size（） > SOFT_CACHE_CAPACITY）{ 

•Log.v（"tag"， "Soft Reference limit ， purge one"）; 

•return true; 

•} 

•return false; 

•} 

•} 

•//缓存bitmap 

•public boolean putBitmap（String key， Bitmap bitmap）{ 

•if（bitmap != null）{ 

•synchronized（sHardBitmapCache）{ 

•sHardBitmapCache.put（key， bitmap）; 

•} 

•return true; 

•} 

•return false; 

•} 

•//从缓存中获取bitmap 

•public Bitmap getBitmap（String key）{ 

•synchronized（sHardBitmapCache）{ 

•final Bitmap bitmap = sHardBitmapCache.get（key）; 

•if（bitmap != null） 

•return bitmap; 

•} 

•//硬引用缓存区间中读取失败，从软引用缓存区间读取 

•synchronized（sSoftBitmapCache）{ 

•SoftReference<Bitmap> bitmapReference = sSoftBtimapCache.get（key）; 

•if（bitmapReference != null）{ 

•final Bitmap bitmap2 = bitmapReference.get（）; 

•if（bitmap2 != null） 

•return bitmap2; 

•else{ 

•Log.v（"tag"， "soft reference 已经被收受接管"）; 

•sSoftBitmapCache.remove（key）; 

•} 

•} 

•} 

•return null; 

•} 

 

　　

2.外部文件缓存

•private File mCacheDir = context.getCacheDir（）; 

•private static final int MAX_CACHE_SIZE = 20 * 1024 * 1024; //20M 

•private final LruCache<String， Long> sFileCache = new LruCache<String， Long>（MAX_CACHE_SIZE）{ 

•＠Override 

•public int sizeOf（String key， Long value）{ 

•return value.intValue（）; 

•} 

•＠Override 

•protected void entryRemoved（boolean evicted， String key， Long oldValue， Long newValue）{ 

•File file = getFile（key）; 

•if（file != null） 

•file.（）; 

•} 

•} 

•private File getFile（String fileName） throws FileNotFoundException { 

•File file = new File（mCacheDir， fileName）; 

•if（!file.exists（） || !file.isFile（）） 

•throw new FileNotFoundException（"文件不存在或有同名文件夹"）; 

•return file; 

•} 

•//缓存bitmap到外部存储 

•public boolean putBitmap（String key， Bitmap bitmap）{ 

•File file = getFile（key）; 

•if（file != null）{ 

•Log.v（"tag"， "文件已经存在"）; 

•return true; 

•} 

•FileOutputStream fos = getOutputStream（key）; 

•boolean saved = bitmap.compress（CompressFormat.JPEG， 100， fos）; 

•fos.flush（）; 

•fos.close（）; 

•if（saved）{ 

•synchronized（sFileCache）{ 

•sFileCache.put（key， getFile（key）.length（））; 

•} 

•return true; 

•} 

•return false; 

•} 

•//按照key获取OutputStream 

•private FileOutputStream getOutputStream（String key）{ 

•if（mCacheDir == null） 

•return null; 

•FileOutputStream fos = new FileOutputStream（mCacheDir.getAbsolutePath（） + File.separator + key）; 

•return fos; 

•} 

•//获取bitmap 

•private static BitmapFactory.Options sBitmapOptions; 

•static { 

•sBitmapOptions = new BitmapFactory.Options（）; 

•sBitmapOptions.inPurgeable=true; //bitmap can be purged to disk 

•} 

•public Bitmap getBitmap（String key）{ 

•File bitmapFile = getFile（key）; 

•if（bitmapFile != null）{ 

•Bitmap bitmap = BitmapFactory.decodeStream（new FileInputStream（bitmapFile）， null， sBitmapOptions）; 

•if（bitmap != null）{ 

•//从头将其缓存至硬引用中 

•... 

•} 

•} 

•} 

 

3.从办事端下载图片 
下载成功后调用1内存缓存的putBitmap（）函数，缓存图片。 
在外部文件缓存中也写入一份，调用2的putBitmap（）函数. 
4.预览图片的流程 
1） 若是预览的图片在内存缓存区中，直接调用1的getBitmap（）函数，获取bitmap数据（先在硬引用缓存区查找匹配，若硬引用区匹配失败，再去软引用区匹配） 
2） 若是从内存缓存区读取失败，再从外部文件缓存中读取，调用2的getBitmap（）函数 
3） 若是从外部文件缓存中读取失败，则从办事端下载该图片，过程3. 
5.生成key值

private static String generateKey（String fileId， int width， int height） { 

String ret = fileId + "_" + Integer.toString（width） + "x" + Integer.toString（height）; 

return ret; 

} 

 

• 
  
• String key = generateKey（...）即可生成独一的key值