缓存工具类ACache使用方法详解
本文实例为大家分享了缓存工具类ACache的使用，供大家参考，具体内容如下
(1).ACachemCache=ACache.get(this);
(2).StringcacheData=mCache.getAsString("cache_data");
(3).if(!TextUtils.isEmpty(cacheData)){
解析、setAdapter、
}
(4).然后仍然请求网络，因为缓存的意义是为了在没网的情况下有数据显示。
(5).网络请求后获得的数据再
mCache.remove("cache_data");
mCache.put("cache_data",data);
Acache.java:
/**
*Copyright(c)2012-2013,MichaelYang杨福海(www.yangfuhai.com).
*
*LicensedundertheApacheLicense,Version2.0(the"License");
*youmaynotusethisfileexceptincompliancewiththeLicense.
*YoumayobtainacopyoftheLicenseat
*
*http://www.apache.org/licenses/LICENSE-2.0
*
*Unlessrequiredbyapplicablelaworagreedtoinwriting,software
*distributedundertheLicenseisdistributedonan"ASIS"BASIS,
*WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
*SeetheLicenseforthespecificlanguagegoverningpermissionsand
*limitationsundertheLicense.
*/
packagecom.monkey.monkeymushroom.utils;
importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.ByteArrayInputStream;
importjava.io.ByteArrayOutputStream;
importjava.io.File;
importjava.io.FileOutputStream;
importjava.io.FileReader;
importjava.io.FileWriter;
importjava.io.IOException;
importjava.io.ObjectInputStream;
importjava.io.ObjectOutputStream;
importjava.io.RandomAccessFile;
importjava.io.Serializable;
importjava.util.Collections;
importjava.util.HashMap;
importjava.util.Map;
importjava.util.Map.Entry;
importjava.util.Set;
importjava.util.concurrent.atomic.AtomicInteger;
importjava.util.concurrent.atomic.AtomicLong;
importorg.json.JSONArray;
importorg.json.JSONObject;
importandroid.content.Context;
importandroid.graphics.Bitmap;
importandroid.graphics.BitmapFactory;
importandroid.graphics.Canvas;
importandroid.graphics.PixelFormat;
importandroid.graphics.drawable.BitmapDrawable;
importandroid.graphics.drawable.Drawable;
/**
*@authorMichaelYang（www.yangfuhai.com）updateat2013.08.07
*/
publicclassACache{
publicstaticfinalintTIME_HOUR=60*60;
publicstaticfinalintTIME_DAY=TIME_HOUR*24;
privatestaticfinalintMAX_SIZE=1000*1000*100;//100mb-->原来50M
privatestaticfinalintMAX_COUNT=Integer.MAX_VALUE;//不限制存放数据的数量
privatestaticMapmInstanceMap=newHashMap();
privateACacheManagermCache;
publicstaticACacheget(Contextctx){
returnget(ctx,"ACache");
}
publicstaticACacheget(Contextctx,StringcacheName){
Filef=newFile(ctx.getCacheDir(),cacheName);
returnget(f,MAX_SIZE,MAX_COUNT);
}
publicstaticACachegetKx(Contextctx,StringcacheName){
StringkxDir=ctx.getFilesDir().getAbsolutePath()+"/KxDir";
Filef=newFile(kxDir,cacheName);
returnget(f,MAX_SIZE,MAX_COUNT);
}
publicstaticACacheget(FilecacheDir){
returnget(cacheDir,MAX_SIZE,MAX_COUNT);
}
publicstaticACacheget(Contextctx,longmax_zise,intmax_count){
Filef=newFile(ctx.getCacheDir(),"ACache");
returnget(f,max_zise,max_count);
}
publicstaticACacheget(FilecacheDir,longmax_zise,intmax_count){
ACachemanager=mInstanceMap.get(cacheDir.getAbsoluteFile()+myPid());
if(manager==null){
manager=newACache(cacheDir,max_zise,max_count);
mInstanceMap.put(cacheDir.getAbsolutePath()+myPid(),manager);
}
returnmanager;
}
privatestaticStringmyPid(){
return"_"+android.os.Process.myPid();
}
privateACache(FilecacheDir,longmax_size,intmax_count){
if(!cacheDir.exists()&&!cacheDir.mkdirs()){
thrownewRuntimeException("can'tmakedirsin"+cacheDir.getAbsolutePath());
}
mCache=newACacheManager(cacheDir,max_size,max_count);
}
//=======================================
//============String数据读写==============
//=======================================
/**
*保存String数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的String数据
*/
publicvoidput(Stringkey,Stringvalue){
Filefile=mCache.newFile(key);
BufferedWriterout=null;
try{
out=newBufferedWriter(newFileWriter(file),1024);
out.write(value);
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(out!=null){
try{
out.flush();
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
mCache.put(file);
}
}
/**
*保存String数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的String数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,Stringvalue,intsaveTime){
put(key,Utils.newStringWithDateInfo(saveTime,value));
}
/**
*读取String数据
*
*@paramkey
*@returnString数据
*/
publicStringgetAsString(Stringkey){
Filefile=mCache.get(key);
if(!file.exists())
returnnull;
booleanremoveFile=false;
BufferedReaderin=null;
try{
in=newBufferedReader(newFileReader(file));
StringreadString="";
StringcurrentLine;
while((currentLine=in.readLine())!=null){
readString+=currentLine;
}
if(!Utils.isDue(readString)){
returnUtils.clearDateInfo(readString);
}else{
removeFile=true;
returnnull;
}
}catch(IOExceptione){
e.printStackTrace();
returnnull;
}finally{
if(in!=null){
try{
in.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
if(removeFile)
remove(key);
}
}
//=======================================
//=============JSONObject数据读写==============
//=======================================
/**
*保存JSONObject数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的JSON数据
*/
publicvoidput(Stringkey,JSONObjectvalue){
put(key,value.toString());
}
/**
*保存JSONObject数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的JSONObject数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,JSONObjectvalue,intsaveTime){
put(key,value.toString(),saveTime);
}
/**
*读取JSONObject数据
*
*@paramkey
*@returnJSONObject数据
*/
publicJSONObjectgetAsJSONObject(Stringkey){
StringJSONString=getAsString(key);
try{
JSONObjectobj=newJSONObject(JSONString);
returnobj;
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}
//=======================================
//============JSONArray数据读写=============
//=======================================
/**
*保存JSONArray数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的JSONArray数据
*/
publicvoidput(Stringkey,JSONArrayvalue){
put(key,value.toString());
}
/**
*保存JSONArray数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的JSONArray数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,JSONArrayvalue,intsaveTime){
put(key,value.toString(),saveTime);
}
/**
*读取JSONArray数据
*
*@paramkey
*@returnJSONArray数据
*/
publicJSONArraygetAsJSONArray(Stringkey){
StringJSONString=getAsString(key);
try{
JSONArrayobj=newJSONArray(JSONString);
returnobj;
}catch(Exceptione){
e.printStackTrace();
returnnull;
}
}
//=======================================
//==============byte数据读写=============
//=======================================
/**
*保存byte数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的数据
*/
publicvoidput(Stringkey,byte[]value){
Filefile=mCache.newFile(key);
FileOutputStreamout=null;
try{
out=newFileOutputStream(file);
out.write(value);
}catch(Exceptione){
e.printStackTrace();
}finally{
if(out!=null){
try{
out.flush();
out.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
mCache.put(file);
}
}
/**
*保存byte数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,byte[]value,intsaveTime){
put(key,Utils.newByteArrayWithDateInfo(saveTime,value));
}
/**
*获取byte数据
*
*@paramkey
*@returnbyte数据
*/
publicbyte[]getAsBinary(Stringkey){
RandomAccessFileRAFile=null;
booleanremoveFile=false;
try{
Filefile=mCache.get(key);
if(!file.exists())
returnnull;
RAFile=newRandomAccessFile(file,"r");
byte[]byteArray=newbyte[(int)RAFile.length()];
RAFile.read(byteArray);
if(!Utils.isDue(byteArray)){
returnUtils.clearDateInfo(byteArray);
}else{
removeFile=true;
returnnull;
}
}catch(Exceptione){
e.printStackTrace();
returnnull;
}finally{
if(RAFile!=null){
try{
RAFile.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
if(removeFile)
remove(key);
}
}
//=======================================
//=============序列化数据读写===============
//=======================================
/**
*保存Serializable数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的value
*/
publicvoidput(Stringkey,Serializablevalue){
put(key,value,-1);
}
/**
*保存Serializable数据到缓存中
*
*@paramkey保存的key
*@paramvalue保存的value
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,Serializablevalue,intsaveTime){
ByteArrayOutputStreambaos=null;
ObjectOutputStreamoos=null;
try{
baos=newByteArrayOutputStream();
oos=newObjectOutputStream(baos);
oos.writeObject(value);
byte[]data=baos.toByteArray();
if(saveTime!=-1){
put(key,data,saveTime);
}else{
put(key,data);
}
}catch(Exceptione){
e.printStackTrace();
}finally{
try{
oos.close();
}catch(IOExceptione){
}
}
}
/**
*读取Serializable数据
*
*@paramkey
*@returnSerializable数据
*/
publicObjectgetAsObject(Stringkey){
byte[]data=getAsBinary(key);
if(data!=null){
ByteArrayInputStreambais=null;
ObjectInputStreamois=null;
try{
bais=newByteArrayInputStream(data);
ois=newObjectInputStream(bais);
ObjectreObject=ois.readObject();
returnreObject;
}catch(Exceptione){
e.printStackTrace();
returnnull;
}finally{
try{
if(bais!=null)
bais.close();
}catch(IOExceptione){
e.printStackTrace();
}
try{
if(ois!=null)
ois.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
}
returnnull;
}
//=======================================
//==============bitmap数据读写=============
//=======================================
/**
*保存bitmap到缓存中
*
*@paramkey保存的key
*@paramvalue保存的bitmap数据
*/
publicvoidput(Stringkey,Bitmapvalue){
put(key,Utils.Bitmap2Bytes(value));
}
/**
*保存bitmap到缓存中
*
*@paramkey保存的key
*@paramvalue保存的bitmap数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,Bitmapvalue,intsaveTime){
put(key,Utils.Bitmap2Bytes(value),saveTime);
}
/**
*读取bitmap数据
*
*@paramkey
*@returnbitmap数据
*/
publicBitmapgetAsBitmap(Stringkey){
if(getAsBinary(key)==null){
returnnull;
}
returnUtils.Bytes2Bimap(getAsBinary(key));
}
//=======================================
//=============drawable数据读写=============
//=======================================
/**
*保存drawable到缓存中
*
*@paramkey保存的key
*@paramvalue保存的drawable数据
*/
publicvoidput(Stringkey,Drawablevalue){
put(key,Utils.drawable2Bitmap(value));
}
/**
*保存drawable到缓存中
*
*@paramkey保存的key
*@paramvalue保存的drawable数据
*@paramsaveTime保存的时间，单位：秒
*/
publicvoidput(Stringkey,Drawablevalue,intsaveTime){
put(key,Utils.drawable2Bitmap(value),saveTime);
}
/**
*读取Drawable数据
*
*@paramkey
*@returnDrawable数据
*/
publicDrawablegetAsDrawable(Stringkey){
if(getAsBinary(key)==null){
returnnull;
}
returnUtils.bitmap2Drawable(Utils.Bytes2Bimap(getAsBinary(key)));
}
/**
*获取缓存文件
*
*@paramkey
*@returnvalue缓存的文件
*/
publicFilefile(Stringkey){
Filef=mCache.newFile(key);
if(f.exists())
returnf;
returnnull;
}
/**
*移除某个key
*
*@paramkey
*@return是否移除成功
*/
publicbooleanremove(Stringkey){
returnmCache.remove(key);
}
/**
*清除所有数据
*/
publicvoidclear(){
mCache.clear();
}
/**
*@author杨福海（michael）www.yangfuhai.com
*@version1.0
*@title缓存管理器
*/
publicclassACacheManager{
privatefinalAtomicLongcacheSize;
privatefinalAtomicIntegercacheCount;
privatefinallongsizeLimit;
privatefinalintcountLimit;
privatefinalMaplastUsageDates=Collections.synchronizedMap(newHashMap());
protectedFilecacheDir;
privateACacheManager(FilecacheDir,longsizeLimit,intcountLimit){
this.cacheDir=cacheDir;
this.sizeLimit=sizeLimit;
this.countLimit=countLimit;
cacheSize=newAtomicLong();
cacheCount=newAtomicInteger();
calculateCacheSizeAndCacheCount();
}
/**
*计算cacheSize和cacheCount
*/
privatevoidcalculateCacheSizeAndCacheCount(){
newThread(newRunnable(){
@Override
publicvoidrun(){
intsize=0;
intcount=0;
File[]cachedFiles=cacheDir.listFiles();
if(cachedFiles!=null){
for(FilecachedFile:cachedFiles){
size+=calculateSize(cachedFile);
count+=1;
lastUsageDates.put(cachedFile,cachedFile.lastModified());
}
cacheSize.set(size);
cacheCount.set(count);
}
}
}).start();
}
privatevoidput(Filefile){
intcurCacheCount=cacheCount.get();
while(curCacheCount+1>countLimit){
longfreedSize=removeNext();
cacheSize.addAndGet(-freedSize);
curCacheCount=cacheCount.addAndGet(-1);
}
cacheCount.addAndGet(1);
longvalueSize=calculateSize(file);
longcurCacheSize=cacheSize.get();
while(curCacheSize+valueSize>sizeLimit){
longfreedSize=removeNext();
curCacheSize=cacheSize.addAndGet(-freedSize);
}
cacheSize.addAndGet(valueSize);
LongcurrentTime=System.currentTimeMillis();
file.setLastModified(currentTime);
lastUsageDates.put(file,currentTime);
}
privateFileget(Stringkey){
Filefile=newFile(key);
LongcurrentTime=System.currentTimeMillis();
file.setLastModified(currentTime);
lastUsageDates.put(file,currentTime);
returnfile;
}
privateFilenewFile(Stringkey){
returnnewFile(cacheDir,key.hashCode()+"");
}
privatebooleanremove(Stringkey){
Fileimage=get(key);
returnimage.delete();
}
privatevoidclear(){
lastUsageDates.clear();
cacheSize.set(0);
File[]files=cacheDir.listFiles();
if(files!=null){
for(Filef:files){
f.delete();
}
}
}
/**
*移除旧的文件
*
*@return
*/
privatelongremoveNext(){
if(lastUsageDates.isEmpty()){
return0;
}
LongoldestUsage=null;
FilemostLongUsedFile=null;
Set>entries=lastUsageDates.entrySet();
synchronized(lastUsageDates){
for(Entryentry:entries){
if(mostLongUsedFile==null){
mostLongUsedFile=entry.getKey();
oldestUsage=entry.getValue();
}else{
LonglastValueUsage=entry.getValue();
if(lastValueUsagesaveTime+deleteAfter*1000){
returntrue;
}
}
returnfalse;
}
privatestaticStringnewStringWithDateInfo(intsecond,StringstrInfo){
returncreateDateInfo(second)+strInfo;
}
privatestaticbyte[]newByteArrayWithDateInfo(intsecond,byte[]data2){
byte[]data1=createDateInfo(second).getBytes();
byte[]retdata=newbyte[data1.length+data2.length];
System.arraycopy(data1,0,retdata,0,data1.length);
System.arraycopy(data2,0,retdata,data1.length,data2.length);
returnretdata;
}
privatestaticStringclearDateInfo(StringstrInfo){
if(strInfo!=null&&hasDateInfo(strInfo.getBytes())){
strInfo=strInfo.substring(strInfo.indexOf(mSeparator)+1,strInfo.length());
}
returnstrInfo;
}
privatestaticbyte[]clearDateInfo(byte[]data){
if(hasDateInfo(data)){
returncopyOfRange(data,indexOf(data,mSeparator)+1,data.length);
}
returndata;
}
privatestaticbooleanhasDateInfo(byte[]data){
returndata!=null&&data.length>15&&data[13]=='-'&&indexOf(data,mSeparator)>14;
}
privatestaticString[]getDateInfoFromDate(byte[]data){
if(hasDateInfo(data)){
StringsaveDate=newString(copyOfRange(data,0,13));
StringdeleteAfter=newString(copyOfRange(data,14,indexOf(data,mSeparator)));
returnnewString[]{saveDate,deleteAfter};
}
returnnull;
}
privatestaticintindexOf(byte[]data,charc){
for(inti=0;i"+to);
byte[]copy=newbyte[newLength];
System.arraycopy(original,from,copy,0,Math.min(original.length-from,newLength));
returncopy;
}
privatestaticfinalcharmSeparator='';
privatestaticStringcreateDateInfo(intsecond){
StringcurrentTime=System.currentTimeMillis()+"";
while(currentTime.length()<13){
currentTime="0"+currentTime;
}
returncurrentTime+"-"+second+mSeparator;
}
/*
*Bitmap→byte[]
*/
privatestaticbyte[]Bitmap2Bytes(Bitmapbm){
if(bm==null){
returnnull;
}
ByteArrayOutputStreambaos=newByteArrayOutputStream();
bm.compress(Bitmap.CompressFormat.PNG,100,baos);
returnbaos.toByteArray();
}
/*
*byte[]→Bitmap
*/
privatestaticBitmapBytes2Bimap(byte[]b){
if(b.length==0){
returnnull;
}
returnBitmapFactory.decodeByteArray(b,0,b.length);
}
/*
*Drawable→Bitmap
*/
privatestaticBitmapdrawable2Bitmap(Drawabledrawable){
if(drawable==null){
returnnull;
}
//取drawable的长宽
intw=drawable.getIntrinsicWidth();
inth=drawable.getIntrinsicHeight();
//取drawable的颜色格式
Bitmap.Configconfig=drawable.getOpacity()!=PixelFormat.OPAQUE?Bitmap.Config.ARGB_8888
:Bitmap.Config.RGB_565;
//建立对应bitmap
Bitmapbitmap=Bitmap.createBitmap(w,h,config);
//建立对应bitmap的画布
Canvascanvas=newCanvas(bitmap);
drawable.setBounds(0,0,w,h);
//把drawable内容画到画布中
drawable.draw(canvas);
returnbitmap;
}
/*
*Bitmap→Drawable
*/
@SuppressWarnings("deprecation")
privatestaticDrawablebitmap2Drawable(Bitmapbm){
if(bm==null){
returnnull;
}
returnnewBitmapDrawable(bm);
}
}
}
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持毛票票。