Volley源码(二)--考虑缓存

在上一篇文章中Volley源码(一)不考虑缓存,以StringRequest为例,讲解了发送不缓存的post请求。这次主要讲解,发送缓存的get请求。为什么这么说。直接翻daima

 if (!request.shouldCache()) {            mNetworkQueue.add(request);            return request;  }

public final boolean shouldCache() {                //Allow caching only if method is a GET request        if(mMethod == Method.GET) {            return mShouldCache & true;        }        return false;    }

mShouldCache默认为true。所以,在shouldCache方法中,GET请求的话就return true(缓存),POST请求的话就return false(不缓存)。接下来来看看有缓存的GET请求有哪些地方不一样
1.RequestQueue的add方法

public Request add(Request request) {        // Tag the request as belonging to this queue and add it to the set of current requests.        request.setRequestQueue(this);        synchronized (mCurrentRequests) {            mCurrentRequests.add(request);        }        // Process requests in the order they are added.        request.setSequence(getSequenceNumber());        request.addMarker("add-to-queue");        // If the request is uncacheable, skip the cache queue and go straight to the network.        if (!request.shouldCache()) {            mNetworkQueue.add(request);            return request;        }        // Insert request into stage if there's already a request with the same cache key in flight.        synchronized (mWaitingRequests) {            String cacheKey = request.getCacheKey();            if (mWaitingRequests.containsKey(cacheKey)) {                // There is already a request in flight. Queue up.                Queue<Request> stagedRequests = mWaitingRequests.get(cacheKey);                if (stagedRequests == null) {                    stagedRequests = new LinkedList<Request>();                }                stagedRequests.add(request);                mWaitingRequests.put(cacheKey, stagedRequests);                if (VolleyLog.sDebug) {                    VolleyLog.v("Request for cacheKey=%s is in flight, putting on hold.", cacheKey);                }            } else {                // Insert 'null' queue for this cacheKey, indicating there is now a request in                // flight.                mWaitingRequests.put(cacheKey, null);                mCacheQueue.add(request);            }            return request;        }    }

上篇文章中,因为不需要缓存,所以在

if (!request.shouldCache()) {            mNetworkQueue.add(request);            return request;}

这里直接return了,这次是GET请求，需要缓存,所以if代码块里面的代码不会被执行到，继续往下走,先拿取request的cacheKey(点进去自己看看,其实就是url)。看mWaitingRequests是否包含这个url。mWaitingRequests是一个HashMap,key是这个请求的url,value是同样请求url的Request的链表。

mWaitingRequests包含这个url的话，就将这个url的请求加到此url对应的LinkedList中去，不包含的话，将此url加到mWaitingRequests(对应的value是null)和mCacheQueue中。

mWaitingRequests包含这个url的话说明这个request还没请求完毕，因为在RequestQueue的finish方法中有从mWaitingRequests中remove这个request,这个finish方法只有请求执行完毕才会被调用(参考NetworkDispatcher的run方法)。

void finish(Request request) {        // Remove from the set of requests currently being processed.        synchronized (mCurrentRequests) {            mCurrentRequests.remove(request);        }        if (request.shouldCache()) {            synchronized (mWaitingRequests) {                String cacheKey = request.getCacheKey();                Queue<Request> waitingRequests = mWaitingRequests.remove(cacheKey);                if (waitingRequests != null) {                    if (VolleyLog.sDebug) {                        VolleyLog.v("Releasing %d waiting requests for cacheKey=%s.",                                waitingRequests.size(), cacheKey);                    }                    // Process all queued up requests. They won't be considered as in flight, but                    // that's not a problem as the cache has been primed by 'request'.                    mCacheQueue.addAll(waitingRequests);                }            }        }    }

2.从缓存队列中取数据

数据加到mCacheQueue后,CacheDispatcher中的run方法就能取到数据啦

public void run() {        if (VolleyLog.sDebug) 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;                }                continue;            }        }    }

先不管mCache是什么(肯定提供了get和put方法,用来缓存的嘛，肯定有存有取)

首先从mCacheQueue取到之前add进去的request,再从缓存中拿数据(缓存用到的key还是url)，

Cache.Entry entry = mCache.get(request.getCacheKey());

再对entry做一系列判断，entry为空(表明之前没有缓存过)，缓存过期了(entry.isExpired),把请求加到mNetworkDispatcher(等于把请求丢到mNetworkDispatcher里啦)。NetworkDispatcher的run方法中，肯定有对此请求有做缓存

if (request.shouldCache() && response.cacheEntry != null) {                    mCache.put(request.getCacheKey(), response.cacheEntry);                    request.addMarker("network-cache-written");}

看到了吧，还是通过mCache缓存该请求。另一方面，如果entry不为空(表明之前有缓存过)，或者缓存没有过期。该怎么请求还是怎么请求，只是多一个处理，就是该缓存是否需要更新一下

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.                            }                        }                    }); }

可以看到，虽然这个类叫CacheDispatcher，实际上，缓存的操作都在NetworkDispatcher里进行的，entry需要刷新的话，将entry设置给request,然后post一个ruannable(为什么不直接加到mNetworkQueue,非要post里面加到mNetworkQueue?因为NetworkDispatcher有用到缓存，这样做可以确保将entry设置给request后,NetworkDispatcher才取到request的)