Android 图片缓存处理

转载 2015年07月07日 15:03:19
异步下载 / 本地缓存
异步下载
  1. 大家都知道,在android应用中UI线程5秒没响应的话就会抛出无响应异常,对于远程获取大的资源来说,这种异常还是很容易就会抛出来的,那么怎么避免这种问题的产生。在android中提供两种方法来做这件事情:

    1. 启动一个新的线程来获取资源,完成后通过Handler机制发送消息,并在UI线程中处理消息,从而达到在异步线程中获取图片,然后通过Handler Message来更新UI线程的过程。
    2. 使用android中提供的AsyncTask来完成。

     

    具体的做法这里就不介绍了,查下API就可以了,或者是google、baidu下。这里主要来说本地缓存。

    本地缓存

    对于图片资源来说,你不可能让应用每次获取的时候都重新到远程去下载(ListView),这样会浪费资源,但是你又不能让所有图片资源都放到内存中去(虽然这样加载会比较快),因为图片资源往往会占用很大的内存空间,容易导致OOM。那么如果下载下来的图片保存到SDCard中,下次直接从SDCard上去获取呢?这也是一种做法,我看了下,还是有不少应用采用这种方式的。采用LRU等一些算法可以保证sdcard被占用的空间只有一小部分,这样既保证了图片的加载、节省了流量、又使SDCard的空间只占用了一小部分。另外一种做法是资源直接保存在内存中,然后设置过期时间和LRU规则。

    sdcard保存:


    1. 在sdcard上开辟一定的空间,需要先判断sdcard上剩余空间是否足够,如果足够的话就可以开辟一些空间,比如10M
    2. 当需要获取图片时,就先从sdcard上的目录中去找,如果找到的话,使用该图片,并更新图片最后被使用的时间。如果找不到,通过URL去download
    3. 去服务器端下载图片,如果下载成功了,放入到sdcard上,并使用,如果失败了,应该有重试机制。比如3次。
    4. 下载成功后保存到sdcard上,需要先判断10M空间是否已经用完,如果没有用完就保存,如果空间不足就根据LRU规则删除一些最近没有被用户的资源。

    关键代码:

    • 保存图片到SD卡上

    [java] view plaincopy
    1. private void saveBmpToSd(Bitmap bm, Stringurl) {  
    2.         if (bm == null) {  
    3.             Log.w(TAG, " trying to savenull bitmap");  
    4.             return;  
    5.         }  
    6.          //判断sdcard上的空间  
    7.         if (FREE_SD_SPACE_NEEDED_TO_CACHE >freeSpaceOnSd()) {  
    8.             Log.w(TAG, "Low free space onsd, do not cache");  
    9.             return;  
    10.         }  
    11.         String filename =convertUrlToFileName(url);  
    12.         String dir = getDirectory(filename);  
    13.         File file = new File(dir +"/" + filename);  
    14.         try {  
    15.             file.createNewFile();  
    16.             OutputStream outStream = newFileOutputStream(file);  
    17.            bm.compress(Bitmap.CompressFormat.JPEG, 100, outStream);  
    18.             outStream.flush();  
    19.             outStream.close();  
    20.             Log.i(TAG, "Image saved tosd");  
    21.         } catch (FileNotFoundException e) {  
    22.             Log.w(TAG,"FileNotFoundException");  
    23.         } catch (IOException e) {  
    24.             Log.w(TAG,"IOException");  
    25.         }  
    26.     }  

    • 计算sdcard上的空间:

    [java] view plaincopy
    1. /** 
    2.  * 计算sdcard上的剩余空间 
    3.  * @return 
    4.  */  
    5. private int freeSpaceOnSd() {  
    6.     StatFs stat = newStatFs(Environment.getExternalStorageDirectory() .getPath());  
    7.     double sdFreeMB = ((double)stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB;  
    8.     return (int) sdFreeMB;  
    9. }  

    • 修改文件的最后修改时间
    [java] view plaincopy
    1. /** 
    2.  * 修改文件的最后修改时间 
    3.  * @param dir 
    4.  * @param fileName 
    5.  */  
    6. private void updateFileTime(String dir,String fileName) {  
    7.     File file = new File(dir,fileName);         
    8.     long newModifiedTime =System.currentTimeMillis();  
    9.     file.setLastModified(newModifiedTime);  
    10. }  
    • 本地缓存优化
    [java] view plaincopy
    1.  /** 
    2.  *计算存储目录下的文件大小,当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定 
    3.  * 那么删除40%最近没有被使用的文件 
    4.  * @param dirPath 
    5.  * @param filename 
    6.  */  
    7. private void removeCache(String dirPath) {  
    8.     File dir = new File(dirPath);  
    9.     File[] files = dir.listFiles();  
    10.     if (files == null) {  
    11.         return;  
    12.     }  
    13.     int dirSize = 0;  
    14.     for (int i = 0; i < files.length;i++) {  
    15.         if(files[i].getName().contains(WHOLESALE_CONV)) {  
    16.             dirSize += files[i].length();  
    17.         }  
    18.     }  
    19.     if (dirSize > CACHE_SIZE * MB ||FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) {  
    20.         int removeFactor = (int) ((0.4 *files.length) + 1);  
    21.   
    22.         Arrays.sort(files, newFileLastModifSort());  
    23.   
    24.         Log.i(TAG, "Clear some expiredcache files ");  
    25.   
    26.         for (int i = 0; i <removeFactor; i++) {  
    27.   
    28.             if(files[i].getName().contains(WHOLESALE_CONV)) {  
    29.   
    30.                 files[i].delete();               
    31.   
    32.             }  
    33.   
    34.         }  
    35.   
    36.     }  
    37.   
    38. }  
    39. /** 
    40.  * 删除过期文件 
    41.  * @param dirPath 
    42.  * @param filename 
    43.  */  
    44. private void removeExpiredCache(StringdirPath, String filename) {  
    45.   
    46.     File file = new File(dirPath,filename);  
    47.   
    48.     if (System.currentTimeMillis() -file.lastModified() > mTimeDiff) {  
    49.   
    50.         Log.i(TAG, "Clear some expiredcache files ");  
    51.   
    52.         file.delete();  
    53.   
    54.     }  
    55.   
    56. }  
    • 文件使用时间排序
    [java] view plaincopy
    1. /** 
    2.  * TODO 根据文件的最后修改时间进行排序 * 
    3.  */  
    4. classFileLastModifSort implements Comparator<File>{  
    5.     public int compare(File arg0, File arg1) {  
    6.         if (arg0.lastModified() >arg1.lastModified()) {  
    7.             return 1;  
    8.         } else if (arg0.lastModified() ==arg1.lastModified()) {  
    9.             return 0;  
    10.         } else {  
    11.             return -1;  
    12.         }  
    13.     }  
    14. }  

    内存保存:

    在内存中保存的话,只能保存一定的量,而不能一直往里面放,需要设置数据的过期时间、LRU等算法。这里有一个方法是把常用的数据放到一个缓存中(A),不常用的放到另外一个缓存中(B)。当要获取数据时先从A中去获取,如果A中不存在那么再去B中获取。B中的数据主要是A中LRU出来的数据,这里的内存回收主要针对B内存,从而保持A中的数据可以有效的被命中。


    1. 先定义A缓存:

    [java] view plaincopy
    1. private final HashMap<String, Bitmap>mHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY/ 20.75f, true) {  
    2.         @Override  
    3.         protected booleanremoveEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {  
    4.             if (size() >HARD_CACHE_CAPACITY) {  
    5.                //当map的size大于30时,把最近不常用的key放到mSoftBitmapCache中,从而保证mHardBitmapCache的效率  
    6.                mSoftBitmapCache.put(eldest.getKey(), newSoftReference<Bitmap>(eldest.getValue()));  
    7.                 return true;  
    8.             } else  
    9.                 return false;  
    10.         }  
    11.     };  

    1. 再定于B缓存:

    [java] view plaincopy
    1. /** 
    2.   *当mHardBitmapCache的key大于30的时候,会根据LRU算法把最近没有被使用的key放入到这个缓存中。 
    3.   *Bitmap使用了SoftReference,当内存空间不足时,此cache中的bitmap会被垃圾回收掉 
    4.   */  
    5.  private final staticConcurrentHashMap<String, SoftReference<Bitmap>> mSoftBitmapCache =new ConcurrentHashMap<String,SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2);  

    1. 从缓存中获取数据:

    [java] view plaincopy
    1. /** 
    2.      * 从缓存中获取图片 
    3.      */  
    4.     private Bitmap getBitmapFromCache(Stringurl) {  
    5.         // 先从mHardBitmapCache缓存中获取  
    6.         synchronized (mHardBitmapCache) {  
    7.             final Bitmap bitmap =mHardBitmapCache.get(url);  
    8.             if (bitmap != null) {  
    9.                 //如果找到的话,把元素移到linkedhashmap的最前面,从而保证在LRU算法中是最后被删除  
    10.                 mHardBitmapCache.remove(url);  
    11.                 mHardBitmapCache.put(url,bitmap);  
    12.                 return bitmap;  
    13.             }  
    14.         }  
    15.         //如果mHardBitmapCache中找不到,到mSoftBitmapCache中找  
    16.         SoftReference<Bitmap>bitmapReference = mSoftBitmapCache.get(url);  
    17.         if (bitmapReference != null) {  
    18.             final Bitmap bitmap =bitmapReference.get();  
    19.             if (bitmap != null) {  
    20.                 return bitmap;  
    21.             } else {  
    22.                 mSoftBitmapCache.remove(url);  
    23.             }  
    24.         }  
    25.         return null;  
    26.     }  

    1. 如果缓存中不存在,那么就只能去服务器端去下载:

    [java] view plaincopy
    1. /** 
    2.   * 异步下载图片 
    3.   */  
    4.  class ImageDownloaderTask extendsAsyncTask<String, Void, Bitmap> {  
    5.      private static final int IO_BUFFER_SIZE= 4 * 1024;  
    6.      private String url;  
    7.      private finalWeakReference<ImageView> imageViewReference;  
    8.      public ImageDownloaderTask(ImageViewimageView) {  
    9.          imageViewReference = newWeakReference<ImageView>(imageView);  
    10.      }  
    11.   
    12.     @Override  
    13.      protected BitmapdoInBackground(String... params) {  
    14.          final AndroidHttpClient client =AndroidHttpClient.newInstance("Android");  
    15.          url = params[0];  
    16.          final HttpGet getRequest = newHttpGet(url);  
    17.          try {  
    18.              HttpResponse response =client.execute(getRequest);  
    19.              final int statusCode =response.getStatusLine().getStatusCode();  
    20.              if (statusCode !=HttpStatus.SC_OK) {  
    21.                  Log.w(TAG, "从" +url + "中下载图片时出错!,错误码:" + statusCode);  
    22.                  return null;  
    23.              }  
    24.              final HttpEntity entity =response.getEntity();  
    25.              if (entity != null) {  
    26.                  InputStream inputStream =null;  
    27.                  OutputStream outputStream =null;  
    28.                  try {  
    29.                      inputStream =entity.getContent();  
    30.                      finalByteArrayOutputStream dataStream = new ByteArrayOutputStream();  
    31.                      outputStream = newBufferedOutputStream(dataStream, IO_BUFFER_SIZE);  
    32.                      copy(inputStream,outputStream);  
    33.                      outputStream.flush();  
    34.                      final byte[] data =dataStream.toByteArray();  
    35.                      final Bitmap bitmap =BitmapFactory.decodeByteArray(data, 0, data.length);  
    36.                      return bitmap;  
    37.                  } finally {  
    38.                      if (inputStream !=null) {  
    39.                         inputStream.close();  
    40.                      }  
    41.                      if (outputStream !=null) {  
    42.                         outputStream.close();  
    43.                      }  
    44.                     entity.consumeContent();  
    45.                  }  
    46.              }  
    47.          } catch (IOException e) {  
    48.              getRequest.abort();  
    49.              Log.w(TAG, "I/O errorwhile retrieving bitmap from " + url, e);  
    50.          } catch (IllegalStateException e) {  
    51.              getRequest.abort();  
    52.              Log.w(TAG, "Incorrect URL:" + url);  
    53.          } catch (Exception e) {  
    54.              getRequest.abort();  
    55.              Log.w(TAG, "Error whileretrieving bitmap from " + url, e);  
    56.          } finally {  
    57.              if (client != null) {  
    58.                  client.close();  
    59.              }  
    60.          }  
    61.          return null;  
    62.      }  

    这是两种做法,还有一些应用在下载的时候使用了线程池和消息队列MQ,对于图片下载的效率要更好一些。有兴趣的同学可以看下。

    总结

    1. 对于远程图片等相对比较大的资源一定要在异步线程中去获取或本地做缓存

相关文章推荐

Android Bitmap图像处理(2)- 图片缓存

上一节我们知道,Bitmap在Android开发中是比较占用内存和耗费资源的。我们不可能每次都从网络去下载图片,每次都从SD卡或者res去读取bitmap,因为这些操作很耗时间和资源的。这个时候,我们...
  • jimdaxu
  • jimdaxu
  • 2015年11月01日 13:39
  • 196

Android 图片缓存处理

异步下载 / 本地缓存 异步下载 大家都知道,在android应用中UI线程5秒没响应的话就会抛出无响应异常,对于远程获取大的资源来说,这种异常还是很容易就会抛出来的,那么怎么避免这种...

Android 图片缓存处理

异步下载本地缓存 异步下载 大家都知道,在android应用中UI线程5秒没响应的话就会抛出无响应异常,对于远程获取大的资源来说,这种异常还是很容易就会抛出来的,那么怎么避免这种问题的产生。在a...

基于Android的图片缓存处理

从互联网下载展示的图片耗时耗流量,切换页面、重新进入应用等操作又会造成图片的重复下载,为达到一次一次下载多次利用节时节量的效果,特进行图片的缓存处理。 一、获取图片     1、第一层:设...

Android加载网络图片缓存处理库的使用-Universal-ImageLoader

Android加载网络图片缓存处理库的使用-Universal-ImageLoader
  • d199138
  • d199138
  • 2016年08月06日 10:16
  • 89

Android图片缓存

  • 2014年12月13日 22:43
  • 2.08MB
  • 下载

Android图片缓存、加载

  • 2015年05月18日 11:30
  • 1.37MB
  • 下载

Android-Volley网络通信框架(二次封装数据请求和图片请求(包括处理请求队列和图片缓存))

1.回顾       上篇 使用 Volley 的 JsonObjectRequest 和 ImageLoader 写了 电影列表的例子 2.重点      (1)封装Volley 内部 请求 类  ...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Android 图片缓存处理
举报原因:
原因补充:

(最多只允许输入30个字)