/** * Called from {@link Request#finish(String)}, indicating that processing of the given request has * finished. * * <p>Releases waiting requests for <code>request.getCacheKey()</code> if <code> * request.shouldCache()</code>. * * <p>(1). 首先从正在进行中请求集合mCurrentRequests中移除该请求。 (2). * 然后查找请求等待集合mWaitingRequests中是否存在等待的请求,如果存在,则将等待队列移除, * 并将等待队列所有的请求添加到缓存请求队列中,让缓存请求处理线程CacheDispatcher自动处理。 */ <T> void finish(Request<T> request) { // Remove from the set of requests currently being processed. synchronized (mCurrentRequests) { mCurrentRequests.remove(request); } synchronized (mFinishedListeners) { for (RequestFinishedListener<T> listener : mFinishedListeners) { listener.onRequestFinished(request); } } if (request.shouldCache()) { synchronized (mWaitingRequests) { String cacheKey = request.getCacheKey(); Queue<Request<?>> waitingRequests = mWaitingRequests.remove(cacheKey); if (waitingRequests != null) { if (VolleyLog.DEBUG) { 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); } } } }
@Before public void setUp() throws Exception { initMocks(this); dispatcher = new SyncDispatcher(cache, mockNetwork); Response response = Response.success(null, cacheEntry); when(cache.get(anyString())).thenReturn(cacheEntry); when(request.parseNetworkResponse(any(NetworkResponse.class))).thenReturn(response); when(request.getCacheKey()).thenReturn("test-cache-key"); }
/** * Adds a Request to the dispatch queue. * * @param request The request to service * @return The passed-in request */ 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); // Rewrite the url, in case of GET requests if (mUrlRewriter != null) { request.setUrl(mUrlRewriter.rewriteUrl(request)); } 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; } }
public static <T> T getCacheFile(InputBase input, Class<T> clazz) { Cache cache = requestQueue.getCache(); Request<T> request = new GsonRequest<T>(input.method(), input.toString(), "", clazz, null, null, null, null); Cache.Entry entry = cache.get(request.getCacheKey()); if (entry != null) { try { String json = new String(entry.data, "UTF-8"); if (clazz == String.class) { return (T) json; } // File类型写文件后返回file对象 else if (clazz == File.class) { String fileName = TextUtil.md5(input.toString()); File outFile = new File(DirectoryManager.getDirectory(DirectoryManager.DIR.DATA), fileName); FileUtils.writeFile(outFile.getAbsolutePath(), entry.data); return (T) outFile; } // 替换服务端可能返回的错误的data格式 json = json.replace("\"data\":[]", "\"data\":{}"); // 服务器返回errNo=0 if (json.matches(ERROR_NO_0_EXPRESSION)) { T data; JSONObject jsonObject = new JSONObject(json); json = jsonObject.getString("data"); // 其他属于Gson请求,解析对象返回 Gson gson = GsonUtil.createBuilder(); data = (T) gson.fromJson(json, clazz); return data; } // 服务器返回errNo != 0 else { return null; } } catch (Exception e) { return null; } } return null; }
@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. if (mCache != null) 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"); mDelivery.postPreExecute(request); // If the request has been canceled, don't bother dispatching it. if (request.isCanceled()) { mDelivery.postCancel(request); mDelivery.postFinish(request); request.finish("cache-discard-canceled"); continue; } // Attempt to retrieve this item from cache. Cache.Entry entry = mCache != null ? mCache.get(request.getCacheKey()) : null; if (entry == null) { request.addMarker("cache-miss"); // Cache miss; send off to the network dispatcher. mNetworkQueue.put(request); mDelivery.postNetworking(request); continue; } // If it is completely expired, just send it to the network. if (entry.isExpired()) { request.addMarker("cache-hit-expired"); mNetworkQueue.put(request); mDelivery.postNetworking(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, entry.charset)); request.addMarker("cache-hit-parsed"); mDelivery.postUsedCache(request); 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"); // 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; } } }
public static <T> void removeCacheFile(InputBase input, Class<T> clazz) { Cache cache = requestQueue.getCache(); Request<T> request = new GsonRequest<T>(input.method(), input.toString(), "", clazz, null, null, null, null); cache.remove(request.getCacheKey()); }
@Override public void run() { Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); Request request; 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; } // Tag the request (if API >= 14) if (Build.VERSION.SDK_INT >= 14) { TrafficStats.setThreadStatsTag(request.getTrafficStatsTag()); } // 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) { mCache.put(request.getCacheKey(), response.cacheEntry); request.addMarker("network-cache-written"); } // Post the response back. 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)); } } }