缓存控制
浏览器 HTTP 协议缓存机制详解
确实很详细
缓存Cache详解
先前对http缓存的主要疑惑在于:
几个相关消息头的优先级顺序是怎样的?
请求中的字段对响应中的字段有什么影响或者有什么关系?
优先级顺序:
Cache-Control > Expires > ETag > Last-Modified
安卓app作为一个客户端,没必要精细地执行http协议.要自由地完全地由客户端控制缓存,那么就只控制Cache-Control.
cache-control的相关值有如下这些:
值可以是public、private、no-cache、no- store、no-transform、must-revalidate、proxy-revalidate、max-age
各个消息中的指令含义如下：
Public指示响应可被任何缓存区缓存。
Private指示对于单个用户的整个或部分响应消息，不能被共享缓存处理。这允许服务器仅仅描述当用户的部分响应消息，此响应消息对于其他用户的请求无效。
no-cache指示请求或响应消息不能缓存，该选项并不是说可以设置”不缓存“，容易望文生义~
no-store用于防止重要的信息被无意的发布。在请求消息中发送将使得请求和响应消息都不使用缓存，完全不存下來。
max-age指示客户机可以接收生存期不大于指定时间（以秒为单位）的响应。
min-fresh指示客户机可以接收响应时间小于当前时间加上指定时间的响应。
max-stale指示客户机可以接收超出超时期间的响应消息。如果指定max-stale消息的值，那么客户机可以接收超出超时期指定值之内的响应消息。
must-revalidate — 响应在特定条件下会被重用，以满足接下来的请求，但是它必须到服务器端去验证它是不是仍然是最新的。
proxy-revalidate — 类似于 must-revalidate,但不适用于代理缓存.
app中可能出现的缓存控制需求场景
请求头
如果不想从缓存中读取,就在请求头中设置no-cache,如此就可以强制访问网络而不读取缓存.
读取缓存有效期内的缓存: 请求头里设置max-age.
设置了这个之后,就去缓存里找,找到了缓存文件,而且文件里的有效期又在这个之内,那么就读取缓存.如果过期,就去访问网络.
强制读取缓存(比如在没有网络的情况下),而不管有没有过期: 设置max-age为一个非常大的值,比如几百年以后
响应
本来,响应头里的字段是服务器写的,但一般post请求甚至get请求,服务器都会直接返回no-cache,为了实现完全的客户端缓存的自我控制,拿到响应对象后,将里面响应头里Cache-Control字段值改成我们需要的值就行了.
如果不想缓存这个响应数据,设置为no-cache.
需要注意的
网络框架至少需要支持Cache-Control字段的逻辑
response对象中需要有一个字段标识其是由缓存中生成的还是网络拉取的,便于修改Cache-Control字段值时只修改网络返回的.
volley里的缓存控制(只看Cache-Control)
了解基本流程:
Android volley 解析（四）之缓存篇
缓存文件里的内容是怎样的:
Android中关于Volley的使用（八）缓存机制的深入认识
疑问:
发送请求时,去取缓存,怎么判断是否过期的?是根据Cache-Control字段吗?
看CacheDispatcher里的这段代码:
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
mNetworkQueue.put(request);
continue;
}
// If it is completely expired, just send it to the network.
if (entry.isExpired()) {
request.addMarker("cache-hit-expired");
request.setCacheEntry(entry);
mNetworkQueue.put(request);
continue;
}
// We have a cache hit; parse its data for delivery back to the request.
request.addMarker("cache-hit");
Response response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
先是根据CacheKey去缓存中拿缓存,然后判断缓存有没有过期,判断缓存过期的方法:
Cache.Entry里:
public boolean isExpired() {
return this.ttl < System.currentTimeMillis();
}
Cache.Entry.ttl是什么东西?注释也没有...那么,看它是怎么赋值的.
当然是响应回来后,解析响应头拿到的:
HttpHeaderParser的 Cache.Entry parseCacheHeaders(NetworkResponse response)方法里:
Cache.Entry entry = new Cache.Entry();
entry.data = response.data;
entry.etag = serverEtag;
entry.softTtl = softExpire;//软过期时间?什么鬼?
entry.ttl = finalExpire;//表示的是最终过期时间
entry.serverDate = serverDate;
entry.lastModified = lastModified;
entry.responseHeaders = headers;
return entry;
// finalExpire 是怎么拿到的?
if (hasCacheControl) {
softExpire = now + maxAge * 1000;
finalExpire = mustRevalidate
? softExpire
: softExpire + staleWhileRevalidate * 1000;
} else if (serverDate > 0 && serverExpires >= serverDate) {
// Default semantic for Expire header in HTTP specification is softExpire.
softExpire = now + (serverExpires - serverDate);
finalExpire = softExpire;
}
//hasCacheControl 是表示响应头里有没有Cache-Control字段
headerValue = headers.get("Cache-Control");
if (headerValue != null) {
hasCacheControl = true;
//同理,mustRevalidate是表示响应头里是否有mustRevalidate字段.不管怎么,既然我决定拦截重写响应头,那我就不要它.为false.最终走到
softExpire = now + maxAge * 1000;
finalExpire = softExpire + staleWhileRevalidate * 1000;
//maxAge当然就是max-Age解析出来的,但staleWhileRevalidate又是什么?
//先把本地缓存的文件给用户，同时会去后端server进行数据对比,后端server能正常响应的话，squid会对比数据是否更新，更新的话，就把更新的数据给到下一次用户请求.我们不需要这么复杂,重写时果断不写.
干脆放出整段源码:
headerValue = headers.get("Cache-Control");
if (headerValue != null) {
hasCacheControl = true;
String[] tokens = headerValue.split(",");
for (int i = 0; i < tokens.length; i++) {
String token = tokens[i].trim();
if (token.equals("no-cache") || token.equals("no-store")) {
return null;
} else if (token.startsWith("max-age=")) {
try {
maxAge = Long.parseLong(token.substring(8));
} catch (Exception e) {
}
} else if (token.startsWith("stale-while-revalidate=")) {
try {
staleWhileRevalidate = Long.parseLong(token.substring(23));
} catch (Exception e) {
}
} else if (token.equals("must-revalidate") || token.equals("proxy-revalidate")) {
mustRevalidate = true;
}
}
}
//最终,finalExpire = softExpire,我们要覆写的响应头达到的效果是,只有一个cache-control ,内部只有一个max-age=xxx,没有其他值了.
复写响应头:
缓存控制相关的字段都有的响应头长这样:
HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)
Cache-Control: max-age=3600, must-revalidate
Expires: Fri, 30 Oct 1998 14:19:41 GMT
Last-Modified: Mon, 29 Jun 1998 02:28:12 GMT
ETag: "3e86-410-3596fbbc"
Content-Length: 1040
Content-Type: text/html
我们要变成的效果是:
HTTP/1.1 200 OK
Date: Fri, 30 Oct 1998 13:19:41 GMT
Server: Apache/1.3.3 (Unix)
Cache-Control: max-age=3600
Content-Length: 1040
Content-Type: text/html
有两种方法可以达到效果,
一是在resonse解析前复写里面的header,二是解析成Cache.entry后修改entry里的值.注意,如果header里cache-control的值为no-cache或no-store,那么解析Cache.entry时直接返回空,所以,还是第一种保险一点.
看NetworkResponse里源码,
/** Response headers. */
public final Map headers;
public NetworkResponse(int statusCode, byte[] data, Map headers,
boolean notModified, long networkTimeMs) {
this.statusCode = statusCode;
this.data = data;
this.headers = headers;
this.notModified = notModified;
this.networkTimeMs = networkTimeMs;
}
这个对象在request里有返回,Request抽象类定义了方法让子类实现:
abstract protected Response parseNetworkResponse(NetworkResponse response);
比如StringRequest的实现:
@Override
protected Response parseNetworkResponse(NetworkResponse response) {
String parsed;
try {
parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
} catch (UnsupportedEncodingException e) {
parsed = new String(response.data);
}
return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}
这里的HttpHeaderParser.parseCacheHeaders(response)就是解析生成Cache.Entry的地方,那么,自定义一个request,更改了NetworkResponse里面的headers后,再传入这个方法中,就可以达到完全控制缓存的目的了.
@Override
protected Response parseNetworkResponse(NetworkResponse response) {
String parsed;
try {
parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
} catch (UnsupportedEncodingException e) {
parsed = new String(response.data);
}
reSetCacheControl(response);
return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}
long time;
private void reSetCacheControl(NetworkResponse response) {
//怎么判断是从缓存中取的还是从网络上取的?请求时设置的缓存时间怎么传?
if(isFromNet){
Map headers = response.headers;
headers.put("Cache-Control","max-age="+time);
}
}
注意解析之后的缓存,还需要判断shouldecache的值:(NetworkDispatcher里)
Response response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");
// Write to cache if applicable.
// TODO: Only update cache metadata instead of entire record for 304s.
if (request.shouldCache() && response.cacheEntry != null) {
mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
// Post the response back.
request.markDelivered();
针对上面的两个问题:
怎么判断是从缓存中取的还是从网络上取的
在CacheDisPatcher里,当拿到的Cache没有过期时:
// We have a cache hit; parse its data for delivery back to the request.
request.addMarker("cache-hit");
Response response = request.parseNetworkResponse(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
if (!entry.refreshNeeded()) {
// Completely unexpired cache hit. Just deliver the response.
mDelivery.postResponse(request, response);
} else {
// Soft-expired cache hit. We can deliver the cached response,
// but we need to also send the request to the network for
// refreshing.
request.addMarker("cache-hit-refresh-needed");
request.setCacheEntry(entry);
// Mark the response as intermediate.
response.intermediate = true;
// Post the intermediate response back to the user and have
// the delivery then forward the request along to the network.
final Request finalRequest = request;
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(finalRequest);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}
// request.addMarker("cache-hit-parsed"); ? addMarker也许有用? 看了源码 略有失望
/**
* Adds an event to this request's event log; for debugging.
*/
public void addMarker(String tag) {
if (MarkerLog.ENABLED) {
mEventLog.add(tag, Thread.currentThread().getId());
}
}
//这个方法是用于debug的,但是可以复写啊,
//在自定义的request里设置一个int值,遇到"cache-hit","cache-hit-parsed"就加1,最终到2,就可以判定是从缓存中读取的.
long cacheTime;//毫秒
public boolean isFromCache = false;
public int cacheHitCount = 0;
@Override
public void addMarker(String tag) {
super.addMarker(tag);
if ("cache-hit".equals(tag)){
cacheHitCount++;
}else if ("cache-hit-parsed".equals(tag)){
cacheHitCount++;
}
if (cacheHitCount == 2){
isFromCache = true;
}
}
private void reSetCacheControl(NetworkResponse response) {
this.setShouldCache(true);//重置cache开关
if (!isFromCache){
Map headers = response.headers;
headers.put("Cache-Control","max-age="+cacheTime);
}
}
缓存时间的话,就设置成这个自定义的request的成员变量就好,代码见上面
于是,几种场景的解决方案如下:
强制进行网络访问,但回来的请求又想缓存个几个小时或几天,或者永久缓存.
request.setShouldCache(false)
myStringRequest.setResponseCacheTime(xxx)//自定义的方法
设置普通的请求缓存时间,过期就拉网络:
这个就是普通的用法了,设置请求头.
public void setRequestHeadCacheTime(int timeInSecond){
try {
getHeaders().put("Cache-Control","max-age="+timeInSecond);
} catch (AuthFailureError authFailureError) {
authFailureError.printStackTrace();
}
}