Android使用缓存机制实现文件下载及异步请求图片加三级缓存
首先给大家介绍Android使用缓存机制实现文件下载
在下载文件或者在线浏览文件时，或者为了保证文件下载的正确性，需要使用缓存机制，常使用SoftReference来实现。
SoftReference的特点是它的一个实例保存对一个Java对象的软引用，该软引用的存在不妨碍垃圾收集线程对该Java对象的回收。也就是说，一旦SoftReference保存了对一个Java对象的软引用后，在垃圾线程对这个Java对象回收前，SoftReference类所提供的get()方法返回Java对象的强引用。另外，一旦垃圾线程回收该Java对象之后，get()方法将返回null。软引用可以和一个引用队列（ReferenceQueue）联合使用，如果软引用所引用的对象被垃圾回收器回收，Java虚拟机就会把这个软引用加入到与之关联的引用队列中。
一般的缓存策略是：
一级内存缓存、二级文件缓存（数据库也算作文件缓存）、三级网络数据
一、网络下载的缓存策略
关于网络下载文件（图片、音频、视频）的基本策略：
1.不要直接下载到目标文件，应使用temp文件作中转，以确保文件的正确性与完整性，流程如下：
a)以网络目标文件名A生成唯一的本地目标文件名B
b)以本地目标文件名B生成唯一的本地临时文件名T
c)下载文件到T中
d)下载完毕，校验文件T的正确性与完整性
e)若不正确或不完整则delete文件T，并返回false
f)校验完毕后，将文件T重命名或复制到B文件
g)最后的清理现场，删除临时文件T，成功后，返回true
2.尽力提供文件正确性与完整性的校验：
a)正确性：比如MD5/HashCode比对、文件格式的比对。
b)完整性：比如文件大小是否一致、图片的数据是否正确（图片文件头中提供了相关信息）
3.考虑对于下载到本地的文件是否需要再做二次加工，可以思考以下情况：
a)比如网络源始图片的大小为800*600，而我们需要作为缩略图的大小为160*145，所以考虑对下载后的文件进行裁剪，再保存，对于源始文件则直接删除。
二、文件缓存策略：
1.需要唯一的缓存文件的对应I/Okey，一般可以使用hashcode。
2.若是同一个文件，以不同的时间，可以考虑，先清本地缓存，再下载新的缓存到本地。
3.同一文件也可以加上时间戳后，再生成唯一hashcode。
4.生成文件缓时，也许需要作以下全面的考虑：
a)sdcard是否已经没有空间（这个需求是存在的，但几乎没有人会考虑到，一旦发生，必crash）。
b)缓存的清理策略。每日、每周定时清理？到达一个阀值后，自动清理？（若无清理策略，把垃圾数据一直当个宝一相存着，
是很SB的）。
c)缓存真正需要的数据。不要觉外存是无限的，所以就可以什么都存，要知道，多则繁，繁则乱。曾经有一同事，每天存几百MB的用户数据（所有用户的性别、age、联系方式等等），而PM需要的只是一个每日数户的活跃数据报表，于是最后改为缓存每天的用户分析报表数据即可（才10几KB）。
d)给缓存文件加密。最简单就是去掉文件的扩展名，这也算加密，当然，你可以把服务端文件加密，然后在内存中解密。这就看项目的需求而定，我的经验也不足，一般就是改改扩展名之类的。
下面给大家介绍Android异步请求图片加三级缓存
使用xUtils等框架是很方便,但今天要用代码实现bitmapUtils的功能,很简单,
1AsyncTask请求一张图片
####AsyncTask
#####AsyncTask是线程池+handler的封装第一个泛型:传参的参数类型类型(和doInBackground一致)第二个泛型:
#####更新进度的参数类型(和onProgressUpdate一致)第三个泛型:返回结果的参数类型(和onPostExecute一致,
#####和doInBackground返回类型一致)
看AsyncTask源码:
publicabstractclassAsyncTask<Params,Progress,Result>{
privatestaticfinalStringLOG_TAG="AsyncTask";
privatestaticfinalintCORE_POOL_SIZE=5;
privatestaticfinalintMAXIMUM_POOL_SIZE=128;
privatestaticfinalintKEEP_ALIVE=1;
privatestaticfinalThreadFactorysThreadFactory=newThreadFactory(){
privatefinalAtomicIntegermCount=newAtomicInteger(1);
publicThreadnewThread(Runnabler){
returnnewThread(r,"AsyncTask#"+mCount.getAndIncrement());
}
};
核心线程5最大线程128这是AsyncTask的线程池然后通过handler发送消息,它内部实例化了一个静态的自定义类InternalHandler，这个类是继承自Handler的，在这个自定义类中绑定了一个叫做AsyncTaskResult的对象，每次子线程需要通知主线程，就调用sendToTarget发送消息给handler自己。然后在handler的handleMessage中AsyncTaskResult根据消息的类型不同（例如MESSAGE_POST_PROGRESS会更新进度条，MESSAGE_POST_CANCEL取消任务）而做不同的操作，值得一提的是，这些操作都是在UI线程进行的，意味着，从子线程一旦需要和UI线程交互，内部自动调用了handler对象把消息放在了主线程了。
privatestaticfinalInternalHandlersHandler=newInternalHandler();mFuture=newFutureTask<Result>(mWorker){
@Override
protectedvoidMore...done(){
Messagemessage;
Resultresult=null;
try{
result=get();
}catch(InterruptedExceptione){
android.util.Log.w(LOG_TAG,e);
}catch(ExecutionExceptione){
thrownewRuntimeException("AnerroroccuredwhileexecutingdoInBackground()",
e.getCause());
}catch(CancellationExceptione){
message=sHandler.obtainMessage(MESSAGE_POST_CANCEL,
newAsyncTaskResult<Result>(AsyncTask.this,(Result[])null));
message.sendToTarget();
return;
}catch(Throwablet){
thrownewRuntimeException("Anerroroccuredwhileexecuting"
+"doInBackground()",t);
}
message=sHandler.obtainMessage(MESSAGE_POST_RESULT,
newAsyncTaskResult<Result>(AsyncTask.this,result));
message.sendToTarget();
}
};
privatestaticclassInternalHandlerextendsHandler{
@SuppressWarnings({"unchecked","RawUseOfParameterizedType"})
@Override
publicvoidMore...handleMessage(Messagemsg){
AsyncTaskResultresult=(AsyncTaskResult)msg.obj;
switch(msg.what){
caseMESSAGE_POST_RESULT:
//Thereisonlyoneresult
result.mTask.finish(result.mData[0]);
break;
caseMESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
caseMESSAGE_POST_CANCEL:
result.mTask.onCancelled();
break;
}
}
}
下面看代码第一步我们先请求一张图片并解析注释写的很详细了.
NetCacheUtils.java
importjava.io.InputStream;
importjava.net.HttpURLConnection;
importjava.net.URL;
importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.os.AsyncTask;
importandroid.widget.ImageView;
/**
*网络缓存
*
*@authorAce
*@date2016-02-18
*/
publicclassNetCacheUtils{
privateLocalCacheUtilsmLocalUtils;
privateMemoryCacheUtilsmMemoryUtils;
publicNetCacheUtils(LocalCacheUtilslocalUtils,
MemoryCacheUtilsmemoryUtils){
mLocalUtils=localUtils;
mMemoryUtils=memoryUtils;
}
publicvoidgetBitmapFromNet(ImageViewimageView,Stringurl){
BitmapTasktask=newBitmapTask();
task.execute(imageView,url);
}
/**
*AsyncTask是线程池+handler的封装第一个泛型:传参的参数类型类型(和doInBackground一致)第二个泛型:
*更新进度的参数类型(和onProgressUpdate一致)第三个泛型:返回结果的参数类型(和onPostExecute一致,
*和doInBackground返回类型一致)
*/
classBitmapTaskextendsAsyncTask<Object,Integer,Bitmap>{
privateImageViewmImageView;
privateStringurl;
//主线程运行,预加载
@Override
protectedvoidonPreExecute(){
super.onPreExecute();
}
//子线程运行,异步加载逻辑在此方法中处理
@Override
protectedBitmapdoInBackground(Object...params){
mImageView=(ImageView)params[0];
url=(String)params[1];
mImageView.setTag(url);//将imageView和url绑定在一起
//publishProgress(values)//通知进度
//下载图片
returndownload(url);
}
//主线程运行,更新进度
@Override
protectedvoidonProgressUpdate(Integer...values){
super.onProgressUpdate(values);
}
//主线程运行,更新主界面
@Override
protectedvoidonPostExecute(Bitmapresult){
if(result!=null){
//判断当前图片是否就是imageView要的图片,防止listview重用导致的图片错乱的情况出现
StringbindUrl=(String)mImageView.getTag();
if(bindUrl.equals(url)){
//给imageView设置图片
mImageView.setImageBitmap(result);
//将图片保存在本地
mLocalUtils.setBitmapToLocal(result,url);
//将图片保存在内存
mMemoryUtils.setBitmapToMemory(url,result);
}
}
}
}
/**
*下载图片
*
*@paramurl
*/
publicBitmapdownload(Stringurl){
HttpURLConnectionconn=null;
try{
conn=(HttpURLConnection)(newURL(url).openConnection());
conn.setConnectTimeout(5000);
conn.setReadTimeout(5000);
conn.setRequestMethod("GET");
conn.connect();
intresponseCode=conn.getResponseCode();
if(responseCode==200){
InputStreamin=conn.getInputStream();
//将流转化为bitmap对象
Bitmapbitmap=BitmapFactory.decodeStream(in);
returnbitmap;
}
}catch(Exceptione){
e.printStackTrace();
}finally{
if(conn!=null){
conn.disconnect();
}
}
returnnull;
}
}
MemoryCacheUtils.java用到了LruCache很简单我简单翻译下文档:
*Acachethatholdsstrongreferencestoalimitednumberofvalues.Eachtime
*avalueisaccessed,itismovedtotheheadofaqueue.Whenavalueis
*addedtoafullcache,thevalueattheendofthatqueueisevictedandmay
*becomeeligibleforgarbagecollection.
*Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。
*当cache已满的时候加入新的item时，在队列尾部的item会被回收。
*<p>Ifyourcachedvaluesholdresourcesthatneedtobeexplicitlyreleased,
*override{@link#entryRemoved}.
*如果你cache的某个值需要明确释放，重写entryRemoved()
*<p>Bydefault,thecachesizeismeasuredinthenumberofentries.Override
*{@link#sizeOf}tosizethecacheindifferentunits.Forexample,thiscache
*islimitedto4MiBofbitmaps:默认cache大小是测量的item的数量，重写sizeof计算不同item的
*大小。
{@code
*intcacheSize=4*1024*1024;//4MiB
*LruCache<String,Bitmap>bitmapCache=newLruCache<String,Bitmap>(cacheSize){
*protectedintsizeOf(Stringkey,Bitmapvalue){
*returnvalue.getByteCount();
*}
*}}
-------------------------------------------------------------------
<p>Thisclassisthread-safe.Performmultiplecacheoperationsatomicallyby
*synchronizingonthecache:<pre>{@code
*synchronized(cache){
*if(cache.get(key)==null){
*cache.put(key,value);
*}
*}}</pre>
*他是线程安全的,自动地执行多个缓存操作并且加锁
-------------------------
<p>Thisclassdoesnotallownulltobeusedasakeyorvalue.Areturn
*valueofnullfrom{@link#get},{@link#put}or{@link#remove}is
*unambiguous:thekeywasnotinthecache.
*不允许key或者value为null
*当get（），put（），remove（）返回值为null时，key相应的项不在cache中
最重要的大概就是以上几点:使用很简单来看代码
importandroid.graphics.Bitmap;
importandroid.support.v4.util.LruCache;
/**
*内存缓存工具类
*
*@authorAce
*@date2016-02-19
*/
publicclassMemoryCacheUtils{
//Android2.3(APILevel
//9)开始，垃圾回收器会更倾向于回收持有软引用或弱引用的对象，这让软引用和弱引用变得不再可靠,建议用LruCache,它是强引用
privateLruCache<String,Bitmap>mCache;
publicMemoryCacheUtils(){
intmaxMemory=(int)Runtime.getRuntime().maxMemory();//获取虚拟机分配的最大内存
//16M
//LRU最近最少使用,通过控制内存不要超过最大值(由开发者指定),来解决内存溢出,就像上面翻译的所说如果cache满了会清理最近最少使用的缓存对象
mCache=newLruCache<String,Bitmap>(maxMemory/8){
@Override
protectedintsizeOf(Stringkey,Bitmapvalue){
//计算一个bitmap的大小
intsize=value.getRowBytes()*value.getHeight();//每一行的字节数乘以高度
returnsize;
}
};
}
publicBitmapgetBitmapFromMemory(Stringurl){
returnmCache.get(url);
}
publicvoidsetBitmapToMemory(Stringurl,Bitmapbitmap){
mCache.put(url,bitmap);
}
}
最后一级缓存本地缓存把网络下载的图片文件名以MD5的形式保存到内存卡的制定目录
/**
*本地缓存工具类
*
*@authorAce
*@date2016-02-19
*/
publicclassLocalCacheUtils{
//图片缓存的文件夹
publicstaticfinalStringDIR_PATH=Environment
.getExternalStorageDirectory().getAbsolutePath()
+"/ace_bitmap_cache";
publicBitmapgetBitmapFromLocal(Stringurl){
try{
Filefile=newFile(DIR_PATH,MD5Encoder.encode(url));
if(file.exists()){
Bitmapbitmap=BitmapFactory.decodeStream(newFileInputStream(
file));
returnbitmap;
}
}catch(Exceptione){
e.printStackTrace();
}
returnnull;
}
publicvoidsetBitmapToLocal(Bitmapbitmap,Stringurl){
FiledirFile=newFile(DIR_PATH);
//创建文件夹文件夹不存在或者它不是文件夹则创建一个文件夹.mkdirs,mkdir的区别在于假如文件夹有好几层路径的话,前者会创建缺失的父目录后者不会创建这些父目录
if(!dirFile.exists()||!dirFile.isDirectory()){
dirFile.mkdirs();
}
try{
Filefile=newFile(DIR_PATH,MD5Encoder.encode(url));
//将图片压缩保存在本地,参1:压缩格式;参2:压缩质量(0-100);参3:输出流
bitmap.compress(CompressFormat.JPEG,100,
newFileOutputStream(file));
}catch(Exceptione){
e.printStackTrace();
}
}
}
MD5Encoder
importjava.security.MessageDigest;
publicclassMD5Encoder{
publicstaticStringencode(Stringstring)throwsException{
byte[]hash=MessageDigest.getInstance("MD5").digest(string.getBytes("UTF-8"));
StringBuilderhex=newStringBuilder(hash.length*2);
for(byteb:hash){
if((b&0xFF)<0x10){
hex.append("0");
}
hex.append(Integer.toHexString(b&0xFF));
}
returnhex.toString();
}
}
最后新建一个工具类来使用我们上面的三个缓存工具类
/**
*三级缓存工具类
*
*@authorAce
*@date2016-02-19
*/
publicclassMyBitmapUtils{
//网络缓存工具类
privateNetCacheUtilsmNetUtils;
//本地缓存工具类
privateLocalCacheUtilsmLocalUtils;
//内存缓存工具类
privateMemoryCacheUtilsmMemoryUtils;
publicMyBitmapUtils(){
mMemoryUtils=newMemoryCacheUtils();
mLocalUtils=newLocalCacheUtils();
mNetUtils=newNetCacheUtils(mLocalUtils,mMemoryUtils);
}
publicvoiddisplay(ImageViewimageView,Stringurl){
//设置默认加载图片
imageView.setImageResource(R.drawable.news_pic_default);
//先从内存缓存加载
Bitmapbitmap=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);
}
}
以上所述给大家介绍了Android异步请求图片加三级缓存的相关知识，希望对大家有所帮助。