Volley（六 ）—— 从源码带看Volley的缓存机制

staticclassCacheHeader{
/**缓存文件的大小*/
publiclongsize;

/**缓存文件的唯一标识*/
publicStringkey;

/**这个是与与http请求缓存相关的标签*/
publicStringetag;

/**服务器的返回来数据的时间*/
publiclongserverDate;

/**TTL缓存过期时间.*/
publiclongttl;

/**SoftTTL缓存新鲜度时间.*/
publiclongsoftTtl;

/**服务器还回来的头部信息.*/
publicMap<String,String>responseHeaders;
}

//可以看到，头部类里包含的都是一些基本信息。再来看一下内容部分，父类Cache里面的的Entry:
publicstaticclassEntry{
/**服务端返回数据的主要内容.*/
publicbyte[]data;

publicStringetag;

publiclongserverDate;

publiclongttl;

publiclongsoftTtl;
}

/**默认的磁盘存放的最大byte*/
privatestaticfinalintDEFAULT_DISK_USAGE_BYTES=5*1024*1024;
...
publicDiskBasedCache(FilerootDirectory){
this(rootDirectory,DEFAULT_DISK_USAGE_BYTES);
}

queue=Volley.newRequestQueue(context);

queue=Volley.newRequestQueue(context，10*1024*1024);

@Override
publicvoidrun(){
while(true){
...
try{
....
请求解析http的返回信息
....
if(request.shouldCache()&&response.cacheEntry!=null){
mCache.put(request.getCacheKey(),response.cacheEntry);
request.addMarker("network-cache-written");
}

....
}
}

/**
*把缓存数据Entry写进磁盘里
*/
@Override
publicsynchronizedvoidput(Stringkey,Entryentry){
//判断是否有足够的缓存空间来缓存新的数据
pruneIfNeeded(entry.data.length);

Filefile=getFileForKey(key);
try{
FileOutputStreamfos=newFileOutputStream(file);
//用enry里面的数据，再封装成一个CacheHeader
CacheHeadere=newCacheHeader(key,entry);
//先写头部缓存信息
booleansuccess=e.writeHeader(fos);
if(!success){
fos.close();
VolleyLog.d("Failedtowriteheaderfor%s",file.getAbsolutePath());
thrownewIOException();
}
//成功后再写缓存内容
fos.write(entry.data);
fos.close();
//把头部信息先暂时保存在一个容器里
putEntry(key,e);
return;
}catch(IOExceptione){
}
booleandeleted=file.delete();
if(!deleted){
VolleyLog.d("Couldnotcleanupfile%s",file.getAbsolutePath());
}
}

Cache.Entryentry=mCache.get(request.getCacheKey())

@Override
publicsynchronizedEntryget(Stringkey){
CacheHeaderentry=mEntries.get(key);
//如果entry不为空，就直接返回
if(entry==null){
returnnull;
}

Filefile=getFileForKey(key);
CountingInputStreamcis=null;
try{
cis=newCountingInputStream(newFileInputStream(file));
CacheHeader.readHeader(cis);//eatheader
byte[]data=streamToBytes(cis,(int)(file.length()-cis.bytesRead));
returnentry.toCacheEntry(data);
}catch(IOExceptione){
VolleyLog.d("%s:%s",file.getAbsolutePath(),e.toString());
remove(key);
returnnull;
}finally{
if(cis!=null){
try{
cis.close();
}catch(IOExceptionioe){
returnnull;
}
}
}
}

publicstaticCache.EntryparseCacheHeaders(NetworkResponseresponse){
longnow=System.currentTimeMillis();

Map<String,String>headers=response.headers;

longserverDate=0;
longserverExpires=0;
longsoftExpire=0;
longmaxAge=0;
booleanhasCacheControl=false;

StringserverEtag=null;
StringheaderValue;

headerValue=headers.get("Date");
if(headerValue!=null){
serverDate=parseDateAsEpoch(headerValue);
}

headerValue=headers.get("Cache-Control");
if(headerValue!=null){
hasCacheControl=true;
String[]tokens=headerValue.split(",");
for(inti=0;i<tokens.length;i++){
Stringtoken=tokens[i].trim();
//如果Cache-Control里为no-cache和no-store则表示不需要缓存，返回null
if(token.equals("no-cache")||token.equals("no-store")){
returnnull;
}elseif(token.startsWith("max-age=")){
try{
maxAge=Long.parseLong(token.substring(8));
}catch(Exceptione){
}
}elseif(token.equals("must-revalidate")||token.equals("proxy-revalidate")){
maxAge=0;
}
}
}

headerValue=headers.get("Expires");
if(headerValue!=null){
serverExpires=parseDateAsEpoch(headerValue);
}
serverEtag=headers.get("ETag");
//Cache-ControltakesprecedenceoveranExpiresheader,evenifbothexistandExpires
//ismorerestrictive.
if(hasCacheControl){
softExpire=now+maxAge*1000;
}elseif(serverDate>0&&serverExpires>=serverDate){
//DefaultsemanticforExpireheaderinHTTPspecificationissoftExpire.
softExpire=now+(serverExpires-serverDate);
}

Cache.Entryentry=newCache.Entry();
entry.data=response.data;
entry.etag=serverEtag;
entry.softTtl=softExpire;
entry.ttl=entry.softTtl;
entry.serverDate=serverDate;
entry.responseHeaders=headers;
returnentry;
}

Volley对于新鲜度和过期的验证

@Override
publicvoidrun(){
if(DEBUG)VolleyLog.v("startnewdispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//初始化缓存，里面会先把磁盘缓存里的头部数据缓存进内存里，增加处理速度
mCache.initialize();

while(true){
try{
//阻塞线程直到有请求加入，才开始运行
finalRequestrequest=mCacheQueue.take();
request.addMarker("cache-queue-take");

//请求是否取消
if(request.isCanceled()){
request.finish("cache-discard-canceled");
continue;
}

//得到缓存数据entry
Cache.Entryentry=mCache.get(request.getCacheKey());
//如果缓存不存在，就把请求交给网络队列取处理
if(entry==null){
request.addMarker("cache-miss");
mNetworkQueue.put(request);
continue;
}

//如果请求过期，也需要到网络重新获取数据
if(entry.isExpired()){
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}

//到这里就表明缓存数据是可用的，解析缓存
request.addMarker("cache-hit");
Response<?>response=request.parseNetworkResponse(
newNetworkResponse(entry.data,entry.responseHeaders));
request.addMarker("cache-hit-parsed");

//验证缓存的新鲜度
if(!entry.refreshNeeded()){
//新鲜的
mDelivery.postResponse(request,response);
}else{
//不新鲜，虽然把缓存数据分发出去，但还是需要到网络上验证缓存是否需要更新
request.addMarker("cache-hit-refresh-needed");
//请求带上缓存属性
request.setCacheEntry(entry);

response.intermediate=true;

//分发完缓存数据后，将请求加入网络请求队列，判断是否需要更新缓存数据
mDelivery.postResponse(request,response,newRunnable(){
@Override
publicvoidrun(){
try{
mNetworkQueue.put(request);
}catch(InterruptedExceptione){
//Notmuchwecandoaboutthis.
}
}
});
}

}catch(InterruptedExceptione){
//Wemayhavebeeninterruptedbecauseitwastimetoquit.
if(mQuit){
return;
}
continue;
}
}
}

@Override
publicNetworkResponseperformRequest(Request<?>request)throwsVolleyError{
....
while(true){
...
try{
Map<String,String>headers=newHashMap<String,String>();
//如果请求有带属性，就将etag和If-Modified-Since属性加上
addCacheHeaders(headers,request.getCacheEntry());
httpResponse=mHttpStack.performRequest(request,headers);
StatusLinestatusLine=httpResponse.getStatusLine();
intstatusCode=statusLine.getStatusCode();

responseHeaders=convertHeaders(httpResponse.getAllHeaders());
//如果304就直接用缓存数据返回
if(statusCode==HttpStatus.SC_NOT_MODIFIED){
returnnewNetworkResponse(HttpStatus.SC_NOT_MODIFIED,
request.getCacheEntry().data,responseHeaders,true);
}
.....
returnnewNetworkResponse(statusCode,responseContents,responseHeaders,false);
}catch(SocketTimeoutExceptione){
...
}
}
}

publicvoidrun(){
...
NetworkResponsenetworkResponse=mNetwork.performRequest(request);
request.addMarker("network-http-complete");
//如果是304并且已经将缓存分发出去里，就直接结束这个请求
if(networkResponse.notModified&&request.hasHadResponseDelivered()){
request.finish("not-modified");
continue;
}
...
}
}

publicstaticCache.EntryparseIgnoreCacheHeaders(NetworkResponseresponse){
longnow=System.currentTimeMillis();
Map<String,String>headers=response.headers;
longserverDate=0;
StringserverEtag=null;
StringheaderValue;
headerValue=headers.get("Date");

if(headerValue!=null){
serverDate=HttpHeaderParser.parseDateAsEpoch(headerValue);
}

serverEtag=headers.get("ETag");
finallongcacheHitButRefreshed=3*60*1000;
finallongcacheExpired=24*60*60*1000;
finallongsoftExpire=now+cacheHitButRefreshed;
finallongttl=now+cacheExpired;

Cache.Entryentry=newCache.Entry();
entry.data=response.data;
entry.etag=serverEtag;
entry.softTtl=softExpire;
entry.ttl=ttl;
entry.serverDate=serverDate;
entry.responseHeaders=headers;
returnentry;
}

publicclassMyRequestextendscom.android.volley.Request<MyResponse>{
...
@Override
protectedResponse<MyResponse>parseNetworkResponse(NetworkResponseresponse){
StringjsonString=newString(response.data);
MyResponseMyResponse=gson.fromJson(jsonString,MyResponse.class);
returnResponse.success(MyResponse,HttpHeaderParser.parseIgnoreCacheHeaders(response));
}
}

图片的自定义内存缓存

publicinterfaceImageCache{
publicBitmapgetBitmap(Stringurl);
publicvoidputBitmap(Stringurl,Bitmapbitmap);
}

publicImageContainerget(StringrequestUrl,ImageListenerimageListener,
intmaxWidth,intmaxHeight){
//请求只能在主线程里，不然会报错
throwIfNotOnMainThread();
//用url和宽高组成key
finalStringcacheKey=getCacheKey(requestUrl,maxWidth,maxHeight);

//从内存缓存里获取数据
BitmapcachedBitmap=mCache.getBitmap(cacheKey);
if(cachedBitmap!=null){
//如果内存不为空，直接返回图片信息
ImageContainercontainer=newImageContainer(cachedBitmap,requestUrl,null,null);
imageListener.onResponse(container,true);
returncontainer;
}

...
//如果为空，就正常请求网络数据，下面用的是ImageRequest取请求网络数据
Request<?>newRequest=
newImageRequest(requestUrl,newListener<Bitmap>(){
@Override
publicvoidonResponse(Bitmapresponse){
//请求成功后，在这个方法里，把图片放进内存缓存中
onGetImageSuccess(cacheKey,response);
}
},maxWidth,maxHeight,
Config.RGB_565,newErrorListener(){
@Override
publicvoidonErrorResponse(VolleyErrorerror){
onGetImageError(cacheKey,error);
}
});
...
}

privatevoidonGetImageSuccess(StringcacheKey,Bitmapresponse){
//把图片放进内存里
mCache.putBitmap(cacheKey,response);
...
}