Android实现图片异步请求加三级缓存
使用xUtils等框架是很方便,但今天要用代码实现bitmapUtils的功能,很简单,
AsyncTask请求一张图片
####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软件编程有所帮助。