Android 缓存机制

相册图片预取缓存策略是内存缓存（硬引用LruCache、软引用SoftReference<Bitmap>）、外部文件缓存（context.getCachedDir()），缓存中取不到的情况下再向服务端请求下载图片。同时缓存三张图片（当前预览的这张，前一张以及后一张）。
1.内存缓存

[html] view plaincopy
//需要导入外部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.外部文件缓存
[html] view plaincopy
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.delete(); 
        } 
    } 
    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值
[html] view plaincopy
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值

地址： http://download.csdn.net/category