关闭

android中图片的三级缓存cache策略(内存/文件/网络)

标签: android图片网络内存缓存
231人阅读 评论(0) 收藏 举报
分类:

1.简介

  现在android应用中不可避免的要使用图片,有些图片是可以变化的,需要每次启动时从网络拉取,这种场景在有广告位的应用以及纯图片应用(比如百度美拍)中比较多。

  现在有一个问题:假如每次启动的时候都从网络拉取图片的话,势必会消耗很多流量。在当前的状况下,对于非wifi用户来说,流量还是很贵的,一个很耗流量的应用,其用户数量级肯定要受到影响。当然,我想,向百度美拍这样的应用,必然也有其内部的图片缓存策略。总之,图片缓存是很重要而且是必须的。
  

2.图片缓存的原理

  实现图片缓存也不难,需要有相应的cache策略。这里我采用 内存-文件-网络 三层cache机制,其中内存缓存包括强引用缓存和软引用缓存(SoftReference),其实网络不算cache,这里姑且也把它划到缓存的层次结构中。当根据url向网络拉取图片的时候,先从内存中找,如果内存中没有,再从缓存文件中查找,如果缓存文件中也没有,再从网络上通过http请求拉取图片。在键值对(key-value)中,这个图片缓存的key是图片url的hash值,value就是bitmap。所以,按照这个逻辑,只要一个url被下载过,其图片就被缓存起来了。

  关于Java中对象的软引用(SoftReference),如果一个对象具有软引用,内存空间足够,垃 圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。软引用可用来实现内存敏感的高 速缓存。使用软引用能防止内存泄露,增强程序的健壮性。

  从代码上来说,采用一个ImageManager来负责图片的管理和缓存,函数接口为public void loadBitmap(String url, Handler handler) ;其中url为要下载的图片地址,handler为图片下载成功后的回调,在handler中处理message,而message中包含了图片的信息以及bitmap对象。ImageManager中使用的ImageMemoryCache(内存缓存)、ImageFileCache(文件缓存)以及LruCache(最近最久未使用缓存)会在后续文章中介绍。

3.代码ImageManager.java

/* 
* 图片管理 
* 异步获取图片,直接调用loadImage()函数,该函数自己判断是从缓存还是网络加载 
* 同步获取图片,直接调用getBitmap()函数,该函数自己判断是从缓存还是网络加载 
* 仅从本地获取图片,调用getBitmapFromNative() 
* 仅从网络加载图片,调用getBitmapFromHttp() 
*/ 
public class ImageManager implements IManager { 
    private final static String TAG = "ImageManager"; 
    private ImageMemoryCache imageMemoryCache; //内存缓存 
private ImageFileCache imageFileCache; //文件缓存 

//正在下载的image列表 
    public static HashMap<String, Handler> ongoingTaskMap = new HashMap<String, Handler>(); 

    //等待下载的image列表 
    public static HashMap<String, Handler> waitingTaskMap = new HashMap<String, Handler>(); 

    //同时下载图片的线程个数 
    final static int MAX_DOWNLOAD_IMAGE_THREAD = 4; 

    private final Handler downloadStatusHandler = new Handler(){ 
        public void handleMessage(Message msg) { 
            startDownloadNext(); 
        } 
    }; 

    public ImageManager() { 
        imageMemoryCache = new ImageMemoryCache(); 
        imageFileCache = new ImageFileCache(); 
    } 

    /** 
    * 获取图片,多线程的入口 
    */ 
    public void loadBitmap(String url, Handler handler) { 
        //先从内存缓存中获取,取到直接加载 
        Bitmap bitmap = getBitmapFromNative(url); 
        if (bitmap != null) 
        { 
            Logger.d(TAG, "loadBitmap:loaded from native"); 
            Message msg = Message.obtain(); 
            Bundle bundle = new Bundle(); 
            bundle.putString("url", url); 
            msg.obj = bitmap; 
            msg.setData(bundle); 
            handler.sendMessage(msg); 
        } else { 
            Logger.d(TAG, "loadBitmap:will load by network"); 
            downloadBmpOnNewThread(url, handler); 
        } 
    } 
    /** 
    * 新起线程下载图片 
    */ 
    private void downloadBmpOnNewThread(final String url, final Handler handler) { 
        Logger.d(TAG, "ongoingTaskMap'size=" + ongoingTaskMap.size()); 

        if (ongoingTaskMap.size() >= MAX_DOWNLOAD_IMAGE_THREAD){ 
            synchronized (waitingTaskMap) { 
                waitingTaskMap.put(url, handler); 
            } 
        } else { 
            synchronized (ongoingTaskMap) { 
                ongoingTaskMap.put(url, handler); 
            } 
            new Thread() { 
                public void run(){ 
                    Bitmap bmp = getBitmapFromHttp(url); 
                    // 不论下载是否成功,都从下载队列中移除,再由业务逻辑判断是否重新下载 
                    // 下载图片使用了httpClientRequest,本身已经带了重连机制 
                    synchronized (ongoingTaskMap) { 
                        ongoingTaskMap.remove(url); 
                    } 

                    if(downloadStatusHandler != null) { 
                        downloadStatusHandler.sendEmptyMessage(0); 
                    } 
                    Message msg = Message.obtain(); 
                    msg.obj = bmp; 
                    Bundle bundle = new Bundle(); 
                    bundle.putString("url", url); 
                    msg.setData(bundle); 

                    if(handler != null){ 
                        handler.sendMessage(msg); 
                    } 
                } 
            }.start(); 
        } 
    } 
    /** 
    * 依次从内存,缓存文件,网络上加载单个bitmap,不考虑线程的问题 
    */ 
    public Bitmap getBitmap(String url) { 
        // 从内存缓存中获取图片 
        Bitmap bitmap = imageMemoryCache.getBitmapFromMemory(url); 
        if (bitmap == null) { 
            // 文件缓存中获取 
            bitmap = imageFileCache.getImageFromFile(url); 
            if (bitmap != null) { 
                // 添加到内存缓存 
                imageMemoryCache.addBitmapToMemory(url, bitmap); 
            } else { 
                // 从网络获取 
                bitmap = getBitmapFromHttp(url); 
            } 
        } 
        return bitmap; 
    } 

    /** 
    * 从内存或者缓存文件中获取bitmap 
    */ 
    public Bitmap getBitmapFromNative(String url) { 
        Bitmap bitmap = null; 
        bitmap = imageMemoryCache.getBitmapFromMemory(url); 

        if(bitmap == null) { 
            bitmap = imageFileCache.getImageFromFile(url); 
            if(bitmap != null) { 
                // 添加到内存缓存 
                imageMemoryCache.addBitmapToMemory(url, bitmap); 
            } 
        } 
        return bitmap; 
    } 

    /** 
    * 通过网络下载图片,与线程无关 
    */ 
    public Bitmap getBitmapFromHttp(String url) { 
        Bitmap bmp = null; 

        try { 
            byte[] tmpPicByte = getImageBytes(url); 

            if (tmpPicByte != null) { 
                bmp = BitmapFactory.decodeByteArray(tmpPicByte, 0, 
                tmpPicByte.length); 
            } 
            tmpPicByte = null; 
        } catch(Exception e) { 
            e.printStackTrace(); 
        } 

        if(bmp != null) { 
            // 添加到文件缓存 
            imageFileCache.saveBitmapToFile(bmp, url); 
            // 添加到内存缓存 
            imageMemoryCache.addBitmapToMemory(url, bmp); 
        } 
        return bmp; 
    } 

    /** 
    * 下载链接的图片资源 
    * @param url 
    * @return 图片 
    */ 
    public byte[] getImageBytes(String url) { 
        byte[] pic = null; 
        if (url != null && !"".equals(url)) { 
            Requester request = RequesterFactory.getRequester(Requester.REQUEST_REMOTE, RequesterFactory.IMPL_HC); 
            // 执行请求 
            MyResponse myResponse = null; 
            MyRequest mMyRequest; 
            mMyRequest = new MyRequest(); 
            mMyRequest.setUrl(url); 
            mMyRequest.addHeader(HttpHeader.REQ.ACCEPT_ENCODING, "identity"); 
            InputStream is = null; 
            ByteArrayOutputStream baos = null; 
            try { 
                myResponse = request.execute(mMyRequest); 
                is = myResponse.getInputStream().getImpl(); 
                baos = new ByteArrayOutputStream(); 
                byte[] b = new byte[512]; 
                int len = 0; 
                while ((len = is.read(b)) != -1) { 
                    baos.write(b, 0, len); 
                    baos.flush(); 
                } 
                pic = baos.toByteArray(); 
                Logger.d(TAG, "icon bytes.length=" + pic.length); 
            } catch (Exception e3) { 
                e3.printStackTrace(); 
                try{ 
                    Logger.e(TAG, 
                    "download shortcut icon faild and responsecode=" + myResponse.getStatusCode()); 
                } catch (Exception e4) { 
                    e4.printStackTrace(); 
                } 
            } finally { 
                try { 
                    if (is != null) { 
                        is.close(); 
                        is = null; 
                    } 
                } catch (Exception e2) { 
                    e2.printStackTrace(); 
                } 
                try { 
                    if (baos != null) { 
                        baos.close(); 
                        baos = null; 
                    } 
                } catch (Exception e2) { 
                    e2.printStackTrace(); 
                } 
                try { 
                    request.close(); 
                } catch (Exception e1) { 
                    e1.printStackTrace(); 
                } 
            } 
        } 
        return pic; 
    } 

    /** 
    * 取出等待队列第一个任务,开始下载 
    */ 
    private void startDownloadNext() { 
        synchronized(waitingTaskMap) { 
            Logger.d(TAG, "begin start next"); 
            Iterator iter = waitingTaskMap.entrySet().iterator(); 

            while (iter.hasNext()) { 
                Map.Entry entry = (Map.Entry) iter.next(); 
                Logger.d(TAG, "WaitingTaskMap isn't null,url=" + (String)entry.getKey()); 

                if(entry != null) { 
                    waitingTaskMap.remove(entry.getKey()); 
                    downloadBmpOnNewThread((String)entry.getKey(), (Handler)entry.getValue()); 
                } 
                break; 
            } 
        } 
    } 

    public String startDownloadNext_ForUnitTest() { 
        String urlString = null; 
        synchronized(waitingTaskMap) { 
            Logger.d(TAG, "begin start next"); 
            Iterator iter = waitingTaskMap.entrySet().iterator(); 

            while (iter.hasNext()) { 
                Map.Entry entry = (Map.Entry) iter.next(); 
                urlString = (String)entry.getKey(); 
                waitingTaskMap.remove(entry.getKey()); 
                break; 
            } 
        } 
        return urlString; 
    } 

    /** 
    * 图片变为圆角 
    * @param bitmap:传入的bitmap 
    * @param pixels:圆角的度数,值越大,圆角越大 
    * @return bitmap:加入圆角的bitmap 
    */ 
    public static Bitmap toRoundCorner(Bitmap bitmap, int pixels) { 
        if(bitmap == null) 
            return null; 
        Bitmap output = Bitmap.createBitmap(bitmap.getWidth(), bitmap.getHeight(), Config.ARGB_8888); 
        Canvas canvas = new Canvas(output); 
        final int color = 0xff424242; 
        final Paint paint = new Paint(); 
        final Rect rect = new Rect(0, 0, bitmap.getWidth(), bitmap.getHeight()); 
        final RectF rectF = new RectF(rect); 
        final float roundPx = pixels; 
        paint.setAntiAlias(true); 
        canvas.drawARGB(0, 0, 0, 0); 
        paint.setColor(color); 
        canvas.drawRoundRect(rectF, roundPx, roundPx, paint); 
        paint.setXfermode(new PorterDuffXfermode(Mode.SRC_IN)); 
        canvas.drawBitmap(bitmap, rect, rect, paint); 
        return output; 
} 

    public byte managerId() { 
        return IMAGE_ID; 
    } 
} 

原文链接:http://www.jb51.net/article/38162.htm

1
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:6111次
    • 积分:114
    • 等级:
    • 排名:千里之外
    • 原创:4篇
    • 转载:7篇
    • 译文:0篇
    • 评论:1条
    文章分类
    文章存档
    最新评论