Volley源码分析之流程和缓存

Volley源码分析之流程和缓存

Volley演讲时配图

前言

Android一开始提供了HttpURLConnection和HttpClient两种方式请求网络，但是这两种控制粒度太细，需要自己做很多操作，同时也导致了需要写很多的重复代码。为此，2013年Google推出Volley网络请求框架，基于此框架，开发者只需设置请求url，传递参数和请求成功或失败的回调的方法即可，大大简化了网络请求；虽然现在Okhttp很流行，但Volley的源码非常值得学习；

Volley官方介绍文档(需翻墙)

使用

可分为三个步骤，简称三部走：

  1. 创建RequestQueue实例
  2. 创建StringRequest实例
  3. 调用RequestQueue实例方法add将request作为参数传入

StringRequest中并没有提供设置POST参数的方法，但是当发出POST请求的时候，Volley会尝试调StringRequest的父类——Request中的getParams()方法来获取POST参数，那么解决方法自然也就有了，我们只需要在StringRequest的匿名类中重写getParams()方法，在这里设置POST参数就可以了。示范代码如下：

String requestUrl = "http://yourapi";//建立请求的api的URL；

Response.Listener successListener = new Response.Listener<String>() {//成功回调
   @Override
   public void onResponse(String response) {
       Log.d("TAG", response);
   }
};

Response.ErrorListener errorListener = new Response.ErrorListener() {//失败回调
   @Override
   public void onErrorResponse(VolleyError error) {
       Log.e("TAG", error.getMessage(), error);
   }
};

StringRequest stringRequest = new StringRequest(Request.Method.POST, requestUrl,  successListener, errorListener) {
   @Override
   protected Map<String, String> getParams() throws AuthFailureError {
       //重写getParams方法传POST请求参数
       Map<String, String> map = new HashMap<String, String>();
       map.put("phone", "phone num");
       map.put("passwd", "passwd");
       return map;
   }
};

Volley.newRequestQueue(mContext).add(stringRequest);//创建newRequestQueue并传入参数

请求成功后，Logcat中会打印出服务器返回的信息；

源码分析

Volley适合通信频繁及数据量少的应用，大多展示类的App都适用；不适合繁重的下载或者流的操作，因为Volley会把解析到的响应数据保持在内存中；

首先从我们一开始的三部走的第一步开始，创建RequestQueue实例，代码语句

Volley.newRequestQueue(mContext)

跟进代码查看

public static RequestQueue newRequestQueue(Context context) {
    return newRequestQueue(context, null);
}

然后调用了两个参数的newRequestQueue方法，默认第二个参数HttpStack为null；

/**
 * Creates a default instance of the worker pool and calls {@link RequestQueue#start()} on it.
 *
 * @param context A {@link Context} to use for creating the cache dir.
 * @param stack An {@link HttpStack} to use for the network, or null for default.
 * @return A started {@link RequestQueue} instance.
 */
public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
    File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);//缓存目录

    String userAgent = "volley/0";
    try {
        String packageName = context.getPackageName();
        PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
        userAgent = packageName + "/" + info.versionCode;
    } catch (NameNotFoundException e) {
    }

    if (stack == null) {
        if (Build.VERSION.SDK_INT >= 9) {//根据系统版本号判断适用哪个请求方式
            stack = new HurlStack();
        } else {
            // Prior to Gingerbread, HttpUrlConnection was unreliable.
            // See: http://android-developers.blogspot.com/2011/09/androids-http-clients.html
            stack = new HttpClientStack(AndroidHttpClient.newInstance(userAgent));
        }
    }

    Network network = new BasicNetwork(stack);

    RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);//进入DiskBasedCache构造方法可知，此处设置缓存目录，以及设定了一个默认5M的缓存大小；
    queue.start();

    return queue;
}

HttpStack有实现两个类：HttpClientStack和HurlStack，都实现了performRequest方法，主要的作用是执行网络请求操作并获取返回结果；HttpClientStack使用了HttpClient进行网络通信，而HttpStack是使用HttpURLConnection；当系统版本小于9时使用HttpClientStack，反之使用HurlStack；这个判断主要是因为系统版本小于9时HttpURLConnection有bug，调用 close() 函数会影响连接池，导致连接复用失效;稳定性不如HttpClient稳定；而9之后系统作了修改，默认开启了 gzip 压缩，提高了 HTTPS 的性能，HttpURLConnection成了最佳选择；郭霖文章给出的原因

最后创建了RequestQueue，调用了start方法并返回RequestQueue实例；注意，RequestQueue的创建方法中我们可以看到，自己可以自定义RequestQueue，配置缓存目录，及缓存的大小；然后调用了RequestQueue的start方法

/**
 * Starts the dispatchers in this queue.
 */
public void start() {
    stop();  // Make sure any currently running dispatchers are stopped.
    // Create the cache dispatcher and start it.
    mCacheDispatcher = new CacheDispatcher(mCacheQueue, mNetworkQueue, mCache, mDelivery);
    mCacheDispatcher.start();

    // Create network dispatchers (and corresponding threads) up to the pool size.
    for (int i = 0; i < mDispatchers.length; i++) {
        NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                mCache, mDelivery);
        mDispatchers[i] = networkDispatcher;
        networkDispatcher.start();
    }
}

start方法主要创建了CacheDispatcher和NetworkDispatcher，并调用了对应的start方法；CacheDispatcher负责处理调度走缓存逻辑的请求，而NetworkDispatcher则是处理调度走网络的请求；一看start方法可以推测这两个类为Thread的子类，进入看果然是继承了Thread

public class CacheDispatcher extends Thread{
  
}

for循环默认创建4个NetworkDispatcher线程并开启，也就是说当Volley.newRequstQueue这句代码执行时，就创建了5个线程在不断运行，不断阻塞内部的请求队列知道请求的添加才开始下面的处理逻辑；

Volley.newRequstQueue创建完RequestQueue后，到了三步走的第三部，调用add方法把Request插入RequestQueue中

public Request add(Request request) {
 
 /*
   ...
   ...隐藏部分代码
   ...*/
    // If the request is uncacheable, skip the cache queue and go straight to the network.
   //判断request是否需要缓存，若不需要缓存则加入mNetworkQueue中，默认Request都需要缓存，       //setShouldCache可改变设置
    if (!request.shouldCache()) {
        mNetworkQueue.add(request);
        return request;
    }

    /*
   ...
   ...隐藏部分代码
   ...*/
  
    mWaitingRequests.put(cacheKey, null);
    mCacheQueue.add(request);//默认的request都加入到mCacheQueue
       
        return request;
    }
}

默认添加Request都会添加到mCacheQueue，缓存调度会不断轮询此队列；上面说到创建了RequestQueue后会默认开启5个线程，其中包括了缓存线程CacheDispatcher，现在看下CacheDispatcher的run方法

 @Override
    public void run() {
        /*
        ...隐藏部分代码
        */
           
                final Request request = mCacheQueue.take();//获取队列头部元素，若为空则一直阻塞，采用了BlockingQueue
                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.
                  //若过期，则添加到NetworkQueue中执行网络请求
                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 {
                  
                    // 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;
            }
        }
    }

可以看到开启线程后会一直阻塞直到获取缓存队列中插入的数据，阻塞队列使用了BlockingQueue，可另外了解；获取后查找缓存中是否有response，若response过期或需要刷新则会向mNetworkQueue中插入，走网络请求，反之则使用缓存中的response；若缓存可用便调用request的parseNetworkResponse解析数据，然后就是调用mDelivery.postResponse回调；mDelivery默认的实现是创建RequestQueue时候创建的

public RequestQueue(Cache cache, Network network, int threadPoolSize) {
    this(cache, network, threadPoolSize,
            new ExecutorDelivery(new Handler(Looper.getMainLooper())));
}

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

mDelivery.postResponse最终会调用ExecutorDelivery的execute方法，其传入的参数ResponseDeliveryRunnable，最终回调用handler的post方法把线程切换到主线程；ResponseDeliveryRunnable的run方法执行在主线程，如下：

public void run() {
    /*
    隐藏部分代码
    */
    // Deliver a normal response or error, depending.
    if (mResponse.isSuccess()) {
        mRequest.deliverResponse(mResponse.result);//回调到我们一开始创建的Listenner回调中
    } 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) {//响应需要刷新的时候为true
        mRequest.addMarker("intermediate-response");
    } else {
        mRequest.finish("done");
    }

    // If we have been provided a post-delivery runnable, run it.
    if (mRunnable != null) {
        mRunnable.run();
    }

可以看到若成功了则调用mRequest.deliverResponse(mResponse.result);这句代码，而deliverResponse则调用了我们一开始创建的StringRequest代码的Response.Listener的onResponse，我们便可以在这里处理返回来的响应并更新View;

现在看下当没有缓存或缓存实效时，使用网络获取响应的NetworkDispatcher,看下run方法：

@Override
public void run() {
    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
    Request request;
    while (true) {
        try {
            // Take a request from the queue.
            request = mQueue.take();//从Volley中创建RequestQueue后调用start方法中，同用一个队列传进构造方法可知：mQueue和刚才CacheDispatcher的mNetworkQueue是同一个队列，
        } catch (InterruptedException e) {
            // We may have been interrupted because it was time to quit.
            if (mQuit) {
                return;
            }
            continue;
        }

            // Perform the network request.
       NetworkResponse networkResponse = mNetwork.performRequest(request);//网络请求，实际上mNetwork的实现是BasicNetwork
       request.addMarker("network-http-complete");

     /*
     隐藏部分代码
     */
            // 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);
         /*
     隐藏部分代码
     */
    }
}

mNetwork.performRequest这句代码实现了请求代码，mNetwork的唯一实现为BasicNetwork，其performRequest方法主要根据HttpStack来执行网络请求并构造NetworkResponse返回；然后就是调用mDelivery.postResponse(request, response)方法回调，跟CacheDispatcher一样的流程了；

Volley.newRequestQueue(mContext).add(stringRequest)

到此，这句代码的流程完全走了一遍；总结一下：调用newRequestQueue创建了RequestQueue，同时开启了CacheDispatcher和NetworkDispatcher 5个线程不断阻塞轮询，当调用add方法时，会先在缓存队列mCacheQueue中插入request，此时缓存线程CacheDispatcher先查找缓存中是否有该request的响应缓存，若有且没有过期，且不需要刷新操作，则request自身的parseNetworkResponse方法解析成response且回调给主线程自己创建request的Response.Listener中的onResponse，若过期，没有缓存或需要刷新，则添加到mNetworkQueue中，NetworkDispatcher轮询获取request后，根据系统版本使用HttpClient或HttpURLConnection执行网络请求，得到响应后解析并回调给主线程，若request需要缓存且响应不为null，则存入响应缓存中；

流程图总结如下：

Volley原理图

缓存策略

  • request的缓存

    ​

现在我们从缓存的角度分析下源码，当调用Volley.newRequestQueue(mContext).add(stringRequest)时，我们进入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);//把request与当前RequestQueue建立联系
    synchronized (mCurrentRequests) {
        mCurrentRequests.add(request);//存放所有的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()) {//是否应该缓存，默认所有request都缓存
        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)) {//当前add的request是否已经有相同的请求，若请求没有完成（成功或者失败），则会一直存在mWaitingRequest中
            // 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);//创建一个队列并添加request
            mWaitingRequests.put(cacheKey, stagedRequests);//缓存含request的队列
            if (VolleyLog.DEBUG) {
                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);//如果request没有则存入map中
            mCacheQueue.add(request);
        }
        return request;
    }
}

当add方法调用时，会判断mWaitingRequests是否包含cacheKey，假设第一个request请求mWaitingRequests不包含，则缓存cacheKey,键值为null，同时添加入缓存队列。当第一个request还在请求中，第二个和第三个相同的request这时添加进来，则走进入逻辑新建一个队列并加入两个request，和cacheKey缓存进mWaitingRequests的map中，注意此时缓存的都是request，当第一个request请求完成后会回调request的finish方法

void finish(final String tag) {
    if (mRequestQueue != null) {
        mRequestQueue.finish(this);//调用RequestQueue的finish方法
    }
   /*
   隐藏部分代码
   *／
}

而request的finish方法会调用RequestQueue的finish方法

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);//移除该request的cacheKey,并得到缓存时创建的request队列
            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);//若缓存起来的队列不为空，把里面的request全部添加到缓存队列；
            }
        }
    }
}

当waitingRequests中的request添加到缓存队列后，又进入到CacheDispatcher的调度线程中了

  • CacheDispatcher里的缓存

又从CacheDispatcher的run分析，这次是从缓存角度；主要有三点

  1. 没有缓存，添加到网络请求队列
  2. 缓存过期，添加到网络请求队列
  3. 缓存需要刷新，先回调数据给用户，再添加请求到网络请求队列
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()) {//不需要刷新，回调给用户设置的listener
                // 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;//在需要刷新时置为true，在mDelivery.postResponse后，会调用ResponseDeliveryRunnable的run方法，其中中有个判断决定是添加信息或者调用request的finish方法

                // 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;
        }
    }
}

注意这里当需要刷新数据的时候，会先回调用户设置的listener，然后再去发起请求，若数据有变化会再次回调，所以这种情况会回调用户设置的listener两次

  • NetworkDispatcher的缓存

请求前添加和cache相关的headers

private void addCacheHeaders(Map<String, String> headers, Cache.Entry entry) {
    // If there's no cache entry, we're done.
    if (entry == null) {
        return;
    }

    if (entry.etag != null) {
        headers.put("If-None-Match", entry.etag);
    }

    if (entry.serverDate > 0) {
        Date refTime = new Date(entry.serverDate);
        headers.put("If-Modified-Since", DateUtils.formatDate(refTime));
    }
}

request的字段含义：

If-None-Match：存文件的Etag(Hash)值，与服务器回应的Etag比较判断是否改变

If-Modified-Since：缓存文件的最后修改时间

当网络请求完成后，调用了request中的parseNetworkResponse方法，用我们一开始的StringRequest来分析下。

protected Response<String> parseNetworkResponse(NetworkResponse response) {
    String parsed;
    try {
        parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
    } catch (UnsupportedEncodingException e) {
        parsed = new String(response.data);
    }
    return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));
}

此时又调用了HttpHeaderParser.parseCacheHeaders(response)来构建Cache.Entry对象,代码就不放了，主要是用response.headers中的Date，Cache-Control，Expires，ETag来构建对象，然后若request需要缓存及响应不为空则放进响应缓存中

response字段含义：

Cache-Control:告诉所有的缓存机制是否可以缓存及哪种类型

Expires：响应过期的日期和时间

Last-Modified：请求资源的最后修改时间

ETag：请求变量的实体标签的当前值

NetworkDispatcher

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

存入缓存的mCache的实现是DiskBasedCache，是不是有点熟悉，没错，就是我们一开始Volley.newRequestQueue中创建RequestQueue中的一个参数，我们看下DiskBasedCache的put方法

public synchronized void put(String key, Entry entry) {
   pruneIfNeeded(entry.data.length);//put之前先修正大小，避免超出限定的缓存大小
   File file = getFileForKey(key);
   try {
       FileOutputStream fos = new FileOutputStream(file);
       CacheHeader e = new CacheHeader(key, entry);
       e.writeHeader(fos);
       fos.write(entry.data);
       fos.close();
       putEntry(key, e);
       return;
   } catch (IOException e) {
   }
   boolean deleted = file.delete();//try出错时会把file给delete
   if (!deleted) {
       VolleyLog.d("Could not clean up file %s", file.getAbsolutePath());
   }
}

进入pruneIfNeeded方法

private void pruneIfNeeded(int neededSpace) {
    if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes) {
        return;
    }
    if (VolleyLog.DEBUG) {
        VolleyLog.v("Pruning old cache entries.");
    }

    long before = mTotalSize;
    int prunedFiles = 0;
    long startTime = SystemClock.elapsedRealtime();

    Iterator<Map.Entry<String, CacheHeader>> iterator = mEntries.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, CacheHeader> entry = iterator.next();
        CacheHeader e = entry.getValue();
        boolean deleted = getFileForKey(e.key).delete();
        if (deleted) {
            mTotalSize -= e.size;
        } else {
           VolleyLog.d("Could not delete cache entry for key=%s, filename=%s",
                   e.key, getFilenameForKey(e.key));
        }
        iterator.remove();
        prunedFiles++;

        if ((mTotalSize + neededSpace) < mMaxCacheSizeInBytes * HYSTERESIS_FACTOR) {
            break;
        }
    }

    if (VolleyLog.DEBUG) {
        VolleyLog.v("pruned %d files, %d bytes, %d ms",
                prunedFiles, (mTotalSize - before), SystemClock.elapsedRealtime() - startTime);
    }
}

传入需要插入数据的大小参数neededSpace和当前缓存文件总大小的记录mTotalSize计算出是否超出了设定的缓存大小，若超出则获取CacheHeader列表；CacheHeader里包含缓存文件大小等信息，遍历CacheHeader列表删除缓存，直到小于设定缓存的0.9倍，为什么是这个数？猜测是个缓存过大的标记，同时可以留有一定可缓存空间；

  • 如果让你去设计Volley的缓存功能，你要如何增大它的命中率？

    可以知道，在pruneIfNeeded中删除缓存时，并没有判断缓存是否过期，只是遍历来删除，很大程度上会误删刚缓存下来的数据，而过期数据却仍然存在；所以可以在删除前进行一次过期缓存的清除，然后再使用Lru算法清除最近最久未使用的缓存；

总结一下缓存方面的流程：当从RequestQueue中add的时候会判断request是否可以缓存，若不可以则添加到网络队列；否则添加到缓存队列；进入缓存队列后，CacheDispatcher中不断轮询取出缓存队列中的request，然后判断该request是否已经缓存了响应，响应是否过期，响应是否需要刷新；若request取消、没有缓存响应、过期或需要刷新，则添加request到网络队列；NetworkDispatcher也不断的轮询，取出添加到网络请求队列的request，用BasicNetwork请求网络，请求前添加headers相关的信息，请求返回的响应会被HttpHeaderParser的parseCacheHeaders解析成Cache.Entry对象，若此时的request能缓存且响应不为null，则添加到响应缓存中；

注：才疏学浅，如有有写错，理解错的地方麻烦指出更正下，非常感谢！

相关文章的引用

Volley的缓存策略

Android Volley完全解析(四)，带你从源码的角度理解Volley

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 216,240评论 6赞 498
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,328评论 3赞 392
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 162,182评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,121评论 1赞 292
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,135评论 6赞 388
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,093评论 1赞 295
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,013评论 3赞 417
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,854评论 0赞 273
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,295评论 1赞 310
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,513评论 2赞 332
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,678评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,398评论 5赞 343
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,989评论 3赞 325
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,636评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,801评论 1赞 268
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,657评论 2赞 368
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,558评论 2赞 352

推荐阅读更多精彩内容