在[Android]Volley源码分析(四)请求队列中提及到:当新增一个消息请求时,如果使用缓存,则先将请求放入缓存队列,否则直接加入网络请求队列。首先我们看看缓存队列mCacheQueue的使用对象CacheDispatcher。通过类图,可以发现CacheDispatcher继承与Thread类,其主要的实现方法是run(),具体代码如下:
<span style="font-size:14px;"> @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 (request.isCanceled()) {
request.finish("cache-discard-canceled");
continue;
}
// 首先判断缓存是否存在,如果没有,则加入网络请求队列
Cache.Entry entry = mCache.get(request.getCacheKey());
if (entry == null) {
VolleyLog.d(" Cache miss; send off to the network dispatcher.");
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
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(
new NetworkResponse(entry.data, entry.responseHeaders));
request.addMarker("cache-hit-parsed");
if (!entry.refreshNeeded()) {
VolleyLog.d("unexpired cache hit. Just deliver the response.");
// 如果缓存没过期,则将缓存中的请求结果返回
mDelivery.postResponse(request, response);
} else {
VolleyLog.d("Soft-expired cache hit.eed 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;
}
continue;
}
}
}</span>
通过代码可以知道,
CacheDispatcher首先检查缓存里是否存在请求结果,如果没有则通过网络请求,返回请求结果。下面我们看看NetworkDispatcher的run()方法是如何实现消息派发的:
<span style="font-size:18px;"> </span><span style="font-size:14px;"> @Override
public void run() {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
Request<?> request;
while (true) {
try {
// 从队列里取出请求,这个方法是阻塞的,如果没有请求,会一直等待
request = mQueue.take();
} catch (InterruptedException e) {
// We may have been interrupted because it was time to quit.
if (mQuit) {
return;
}
continue;
}
try {
request.addMarker("network-queue-take");
// If the request was cancelled already, do not perform the
// network request.
if (request.isCanceled()) {
request.finish("network-discard-cancelled");
continue;
}
addTrafficStatsTag(request);
// 执行网络请求
VolleyLog.d("current thread:"+getId()+" start request.");
NetworkResponse networkResponse = mNetwork.performRequest(request);
request.addMarker("network-http-complete");
// If the server returned 304 AND we delivered a response already,
// we're done -- don't deliver a second identical response.
if (networkResponse.notModified && request.hasHadResponseDelivered()) {
request.finish("not-modified");
continue;
}
// 解析网络请求结果
Response<?> response = request.parseNetworkResponse(networkResponse);
request.addMarker("network-parse-complete");
// 如果需要缓存,加入缓存
// 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");
}
//返回请求和请求结果
request.markDelivered();
mDelivery.postResponse(request, response);
} catch (VolleyError volleyError) {
parseAndDeliverNetworkError(request, volleyError);
} catch (Exception e) {
VolleyLog.e(e, "Unhandled exception %s", e.toString());
mDelivery.postError(request, new VolleyError(e));
}
}
}</span>
通过代码可以看出,
NetworkDispatcher通过Network向网络发出请求,然后将请求结果解析,如果需要缓存则加入缓存,最好通过ResponseDelivery返回请求以及解析后的请求结果给主线程。
通过类图可以看出,ResponseDelivery是由ExecutorDelivery实现的,ExecutorDelivery通过主线程的handler返回消息结果:
<span style="font-size: 18px;"> </span><span style="font-size:14px;">public ExecutorDelivery(final Handler handler) {
// Make an Executor that just wraps the handler.
mResponsePoster = new Executor() {
@Override
public void execute(Runnable command) {
handler.post(command);
}
};
}
/**
* Creates a new response delivery interface, mockable version
* for testing.
* @param executor For running delivery tasks
*/
public ExecutorDelivery(Executor executor) {
mResponsePoster = executor;
}
@Override
public void postResponse(Request<?> request, Response<?> response) {
postResponse(request, response, null);
}
@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}</span>
具体是通过ResponseDeliveryRunnable的run()实现的:
public void run() {
// If this request has canceled, finish it and don't deliver.
if (mRequest.isCanceled()) {
mRequest.finish("canceled-at-delivery");
return;
}
// Deliver a normal response or error, depending.
if (mResponse.isSuccess()) {
mRequest.deliverResponse(mResponse.result);
} else {
mRequest.deliverError(mResponse.error);
}
// If this is an intermediate response, add a marker, otherwise we're done
// and the request can be finished.
if (mResponse.intermediate) {
mRequest.addMarker("intermediate-response");
} else {
mRequest.finish("done");
}
// If we have been provided a post-delivery runnable, run it.
if (mRunnable != null) {
mRunnable.run();
}
}
可以看出,消息返回后,执行Request的finish()方法。
Volley的消息分发流程到此结束了。