Volley是个轻量级的通信框架,对Android开发来说确实比较好用,扩展性也强。不过今天谈的不是它的应用,而是剖析它的一个问题,就是Volley使用缓存,则会响应3次。这篇文章的思路只讲最核心的代码,其他代码就不贴了,获取源码也简单的。
在Volley中有一个缓存线程,4个网络请求线程,分别为CacheDispatcher.java,NetworkDispatcher.java。
分析过程不按照调用顺序来讲,是从最重要的地方开始,然后再分析调用它的地方,这样带着问题来分析,可能更有意思。
在CacheDispatcher.java的run方法中,有如下代码:
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.
1 Cache.Entry entry = mCache.get(request.getCacheKey());
2 if (entry == null) {
request.addMarker("cache-miss");
// Cache miss; send off to the network dispatcher.
3 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");
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.
4 mDelivery.postResponse(request, response, new Runnable() {
@Override
public void run() {
try {
5 mNetworkQueue.put(request);
} catch (InterruptedException e) {
// Not much we can do about this.
}
}
});
6 mDelivery.postResponse(request, response);
有while(true),说明这个线程是一直运行着,在1处,从request中取出key对应的缓存Entry,key其实就是request的url,2处如果缓存为空,3处在将请求加入网络请求队列,continue,继续下一次循环(由NetworkDispatcher.java会处理这个请求)。这种情况不在讨论之内,在4处,mDelivery调用postResponse,看看里面怎么写的。mDelivery是ExecutorDelivery的实例。
@Override
public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
request.markDelivered();
request.addMarker("post-response");
1 mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
}
在1处,则看看mResponsePoster的定义。
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);
}
};
}
可以看到mResponsePoster所要执行的任务,执行hanlder.post(commnad)后,任务是在主线程执行的,看看command的实现代码,挑它的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()) {
1 mRequest.deliverResponse(mResponse.result);
} else {
2 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 {
3 mRequest.finish("done");
}
// If we have been provided a post-delivery runnable, run it.
if (mRunnable != null) {
mRunnable.run();
}
}
1处就是将结果返回,看看deliverResponse()的实现,继承Requst的类JsonRequest,看它的实现:
protected void deliverResponse(T response) {
1 mListener.onResponse(response);
}
1处这个mListener的类型是Response.Listener,正好是我们定义request的时候传进去的,如
request = new JsonPostRequest(IMConfig.mUserSummary, new Response.Listener<JSONObject>() {
@Override
public void onResponse(JSONObject jsonObject) {
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError volleyError) {
}
}, map);
这样流程完毕,就是响应了1次,第二次是怎么来的呢,回顾CacheDispatcher.java的5处,是将请求放到了网络请求队列中,网络线程NetworkDispatcher.java就会检测到这个请求,会执行网络操作,操作完成后,也会回到主线程响应,简要分析它的代码 run方法,如下
while (true) {
try {
// Take a request from the queue.
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);
// Perform the network 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;
}
// Parse the response here on the worker thread.
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) {
1 mCache.put(request.getCacheKey(), response.cacheEntry);
request.addMarker("network-cache-written");
}
// Post the response back.
request.markDelivered();
2 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));
}
}
可以看到又是个死循环,从而网络队列里只要有request,一定会被执行到,其他地方不看,就看2处,通过前面的分析,清楚postResponse的逻辑是将结果返回到主线程响应,这就是第二次。第三次就看CacheDispatcher.java的run方法的6处,又发现调用了一次postResponse(),又将结果返回到主线程响应,到这里共有3次响应了,至于google的这个volley为什么要做3次,也觉得困惑,个人觉得第三次响应是没必要的。前面的分析有很多细节之处没有分析到位,就如同前面所说,只取这个问题的最核心的地方,其他细节之处可以看源码。
在最新的Volley的版本中,已把这个问题修复了,CacheDispatcher.java代码如下:
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");
1 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;
}
continue;
}
}
看1处的代码,通过对实体判断需要更新的话,会再次请求网络,不更新的话,则直接响应。