利用LruCache和DiskLruCache实现图片异步下载

前言：对于图片的缓存现在都倾向于使用开源项目，如下：

1. Android-Universal-Image-Loader 图片缓存

目前使用最广泛的图片缓存，支持主流图片缓存的绝大多数特性。

项目地址：https://github.com/nostra13/Android-Universal-Image-Loader

2. picasso square开源的图片缓存

项目地址：https://github.com/square/picasso

特点：(1)可以自动检测adapter的重用并取消之前的下载

(2)图片变换

(3)可以加载本地资源

(4)可以设置占位资源

(5)支持debug模式

3. ImageCache 图片缓存，包含内存和Sdcard缓存

项目地址：https://github.com/Trinea/AndroidCommon

特点：

(1)支持预取新图片，支持等待队列

(2)包含二级缓存，可自定义文件名保存规则

(3)可选择多种缓存算法(FIFO、LIFO、LRU、MRU、LFU、MFU等13种)或自定义缓存算法

(4)可方便的保存及初始化恢复数据

(5)支持不同类型网络处理

(6)可根据系统配置初始化缓存等

4.以及FaceBook新近开源的图片下载框架Fresco

本教程适合新手，能力有限，如有错误欢迎指出；

开始撸码：

核心：LruCache和DiskLruCache以及线程池

1. LruCache进行内存缓存（Google官方提供）

2. DiskLruCache硬盘缓存（非Google官方提供，已经获得官方认证）源码地址：https://github.com/JakeWharton/DiskLruCache

本文代码是在郭神以及这位大神的基础上修改而成，感谢两位大神！

LruCache和DiskLruCache用法参考以上两位大神；

项目：



代码API和Android-Universal-Image-Loader类似

package cc.mnbase.image;

import android.content.Context;
import android.content.pm.PackageInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.media.ThumbnailUtils;
import android.os.Handler;
import android.os.Message;
import android.support.v4.util.LruCache;
import android.util.Log;
import android.view.View;
import android.widget.ImageView;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import cc.mnbase.image.libcore.io.DiskLruCache;

/**
* Date: 2015-10-22
* Time: 10:22
* Version 1.0
*/

public class ImageLoader {

private LruCache<String, Bitmap> mMemoryCache; //内存缓存

private DiskLruCache mDiskLruCache; //google官方推荐处理本地缓存库

private ExecutorService mDownlodThreadPool;  //下载图片线程池

private int maxDiskMemory = 20*1024*1024; //本地最大缓存:20M

private FileUtils fileUtils;

private Context mContext;

private String tag = ImageLoader.class.getSimpleName();

public ImageLoader(Context context){
mContext = context;
//获取系统为每个应用分配的最大内存
int maxMemory = (int)Runtime.getRuntime().maxMemory();
int mCacheSize = maxMemory / 8;
//分配最大内存的1/8
mMemoryCache = new LruCache<String, Bitmap>(mCacheSize){
@Override
protected int sizeOf(String key, Bitmap value) {
return value.getRowBytes() * value.getHeight();
}

@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
//可以进行强制回收oldValue
//oldValue.recycle();
//oldValue = null;
}
};
fileUtils = new FileUtils(context);
try {
mDiskLruCache = DiskLruCache.open(new File(fileUtils.getStorageDirectory()), getAppVersion(context),
1, maxDiskMemory);
} catch (IOException e) {
e.printStackTrace();
}

}

/**
* 获取线程池
* */
// private ExecutorService getThreadPool(){
//     if(mDownlodThreadPool==null){
//         synchronized (ExecutorService.class){
//             if(mDownlodThreadPool==null){
//                 mDownlodThreadPool = Executors.newFixedThreadPool(1);
//             }
//         }
//     }
//      return mDownlodThreadPool;
//  }
/**
* 获取线程池
* */
private ExecutorService getThreadPool(){
if(mDownlodThreadPool==null){
mDownlodThreadPool = Executors.newFixedThreadPool(5);
}
return mDownlodThreadPool;
}

/**
* 添加Bitmap到内存缓存中
* */
private void addBitmapToMemoryCache(String key, Bitmap value){
if(getBitmapFromMemoryCache(key) == null && value!=null){
mMemoryCache.put(key, value);
}
}

/**
* 从内存缓存中获取Bitmap
* */
private Bitmap getBitmapFromMemoryCache(String key){
return mMemoryCache.get(key);
}

/**
* 下载图片
* @param imageView 图片控件
* @param listener  回调方法
* @param url 图片地址
* */
public void displayImage(String url, ImageView imageView, onImageLoaderListener listener){
downLoadImage(url, null, imageView, null, listener, null);
}

/**
* 下载图片
* @param imageSize 设置图片尺寸
* @param imageView 图片控件
* @param listener 回调方法
* @param url 图片地址
* */
public void loadImage(String url, ImageSize imageSize, ImageView imageView, DisplayImageOptions options, onImageLoaderListener listener,
onImageLoadingProgressListener progressListener){
downLoadImage(url, imageSize, imageView, options, listener, progressListener);
}

/**
* 下载图片
* @param imageSize 设置图片尺寸
* @param imageView 图片控件
* @param listener 回调方法
* @param url 图片地址
* */
public void loadImage(String url, ImageSize imageSize, ImageView imageView, onImageLoaderListener listener,
onImageLoadingProgressListener progressListener){
loadImage(url, imageSize, imageView, null, listener, progressListener);
}

/**
* 下载图片
* @param imageSize 设置图片尺寸
* @param imageView 图片控件
* @param listener 回调方法
* @param url 图片地址
* */
public void loadImage(String url, ImageSize imageSize, ImageView imageView, onImageLoaderListener listener){
loadImage(url, imageSize, imageView, listener, null);
}

/**
* 下载图片
* @param imageSize 设置图片尺寸
* @param imageView 图片控件
* @param url 图片地址
* */
public void loadImage(String url, ImageSize imageSize, ImageView imageView){
loadImage(url, imageSize, imageView, null);
}

/**
* 下载图片
* @param imageView 图片控件
* @param url 图片地址
* */
public void loadImage(String url, ImageView imageView){
loadImage(url, null, imageView);
}

/**
* 下载图片
* */
private void downLoadImage(final String url, final ImageSize imageSize, final ImageView imageView, final DisplayImageOptions options,
final onImageLoaderListener listener, final onImageLoadingProgressListener progressListener){
if(options!=null){
imageView.setImageDrawable(options.getImageOnLoading(mContext.getResources()));
}
final String key = MD5.hashKeyForDisk(url);
Bitmap bitmap = showCacheBitmap(key);
if(bitmap!=null){
if(imageSize!=null){
bitmap = createNewBitmap(bitmap, imageSize);
}
if(imageView!=null){
imageView.setImageBitmap(bitmap);
}
if(listener!=null){
listener.onImageLoader(bitmap, url);
}
return;
} else {
final int[] fileLength = {0};
final Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what){
case 0:
if(imageView!=null){
Bitmap tmpBitmap = (Bitmap)msg.obj;
if(tmpBitmap!=null){
imageView.setImageBitmap(tmpBitmap);
if(listener!=null){
listener.onImageLoader(tmpBitmap, url);
}
} else {
if(options!=null){
imageView.setImageDrawable(options.getImageOnFail(mContext.getResources()));
}
}
}
break;
case 1:
if(progressListener!=null){
progressListener.onProgressUpdate(url, imageView, (int)msg.obj, fileLength[0]);
}
break;
case 2:
fileLength[0] = (int)msg.obj;
break;
}
}
};

getThreadPool().execute(new Runnable() {
@Override
public void run() {
Bitmap bitmap = saveBitmapToDisk(url, key, handler);  //下载并保存在储存卡中
if(bitmap!=null && imageSize!=null){
bitmap = createNewBitmap(bitmap, imageSize);
}
Message msg = handler.obtainMessage(0, bitmap);
handler.sendMessage(msg);

addBitmapToMemoryCache(key, bitmap); //添加Bitmap到手机内存里
}
});

}
}

/**
* 根据ImageSize重新设置图片尺寸
* */
private Bitmap createNewBitmap(Bitmap bitmap, ImageSize imageSize){
//系统提供的图片缩放方法
Bitmap tmp = ThumbnailUtils.extractThumbnail(bitmap, imageSize.getWidth(), imageSize.getHeight());
return tmp;
}

/**
* 从内存或者SD卡中获取图片
* */
private Bitmap showCacheBitmap(String key){
if(getBitmapFromMemoryCache(key) != null){
return getBitmapFromMemoryCache(key);
} else {
Bitmap bitmap = getBitmapFromDisk(key);
addBitmapToMemoryCache(key, bitmap);
return bitmap;
}
}

/**
* 从储存卡缓存中获取Bitmap
* */
private Bitmap getBitmapFromDisk(String key){
Bitmap bitmap = null;
try{
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
if(snapshot!=null){
InputStream is = snapshot.getInputStream(0);
bitmap = BitmapFactory.decodeStream(is);
}
} catch (Exception e){
e.printStackTrace();
}
return bitmap;
}

/**
* 获取储存卡已缓存图片的大小
* */
public int getDiskMemory(){
return mMemoryCache.size();
}

/**
* 保存Bitmap到储存卡中
* */
private Bitmap saveBitmapToDisk(String url, String key, Handler handler){
Bitmap bitmap = null;
try{
DiskLruCache.Editor editor = mDiskLruCache.edit(key);
if(editor!=null){
OutputStream os = editor.newOutputStream(0);
boolean succ = getBitmapFromUrl(url, key, handler, os);
if(succ){
editor.commit(); //一定要执行此方法否则不会保存图片
bitmap = getBitmapFromDisk(key); //从SD卡获取
} else {
editor.abort();
}
}
mDiskLruCache.flush();
} catch (Exception e){
e.printStackTrace();
}
return bitmap;
}

/**
* 从网络中获取图片
* */
private boolean getBitmapFromUrl(String url, String key,  Handler handler, OutputStream fos){
boolean succ = false;
HttpURLConnection con = null;
try{
URL imgUrl = new URL(url);
con = (HttpURLConnection)imgUrl.openConnection();
con.setConnectTimeout(10 * 1000);
con.setReadTimeout(10 * 1000);

InputStream is = con.getInputStream();

int fileLength = con.getContentLength();
Message message = handler.obtainMessage(2, fileLength);
handler.sendMessage(message);
byte buf[] = new byte[1024];
int downLoadFileSize = 0;
do{
int numread = is.read(buf);
if(numread == -1){
break; //终止循环
}
fos.write(buf, 0, numread);
downLoadFileSize += numread;
Message msg = handler.obtainMessage(1, downLoadFileSize);
handler.sendMessage(msg);
} while (true);

succ = true; //下载完成

} catch (Exception e){
e.printStackTrace();
succ = false;
} finally {
if(con != null){
con.disconnect();
}
}

return succ;
}

/**
* 取消下载任务
* */
//public synchronized void cancelTask(){
//    if(mDownlodThreadPool != null){
//        mDownlodThreadPool.shutdownNow();
//        mDownlodThreadPool = null;
//    }
//}
/**
* 取消下载任务
* */
public void cancelTask(){
if(mDownlodThreadPool != null){
mDownlodThreadPool.shutdownNow();
mDownlodThreadPool = null;
}
}

/**
* 获取app当前版本号
* */
private int getAppVersion(Context context){
try {
PackageInfo info = context.getPackageManager().getPackageInfo(context.getPackageName(), 1);
return info.versionCode;
} catch (Exception e){
e.printStackTrace();
}
return 1;
}

/**
* 图片异步下载的回调方法
* */
public interface onImageLoaderListener{
void onImageLoader(Bitmap bitmap, String url);
}

/**
* 图片异步下载的进度回调方法
* */
public interface onImageLoadingProgressListener{
void onProgressUpdate(String imageUri, View view, int current, int total);
}

}

FileUtil类主要是获取图片缓存路径：

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.os.Environment;
import android.util.Log;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
* Date: 2015-10-22
* Time: 11:49
* Version 1.0
*/

public class FileUtils {

public static String mSdRootPath = Environment.getExternalStorageDirectory().getPath();

private static String mDataRootPath = null;

private final static String APP_PACKAGE_FOLDER = "/Android/data";

private final static String FOLDER_NAME = "/image";

private String appPackage = null;

private String tag = FileUtils.class.getSimpleName();

public FileUtils(Context context){
appPackage = context.getPackageName();
mDataRootPath = context.getCacheDir().getPath();
}

/**
* 获取图片保存路径：优先保存在SD卡
* */
public String getStorageDirectory(){
String path = Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED) ?
mSdRootPath + APP_PACKAGE_FOLDER + File.separator + appPackage + FOLDER_NAME : mDataRootPath + FOLDER_NAME;
File folderFile = new File(path);
if(!folderFile.exists()){ //目录不存在时，进行创建
folderFile.mkdirs();
}
return path;
}
}

ImageSize类主要为了设置图片大小：

package cc.mnbase.image;

/**
* Date: 2015-10-22
* Time: 14:57
* Version 1.0
*/

public class ImageSize {

private int width;

private int height;

public ImageSize(int width, int height){
this.width = width;
this.height = height;
}

public int getWidth() {
return width;
}

public void setWidth(int width) {
this.width = width;
}

public int getHeight() {
return height;
}

public void setHeight(int height) {
this.height = height;
}

}

DisplayImageOptions类主要设置图片在下载中，失败时显示的默认图片（和Android-Universal-Image-Loader同名类用法类似）：

package cc.mnbase.image;

import android.content.res.Resources;
import android.graphics.drawable.Drawable;

/**
* Date: 2015-10-22
* Time: 21:55
* Version 1.0
*/

public final class DisplayImageOptions {

private final int imageResOnLoading;

private final int imageResForEmptyUri;

private final int imageResFail;

private final Drawable imageLoading;

private final Drawable imageForEmptyUri;

private final Drawable imageOnFail;

private DisplayImageOptions(DisplayImageOptions.Builder builder){
this.imageResOnLoading = builder.imageResOnLoading;
this.imageResForEmptyUri = builder.imageResForEmptyUri;
this.imageResFail = builder.imageResOnFail;
this.imageLoading = builder.imageLoading;
this.imageForEmptyUri = builder.imageForEmptyUri;
this.imageOnFail = builder.imageOnFail;
}

public Drawable getImageOnLoading(Resources res){
return this.imageResOnLoading != 0 ?  res.getDrawable(this.imageResOnLoading):this.imageLoading;
}

public Drawable getImageForEmptyUri(Resources res){
return this.imageResForEmptyUri != 0 ? res.getDrawable(this.imageResForEmptyUri):this.imageForEmptyUri;
}

public Drawable getImageOnFail(Resources res){
return this.imageResFail != 0 ? res.getDrawable(this.imageResFail):this.imageOnFail;
}

public static class Builder{
private int imageResOnLoading = 0;
private int imageResForEmptyUri = 0;
private int imageResOnFail = 0;
private Drawable imageLoading = null;
private Drawable imageForEmptyUri = null;
private Drawable imageOnFail = null;

public Builder(){

}

/**
* 设置正在加载时显示图片
* */
public DisplayImageOptions.Builder showImageOnLoading(int imageRes){
this.imageResOnLoading = imageRes;
return this;
}

/**
*
* */
public DisplayImageOptions.Builder showImageForEmptyUri(int imageRes){
this.imageResForEmptyUri = imageRes;
return this;
}

/**
* 设置图片加载失败时显示的图片
* */
public DisplayImageOptions.Builder showImageOnFail(int imageRes){
this.imageResOnFail = imageRes;
return this;
}

/**
* 设置正在加载时显示图片
* */
public DisplayImageOptions.Builder showImageOnLoading(Drawable drawable){
this.imageLoading = drawable;
return this;
}

/**
*
* */
public DisplayImageOptions.Builder showImageForEmptyUri(Drawable drawable){
this.imageForEmptyUri = drawable;
return this;
}

/**
* 设置图片加载失败时显示的图片
* */
public DisplayImageOptions.Builder showImageOnFail(Drawable drawable){
this.imageOnFail = drawable;
return this;
}

public DisplayImageOptions build(){
return new DisplayImageOptions(this);
}

}

}

MD5类主要是处理图片名称：

package cc.mnbase.image;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
* Date: 2015-10-23
* Time: 15:22
* Version 1.0
*/

public class MD5 {

public static String hashKeyForDisk(String key){
String cacheKey = null;
try {
MessageDigest mDigest = MessageDigest.getInstance("MD5");
mDigest.update(key.getBytes());
cacheKey = byteToHexString(mDigest.digest());
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
cacheKey = String.valueOf(key.hashCode());
}
return cacheKey;
}

private static String byteToHexString(byte[] bytes){
StringBuilder sb = new StringBuilder();

for(int i=0; i< bytes.length; i++){
String hex = Integer.toHexString(0XFF & bytes[i]);
if(hex.length() == 1){
sb.append('0');
}
sb.append(hex);
}

return sb.toString();
}
}

OK，以上是主要代码，看下效果截图：