Volley源码分析(二)CacheDispatcher分析
CacheDispatcher 缓存分发
cacheQueue只是一个优先队列，我们在start方法中，分析了CacheDispatcher的构成是需要cacheQueue，然后调用CacheDispatcher.start方法，我们看一下CacheDispatcher得到cacheQueue之后，到底做了什么。
CacheQueue是一个继承于Thread的类，其start方法实质上是调用了run方法，我们看一下run方法所做的事情
@Override
public void run() {
if (DEBUG) VolleyLog.v("start new dispatcher");
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// Make a blocking call to initialize the cache.
mCache.initialize();
while (true) {
try {
// Get a request from the cache triage queue, blocking until
// at least one is available.
final Request<?> request = mCacheQueue.take();
request.addMarker("cache-queue-take");
// If the request has been canceled, don't bother dispatching it.
if (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
// Attempt to retrieve this item from cache.
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");
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.
mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
}
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
}
}
}
我们可以看出其Run方法是一个无限循环的方法，退出的方式只有产生中断异常，也就是其thread对象调用了 interrupt()方法，这个方法是在requestQueue中的stop方法中调用了，上面我们已经分析了。
下面我们主要run方法的执行过程，取出队头的request，然后判断request是否被取消，如果没有就判断该request中取出entity，判断entity的状态，如果entity为空，则将该request放入NetWorkDispatcher中重新请求，如果entity过期了也将该request放入NetWorkDispatcher中重新请求。两者都没有，则从request中entity的内容，重新构造response，然后判断该entity是否需要刷新，不需要就直接Delivery该response，如果需要刷新，则将该response依旧发给用户，但是重新进行请求该刷新entity。
可以用下图的逻辑去看上面的过程
这里，涉及到了Http一个重要的点，缓存。我们看一下，entity中关于缓存是怎么设置的.
class Entry {
/** The data returned from cache. */
public byte[] data;
/** ETag for cache coherency. */
public String etag;
/** Date of this response as reported by the server. */
public long serverDate;
/** The last modified date for the requested object. */
public long lastModified;
/** TTL for this record. */
public long ttl;
/** Soft TTL for this record. */
public long softTtl;
/** Immutable response headers as received from server; must be non-null. */
public Map<String, String> responseHeaders = Collections.emptyMap();
/** True if the entry is expired. */
boolean isExpired() {
return this.ttl < System.currentTimeMillis();
}
/** True if a refresh is needed from the original data source. */
boolean refreshNeeded() {
return this.softTtl < System.currentTimeMillis();
}
}
这里的过期方法判断与是否需要刷新都是通过TTL与softTTL和现在时间对比而得到的。
缓存
这里说一下Volley的缓存机制，涉及到Http缓存，需要解析Http响应报文的头部。
public static Cache.Entry parseCacheHeaders(NetworkResponse response) {
long now = System.currentTimeMillis();
Map<String, String> headers = response.headers;
long serverDate = 0;
long lastModified = 0;
long serverExpires = 0;
long softExpire = 0;
long finalExpire = 0;
long maxAge = 0;
long staleWhileRevalidate = 0;
boolean hasCacheControl = false;
boolean mustRevalidate = false;
String serverEtag;
String headerValue;
headerValue = headers.get("Date");
if (headerValue != null) {
serverDate = parseDateAsEpoch(headerValue);
}
// 获取响应体的Cache缓存策略.
headerValue = headers.get("Cache-Control");
if (headerValue != null) {
hasCacheControl = true;
String[] tokens = headerValue.split(",");
for (String token : tokens) {
token = token.trim();
if (token.equals("no-cache") || token.equals("no-store")) {
// no-cache|no-store代表服务器禁止客户端缓存,每次需要重新发送HTTP请求
return null;
} else if (token.startsWith("max-age=")) {
// 获取缓存的有效时间
try {
maxAge = Long.parseLong(token.substring(8));
} catch (Exception e) {
maxAge = 0;
}
} else if (token.startsWith("stale-while-revalidate=")) {
try {
staleWhileRevalidate = Long.parseLong(token.substring(23));
} catch (Exception e) {
staleWhileRevalidate = 0;
}
} else if (token.equals("must-revalidate") || token.equals("proxy-revalidate")) {
// 需要进行新鲜度验证
mustRevalidate = true;
}
}
}
// 获取服务器资源的过期时间
headerValue = headers.get("Expires");
if (headerValue != null) {
serverExpires = parseDateAsEpoch(headerValue);
}
// 获取服务器资源最后一次的修改时间
headerValue = headers.get("Last-Modified");
if (headerValue != null) {
lastModified = parseDateAsEpoch(headerValue);
}
// 获取服务器资源标识
serverEtag = headers.get("ETag");
// 计算缓存的ttl和softTtl
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;
}
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;
}
这里设计到缓存，就要先得到Http的cache-control的headervalue，如果是no-cahce||no-store就不需要再处理缓存，虽然on-cache在浏览器那边还是保存了请求的资源，但这里去没有处理。如果headervalue中有MaxAge,这个值是判断缓存存在的有效时间。如果headervalue中有stale-while-revalidate，这个值是缓存过期的可用时间，即使缓存过期，在stale-while-revalidate时间内依旧可用。如果headervalue中有must-revalidate就意味着
从必须再验证缓存的新鲜度，然后再用。
然后继续解析header与缓存有关的内容，如Expires（这是一个不推荐的标签），Last-Modified（最近被修改的时间),ETag（服务器资源标识）。
然后如果有缓存控制就计算缓存的TTL与SoftTTL，SoftTTL就是softExpire，其值就是maxAge + 当前时间，而TTL是finalTTL其值是 先判断是否过期就再验证，如果是的话，其值就是softExpire,如果不是的话，其值就是softExpire加上staleWhileRevalidate(缓存过期有效时间)。
如果没有缓存控制，softExpire = now + (serverExpires - serverDate);
所以，说回上面，CacheQueue中缓存的判断，isExpire就是判断finalTTL是否超过当前时间，而refreshNeeded则是判断softExpire是否超过当前时间。
