Android使用缓存机制实现文件下载及异步请求图片加三级缓存

public abstract class asynctask<params, progress, result> {
private static final string log_tag = "asynctask";
private static final int core_pool_size = 5;
private static final int maximum_pool_size = 128;
private static final int keep_alive = 1;
private static final threadfactory sthreadfactory = new threadfactory() {
private final atomicinteger mcount = new atomicinteger(1);
public thread newthread(runnable r) {
return new thread(r, "asynctask #" + mcount.getandincrement());
}
}; 

private static final internalhandler shandler = new internalhandler(); mfuture = new futuretask<result>(mworker) {
@override
protected void more ...done() {
message message;
result result = null;
try {
result = get();
} catch (interruptedexception e) {
android.util.log.w(log_tag, e);
} catch (executionexception e) {
throw new runtimeexception("an error occured while executing doinbackground()",
e.getcause());
} catch (cancellationexception e) {
message = shandler.obtainmessage(message_post_cancel,
new asynctaskresult<result>(asynctask.this, (result[]) null));
message.sendtotarget();
return;
} catch (throwable t) {
throw new runtimeexception("an error occured while executing "
+ "doinbackground()", t);
}
message = shandler.obtainmessage(message_post_result,
new asynctaskresult<result>(asynctask.this, result));
message.sendtotarget();
}
};
private static class internalhandler extends handler {
@suppresswarnings({"unchecked", "rawuseofparameterizedtype"})
@override
public void more ...handlemessage(message msg) {
asynctaskresult result = (asynctaskresult) msg.obj;
switch (msg.what) {
case message_post_result:
// there is only one result
result.mtask.finish(result.mdata[0]);
break;
case message_post_progress:
result.mtask.onprogressupdate(result.mdata);
break;
case message_post_cancel:
result.mtask.oncancelled();
break;
}
}
}

import java.io.inputstream;
import java.net.httpurlconnection;
import java.net.url;
import android.graphics.bitmap;
import android.graphics.bitmapfactory;
import android.os.asynctask;
import android.widget.imageview;
/**
* 网络缓存
* 
* @author ace
* @date 2016-02-18
*/
public class netcacheutils {
private localcacheutils mlocalutils;
private memorycacheutils mmemoryutils;
public netcacheutils(localcacheutils localutils,
memorycacheutils memoryutils) {
mlocalutils = localutils;
mmemoryutils = memoryutils;
}
public void getbitmapfromnet(imageview imageview, string url) {
bitmaptask task = new bitmaptask();
task.execute(imageview, url);
}
/**
* asynctask是线程池+handler的封装 第一个泛型: 传参的参数类型类型(和doinbackground一致) 第二个泛型:
* 更新进度的参数类型(和onprogressupdate一致) 第三个泛型: 返回结果的参数类型(和onpostexecute一致,
* 和doinbackground返回类型一致)
*/
class bitmaptask extends asynctask<object, integer, bitmap> {
private imageview mimageview;
private string url;
// 主线程运行, 预加载
@override
protected void onpreexecute() {
super.onpreexecute();
}
// 子线程运行, 异步加载逻辑在此方法中处理
@override
protected bitmap doinbackground(object... params) {
mimageview = (imageview) params[0];
url = (string) params[1];
mimageview.settag(url);// 将imageview和url绑定在一起
// publishprogress(values)//通知进度
// 下载图片
return download(url);
}
// 主线程运行, 更新进度
@override
protected void onprogressupdate(integer... values) {
super.onprogressupdate(values);
}
// 主线程运行, 更新主界面
@override
protected void onpostexecute(bitmap result) {
if (result != null) {
// 判断当前图片是否就是imageview要的图片, 防止listview重用导致的图片错乱的情况出现
string bindurl = (string) mimageview.gettag();
if (bindurl.equals(url)) {
// 给imageview设置图片
mimageview.setimagebitmap(result);
// 将图片保存在本地
mlocalutils.setbitmaptolocal(result, url);
// 将图片保存在内存
mmemoryutils.setbitmaptomemory(url, result);
}
}
}
}
/**
* 下载图片
* 
* @param url
*/
public bitmap download(string url) {
httpurlconnection conn = null;
try {
conn = (httpurlconnection) (new url(url).openconnection());
conn.setconnecttimeout(5000);
conn.setreadtimeout(5000);
conn.setrequestmethod("get");
conn.connect();
int responsecode = conn.getresponsecode();
if (responsecode == 200) {
inputstream in = conn.getinputstream();
// 将流转化为bitmap对象
bitmap bitmap = bitmapfactory.decodestream(in);
return bitmap;
}
} catch (exception e) {
e.printstacktrace();
} finally {
if (conn != null) {
conn.disconnect();
}
}
return null;
}
}

* a cache that holds strong references to a limited number of values. each time 
* a value is accessed, it is moved to the head of a queue. when a value is 
* added to a full cache, the value at the end of that queue is evicted and may 
* become eligible for garbage collection. 
* cache保存一个强引用来限制内容数量，每当item被访问的时候，此item就会移动到队列的头部。
* 当cache已满的时候加入新的item时，在队列尾部的item会被回收。 
* <p>if your cached values hold resources that need to be explicitly released, 
* override {@link #entryremoved}. 
* 如果你cache的某个值需要明确释放，重写entryremoved()

* <p>by default, the cache size is measured in the number of entries. override 
* {@link #sizeof} to size the cache in different units. for example, this cache 
* is limited to 4mib of bitmaps: 默认cache大小是测量的item的数量，重写sizeof计算不同item的
* 大小。
 {@code 
 * int cachesize = 4 * 1024 * 1024; // 4mib 
 * lrucache<string, bitmap> bitmapcache = new lrucache<string, bitmap>(cachesize) { 
 * protected int sizeof(string key, bitmap value) { 
 * return value.getbytecount(); 
 * } 
 * }}
-------------------------------------------------------------------
<p>this class is thread-safe. perform multiple cache operations atomically by 
* synchronizing on the cache: <pre> {@code 
* synchronized (cache) { 
* if (cache.get(key) == null) { 
* cache.put(key, value); 
* } 
* }}</pre> 
* 他是线程安全的,自动地执行多个缓存操作并且加锁
-------------------------
<p>this class does not allow null to be used as a key or value. a return 
* value of null from {@link #get}, {@link #put} or {@link #remove} is 
* unambiguous: the key was not in the cache.
* 不允许key或者value为null
* 当get（），put（），remove（）返回值为null时，key相应的项不在cache中

import android.graphics.bitmap;
import android.support.v4.util.lrucache;
/**
* 内存缓存工具类
* 
* @author ace
* @date 2016-02-19
*/
public class memorycacheutils {

// android 2.3 (api level
// 9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠,建议用lrucache,它是强引用
private lrucache<string, bitmap> mcache;
public memorycacheutils() {
int maxmemory = (int) runtime.getruntime().maxmemory();// 获取虚拟机分配的最大内存
// 16m
// lru 最近最少使用, 通过控制内存不要超过最大值(由开发者指定), 来解决内存溢出,就像上面翻译的所说 如果cache满了会清理最近最少使用的缓存对象
mcache = new lrucache<string, bitmap>(maxmemory / 8) {
@override
protected int sizeof(string key, bitmap value) {
// 计算一个bitmap的大小
int size = value.getrowbytes() * value.getheight();// 每一行的字节数乘以高度
return size;
}
};
}
public bitmap getbitmapfrommemory(string url) {
return mcache.get(url);
}
public void setbitmaptomemory(string url, bitmap bitmap) {
mcache.put(url, bitmap);
}
}

/**
* 本地缓存工具类
* 
* @author ace
* @date 2016-02-19
*/
public class localcacheutils {
// 图片缓存的文件夹
public static final string dir_path = environment
.getexternalstoragedirectory().getabsolutepath()
+ "/ace_bitmap_cache";
public bitmap getbitmapfromlocal(string url) {
try {
file file = new file(dir_path, md5encoder.encode(url));
if (file.exists()) {
bitmap bitmap = bitmapfactory.decodestream(new fileinputstream(
file));
return bitmap;
}
} catch (exception e) {
e.printstacktrace();
}
return null;
}
public void setbitmaptolocal(bitmap bitmap, string url) {
file dirfile = new file(dir_path);
// 创建文件夹 文件夹不存在或者它不是文件夹 则创建一个文件夹.mkdirs,mkdir的区别在于假如文件夹有好几层路径的话,前者会创建缺失的父目录 后者不会创建这些父目录
if (!dirfile.exists() || !dirfile.isdirectory()) {
dirfile.mkdirs();
}
try {
file file = new file(dir_path, md5encoder.encode(url));
// 将图片压缩保存在本地,参1:压缩格式;参2:压缩质量(0-100);参3:输出流
bitmap.compress(compressformat.jpeg, 100,
new fileoutputstream(file));
} catch (exception e) {
e.printstacktrace();
}
}
}

import java.security.messagedigest;
public class md5encoder {
public static string encode(string string) throws exception {
byte[] hash = messagedigest.getinstance("md5").digest(string.getbytes("utf-8"));
stringbuilder hex = new stringbuilder(hash.length * 2);
for (byte b : hash) {
if ((b & 0xff) < 0x10) {
hex.append("0");
}
hex.append(integer.tohexstring(b & 0xff));
}
return hex.tostring();
}
}

/**
* 三级缓存工具类
* 
* @author ace
* @date 2016-02-19
*/
public class mybitmaputils {
// 网络缓存工具类
private netcacheutils mnetutils;
// 本地缓存工具类
private localcacheutils mlocalutils;
// 内存缓存工具类
private memorycacheutils mmemoryutils;
public mybitmaputils() {
mmemoryutils = new memorycacheutils();
mlocalutils = new localcacheutils();
mnetutils = new netcacheutils(mlocalutils, mmemoryutils);
}
public void display(imageview imageview, string url) {
// 设置默认加载图片
imageview.setimageresource(r.drawable.news_pic_default);
// 先从内存缓存加载
bitmap bitmap = mmemoryutils.getbitmapfrommemory(url);
if (bitmap != null) {
imageview.setimagebitmap(bitmap);
system.out.println("从内存读取图片啦...");
return;
}
// 再从本地缓存加载
bitmap = mlocalutils.getbitmapfromlocal(url);
if (bitmap != null) {
imageview.setimagebitmap(bitmap);
system.out.println("从本地读取图片啦...");
// 给内存设置图片
mmemoryutils.setbitmaptomemory(url, bitmap);
return;
}
// 从网络缓存加载
mnetutils.getbitmapfromnet(imageview, url);
}
}