android 三级缓存

我们在移动开发时常常需要从网络请求图片，如果每次都去请求网络是很耗费流量。况且在网络不好的时候图片很可能加载不了，影响用户的体验。我们需要做图片缓存处理

不做图片缓存处理缺点:

每次去请求网络，耗费流量。

网络不好，图片不加有问题，影响用户的体验

还有可能发生oom

图片缓存的原理：

图片缓存的三级缓存，内存缓存、sdcard缓存、网络缓存。我们加载图片先查看内存中有没有该图片，有直接在内存中获取。如果没有在去sdcard中获取，sdcard中有加载图片，并保存一份缓存在内存中。罗sdcard中也没有就去网络获取，加载图片并分别保存一份缓存在内存和sdcard中。

网络缓存：

使用AsyncTask从网络获取图片

/**
 * 这是网络缓存，主要负责从网络上下载图片
 * Created by lenovo on 2016/1/11.
 */
public class NetCache {

    private SdCardCache sdCardCache;
    private MemoryCache memoryCache;

    public NetCache(MemoryCache memoryCache, SdCardCache sdCardCache) {
        this.memoryCache = memoryCache;
        this.sdCardCache = sdCardCache;
    }

    public void getImageFromNet(String url, ImageView image) {
        new BitmapAsyncTask().execute(url, image);
    }

    class BitmapAsyncTask extends AsyncTask<Object, Integer, Bitmap> {

        private String url;
        private ImageView image;

        @Override
        protected Bitmap doInBackground(Object... params) {
            url = ((String) params[0]);
            image = ((ImageView) params[1]);
            return downloadImage(url);
        }

        @Override
        protected void onPostExecute(Bitmap bitmap) {
            super.onPostExecute(bitmap);
            if(url!=null&&bitmap!=null) {
                image.setImageBitmap(bitmap);
                memoryCache.setImageToMemory(url, bitmap);
                sdCardCache.setImageToSDCard(url, bitmap);
            }
        }

        /**
         * 请求网络下载图片
         */
        private Bitmap downloadImage(String url) {
            InputStream in = null;
            try {
                URL bitmapURL = new URL(url);
                HttpURLConnection conn = ((HttpURLConnection) bitmapURL.openConnection());
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(3 * 1000);
                conn.setDoInput(true);
                if (conn.getResponseCode() == 200) {
                    in = conn.getInputStream();
                    return BitmapFactory.decodeStream(in);
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                if (in != null) {
                    try {
                        in.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
            return null;
        }

    }

}

sdcard缓存

缓存在sdcard中我们把图片压缩在sdcard中，获取sdcard中的图片使用BitmapFactory获取，我这里图片的名没有经过加密，一般使用可以经过加密

public class SdCardCache {
    private static  final String CACHE_PATH = Environment.getExternalStorageDirectory().getPath()+"/catch/";
    /**图片放入sdcard*/
    public void setImageToSDCard(String url,Bitmap bitmap)
    {
        File file=new File(CACHE_PATH,url.substring(url.lastIndexOf("/")+1));
        File parentFile = file.getParentFile();
        if(!parentFile.exists()){
            parentFile.mkdirs();
        }
        //图片压缩
        try {
            bitmap.compress(Bitmap.CompressFormat.JPEG,100,new FileOutputStream(file));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**从sdcard中获取Bitmap*/
    public Bitmap getImageFromSDCard(String url)
    {
        File file=new File(CACHE_PATH,url.substring(url.lastIndexOf("/")+1));
        if(file.exists())
        {
            try {
                Bitmap bitmap = BitmapFactory.decodeStream(new FileInputStream(file));
                return bitmap;
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }

        }
        return null;
    }

}

内存缓存：

内存缓存比较麻烦，java给我们提供了四种引用类型，强引用（StrongReference）,软引用（SoftReference），弱引用（WeakReference），虚引用（PhantomReference）

强引用（StrongReference）在java虚拟机内存不足时不会被回收，java虚拟机可能跑出oom（out of memory）

软引用（SoftReference）  如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存

弱引用（WeakReference）在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。
虚引用（PhantomReference）与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收
使用软引用可以做内存的缓存，但在android中，你使用发现他很快就会垃圾回收机制回收，在android中为我们提供你另一种缓存的处理LruCache

public class MemoryCache {
    /**数据写入内存，在android中使用软引用，资源很容易被回收被回收，使用前引用资源不会被虚拟机回收，我们这里使用（LRUCatch）Least recently used*/
    private LruCache<String,Bitmap> cache;

    public MemoryCache() {
        long maxMemory = Runtime.getRuntime().maxMemory();
        cache=new LruCache<String, Bitmap>((int) (maxMemory/8)){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }
        };
    }
    /**数据写入内存*/
    public void setImageToMemory(String url, Bitmap bitmap){
            cache.put(url, bitmap);
    }
    /**从内存中读取数据*/
    public Bitmap getImageFromMemory(String url)
    {
        return cache.get(url);
    }
}

逻辑处理这三个类的使用

public class DispalyImageUtil {

    private static final String TAG =DispalyImageUtil.class.getSimpleName() ;
    /**网络缓存*/
    private final NetCache netCache;
    /**内存缓存*/
    private final MemoryCache memoryCache;
    /**sdCard缓存*/
    private SdCardCache sdCardCache;

    public DispalyImageUtil() {
        memoryCache = new MemoryCache();
        this.sdCardCache = new SdCardCache();
        netCache = new NetCache(memoryCache, sdCardCache);
    }

    /**先去读取内存中的数据，如果内存中不存在该图片，再去sdcard中读取图片，如果sdcard中有，就在内存中写入该图片，并显示
     * 在sdcard中读取的图片。如果sdcard中也不存在该图片，啦就去网络去读取图片，并把图片缓存在内存和sdcard中*/
    public  void display(String url, ImageView imageView){
        //内存获取数据
        Bitmap memoryBitmap = memoryCache.getImageFromMemory(url);
        if(memoryBitmap!=null)
        {
            imageView.setImageBitmap(memoryBitmap);
            Log.i(TAG,"从内存中读取图片");
            return;
        }
        //sdcard获取数据
        Bitmap SdcardBitmap = sdCardCache.getImageFromSDCard(url);

        if(SdcardBitmap!=null){
            imageView.setImageBitmap(SdcardBitmap);
            memoryCache.setImageToMemory(url,SdcardBitmap);//内存中没有该数据，写入该数据
            Log.i(TAG,"从sdcard中获取图片");
            return;
        }
        //网络获取数据
        netCache.getImageFromNet(url,imageView);
        Log.i(TAG,"从网络获取图片");
    }
}