Android 之 远程图片获取和本地缓存

/article/7616251.html

概述

对于客户端——服务器端应用，从远程获取图片算是经常要用的一个功能，而图片资源往往会消耗比较大的流量，对应用来说，如果处理不好这个问题，那会让用户很崩溃，不知不觉手机流量就用完了，等用户发现是你的应用消耗掉了他手机流量的话，那么可想而知你的应用将面临什么样的命运。

另外一个问题就是加载速度，如果应用中图片加载速度很慢的话，那么用户同样会等到崩溃。

那么如何处理好图片资源的获取和管理呢？

异步下载
本地缓存

异步下载

大家都知道，在android应用中UI线程5秒没响应的话就会抛出无响应异常，对于远程获取大的资源来说，这种异常还是很容易就会抛出来的，那么怎么避免这种问题的产生。在android中提供两种方法来做这件事情：

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



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

本地缓存

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

sdcard保存：



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

关键代码：

保存图片到SD卡上

[java] view
plaincopy

private void saveBmpToSd(Bitmap bm, Stringurl) {

if (bm == null) {

Log.w(TAG, " trying to savenull bitmap");

return;

}

//判断sdcard上的空间

if (FREE_SD_SPACE_NEEDED_TO_CACHE >freeSpaceOnSd()) {

Log.w(TAG, "Low free space onsd, do not cache");

return;

}

String filename =convertUrlToFileName(url);

String dir = getDirectory(filename);

File file = new File(dir +"/" + filename);

try {

file.createNewFile();

OutputStream outStream = newFileOutputStream(file);

bm.compress(Bitmap.CompressFormat.JPEG, 100, outStream);

outStream.flush();

outStream.close();

Log.i(TAG, "Image saved tosd");

} catch (FileNotFoundException e) {

Log.w(TAG,"FileNotFoundException");

} catch (IOException e) {

Log.w(TAG,"IOException");

}

}

计算sdcard上的空间：

[java] view
plaincopy

/**

* 计算sdcard上的剩余空间

* @return

*/

private int freeSpaceOnSd() {

StatFs stat = newStatFs(Environment.getExternalStorageDirectory() .getPath());

double sdFreeMB = ((double)stat.getAvailableBlocks() * (double) stat.getBlockSize()) / MB;

return (int) sdFreeMB;

}

修改文件的最后修改时间

[java] view
plaincopy

/**

* 修改文件的最后修改时间

* @param dir

* @param fileName

*/

private void updateFileTime(String dir,String fileName) {

File file = new File(dir,fileName);

long newModifiedTime =System.currentTimeMillis();

file.setLastModified(newModifiedTime);

}

本地缓存优化

[java] view
plaincopy

/**

*计算存储目录下的文件大小，当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定

* 那么删除40%最近没有被使用的文件

* @param dirPath

* @param filename

*/

private void removeCache(String dirPath) {

File dir = new File(dirPath);

File[] files = dir.listFiles();

if (files == null) {

return;

}

int dirSize = 0;

for (int i = 0; i < files.length;i++) {

if(files[i].getName().contains(WHOLESALE_CONV)) {

dirSize += files[i].length();

}

}

if (dirSize > CACHE_SIZE * MB ||FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) {

int removeFactor = (int) ((0.4 *files.length) + 1);

Arrays.sort(files, newFileLastModifSort());

Log.i(TAG, "Clear some expiredcache files ");

for (int i = 0; i <removeFactor; i++) {

if(files[i].getName().contains(WHOLESALE_CONV)) {

files[i].delete();

}

}

}

}

/**

* 删除过期文件

* @param dirPath

* @param filename

*/

private void removeExpiredCache(StringdirPath, String filename) {

File file = new File(dirPath,filename);

if (System.currentTimeMillis() -file.lastModified() > mTimeDiff) {

Log.i(TAG, "Clear some expiredcache files ");

file.delete();

}

}

文件使用时间排序

[java] view
plaincopy

/**

* TODO 根据文件的最后修改时间进行排序 *

*/

classFileLastModifSort implements Comparator<File>{

public int compare(File arg0, File arg1) {

if (arg0.lastModified() >arg1.lastModified()) {

return 1;

} else if (arg0.lastModified() ==arg1.lastModified()) {

return 0;

} else {

return -1;

}

}

}

内存保存：

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



先定义A缓存：

[java] view
plaincopy

private final HashMap<String, Bitmap>mHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY/ 2, 0.75f, true) {

@Override

protected booleanremoveEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {

if (size() >HARD_CACHE_CAPACITY) {

//当map的size大于30时，把最近不常用的key放到mSoftBitmapCache中，从而保证mHardBitmapCache的效率

mSoftBitmapCache.put(eldest.getKey(), newSoftReference<Bitmap>(eldest.getValue()));

return true;

} else

return false;

}

};

再定于B缓存：

[java] view
plaincopy

/**

*当mHardBitmapCache的key大于30的时候，会根据LRU算法把最近没有被使用的key放入到这个缓存中。

*Bitmap使用了SoftReference，当内存空间不足时，此cache中的bitmap会被垃圾回收掉

*/

private final staticConcurrentHashMap<String, SoftReference<Bitmap>> mSoftBitmapCache =new ConcurrentHashMap<String,SoftReference<Bitmap>>(HARD_CACHE_CAPACITY / 2);

从缓存中获取数据：

[java] view
plaincopy

/**

* 从缓存中获取图片

*/

private Bitmap getBitmapFromCache(Stringurl) {

// 先从mHardBitmapCache缓存中获取

synchronized (mHardBitmapCache) {

final Bitmap bitmap =mHardBitmapCache.get(url);

if (bitmap != null) {

//如果找到的话，把元素移到linkedhashmap的最前面，从而保证在LRU算法中是最后被删除

mHardBitmapCache.remove(url);

mHardBitmapCache.put(url,bitmap);

return bitmap;

}

}

//如果mHardBitmapCache中找不到，到mSoftBitmapCache中找

SoftReference<Bitmap>bitmapReference = mSoftBitmapCache.get(url);

if (bitmapReference != null) {

final Bitmap bitmap =bitmapReference.get();

if (bitmap != null) {

return bitmap;

} else {

mSoftBitmapCache.remove(url);

}

}

return null;

}

如果缓存中不存在，那么就只能去服务器端去下载：

[java] view
plaincopy

/**

* 异步下载图片

*/

class ImageDownloaderTask extendsAsyncTask<String, Void, Bitmap> {

private static final int IO_BUFFER_SIZE= 4 * 1024;

private String url;

private finalWeakReference<ImageView> imageViewReference;

public ImageDownloaderTask(ImageViewimageView) {

imageViewReference = newWeakReference<ImageView>(imageView);

}

@Override

protected BitmapdoInBackground(String... params) {

final AndroidHttpClient client =AndroidHttpClient.newInstance("Android");

url = params[0];

final HttpGet getRequest = newHttpGet(url);

try {

HttpResponse response =client.execute(getRequest);

final int statusCode =response.getStatusLine().getStatusCode();

if (statusCode !=HttpStatus.SC_OK) {

Log.w(TAG, "从" +url + "中下载图片时出错!,错误码:" + statusCode);

return null;

}

final HttpEntity entity =response.getEntity();

if (entity != null) {

InputStream inputStream =null;

OutputStream outputStream =null;

try {

inputStream =entity.getContent();

finalByteArrayOutputStream dataStream = new ByteArrayOutputStream();

outputStream = newBufferedOutputStream(dataStream, IO_BUFFER_SIZE);

copy(inputStream,outputStream);

outputStream.flush();

final byte[] data =dataStream.toByteArray();

final Bitmap bitmap =BitmapFactory.decodeByteArray(data, 0, data.length);

return bitmap;

} finally {

if (inputStream !=null) {

inputStream.close();

}

if (outputStream !=null) {

outputStream.close();

}

entity.consumeContent();

}

}

} catch (IOException e) {

getRequest.abort();

Log.w(TAG, "I/O errorwhile retrieving bitmap from " + url, e);

} catch (IllegalStateException e) {

getRequest.abort();

Log.w(TAG, "Incorrect URL:" + url);

} catch (Exception e) {

getRequest.abort();

Log.w(TAG, "Error whileretrieving bitmap from " + url, e);

} finally {

if (client != null) {

client.close();

}

}

return null;

}

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

总结

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

------------------------------------------------------------------------------------------------------------------------------------------------------

很多时候我们需要在Android设备上下载远程服务器上的图片进行显示，今天Android123整理出两种比较好的方法来实现远程图片的下载。 方法一、直接通过Android提供的Http类访问远程服务器，这里AndroidHttpClient是SDK
2.2中新出的方法，API Level为8，大家需要注意下，静态访问可以直接调用，如果SDK版本较低可以考虑Apache的Http库，当然HttpURLConnection或URLConnection也可以。

static Bitmap downloadBitmapByCwj(String url) {
final AndroidHttpClient client = AndroidHttpClient.newInstance("Android123");
final HttpGet getRequest = new HttpGet(url);

try {
HttpResponse response = client.execute(getRequest);
final int statusCode = response.getStatusLine().getStatusCode();
if (statusCode != HttpStatus.SC_OK) {
Log.e("cwjDebug", "Error " + statusCode + " while retrieving bitmap from " + url);
return null;
}

final HttpEntity entity = response.getEntity();
if (entity != null) {
InputStream inputStream = null;
try {
inputStream = entity.getContent();
final Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
return bitmap;
} finally {
if (inputStream != null) {
inputStream.close();
}
entity.consumeContent();
}
}
} catch (Exception e) {
getRequest.abort();
Log.e("android123Debug", "Error while retrieving bitmap from " + url, e.toString());
} finally {
if (client != null) {
client.close();
}
}
return null;
}

这里Android开发网提醒大家，BitmapFactory类的decodeStream方法在网络超时或较慢的时候无法获取完整的数据，这里我们通过继承FilterInputStream类的skip方法来强制实现flush流中的数据，主要原理就是检查是否到文件末端，告诉http类是否继续。

static class FlushedInputStream extends FilterInputStream {
public FlushedInputStream(InputStream inputStream) {
super(inputStream);
}

@Override
public long skip(long n) throws IOException {
long totalBytesSkipped = 0L;
while (totalBytesSkipped < n) {
long bytesSkipped = in.skip(n - totalBytesSkipped);
if (bytesSkipped == 0L) {
int byte = read();
if (byte < 0) {
break;  // we reached EOF
} else {
bytesSkipped = 1; // we read one byte
}
}
totalBytesSkipped += bytesSkipped;
}
return totalBytesSkipped;
}
}

方法二、AsyncTask异步任务

从Android 1.5固件开始Google提供了一个AsyncTask类来帮助开发者处理异步下载的实现，相对于Thread而言他可以运行在UI线程中，其内部的实现是从Java 5开始的并发包concurrent中派生而来的，总体实现比较可靠就是资源占用略大了些。不过使用起来比简单。这里下载图片类ImageDownloader类的download方法可以很好的处理实现UI显示等操作，参数一url为远程server上文件的url，第二个参数为imageview对象，可以直接让imageview显示出下载的远程图片。

public class ImageDownloader {

public void download(String url, ImageView imageView) {
BitmapDownloaderTask task = new BitmapDownloaderTask(imageView);
task.execute(url);
}
}

}

有关具体的AsyncTask类实现，考虑到图片可能较大，为了给JVM充分的空间存储，这里Android123推荐大家使用弱引用来保存ImageView对象。

class BitmapDownloaderTask extends AsyncTask<String, Void, Bitmap> {
private String url;
private final WeakReference<ImageView> imageViewReference;  //使用WeakReference解决内存问题

public BitmapDownloaderTask(ImageView imageView) {
imageViewReference = new WeakReference<ImageView>(imageView);
}

@Override
protected Bitmap doInBackground(String... params) {   //实际的下载线程，内部其实是concurrent线程，所以不会阻塞

return downloadBitmap(params[0]);
}

@Override
protected void onPostExecute(Bitmap bitmap) {   //下载完后执行的
if (isCancelled()) {
bitmap = null;
}

if (imageViewReference != null) {
ImageView imageView = imageViewReference.get();
if (imageView != null) {
imageView.setImageBitmap(bitmap);  //下载完设置imageview为刚才下载的bitmap对象
}
}
}
}