Volley框架的基本解读(五)

在之前四篇博客中，我们已经将RequestQueue中start方法中的网络请求这条主线完全解析了一遍，接下来我们看另一条缓存主线，CacheDispatcher的源码：

public class CacheDispatcher extends Thread

同NetworkDispatcher一样，CacheDispatcher同样是一个线程

public CacheDispatcher(            BlockingQueue<Request> cacheQueue, BlockingQueue<Request> networkQueue,            Cache cache, ResponseDelivery delivery) {        mCacheQueue = cacheQueue;        mNetworkQueue = networkQueue;        mCache = cache;        mDelivery = delivery;    }

里面也只有一个构造方法，四个参数分别是缓存队列，网络队列，缓存处理类，结果分发类，同样的在RequestQueue调用了它的start方法，因为是Thread所以我们看run方法：

@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.            // 从缓存队列中取出request                final Request request = mCacheQueue.take();                // 调试信息                request.addMarker("cache-queue-take");                // If the request has been canceled, don't bother dispatching it.                // 如果该request以取消，则中断任务                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解析，并输出调试日志                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.initialize方法里面看看，这里说一点Cache同Network一样是一个接口，里面的方法稍微多一点，我们来看具体子类实现，同样是在Volley.newRequestQueue中创建的：

RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);

接着看

public DiskBasedCache(File rootDirectory) {        this(rootDirectory, DEFAULT_DISK_USAGE_BYTES);    }

public DiskBasedCache(File rootDirectory, int maxCacheSizeInBytes) {        mRootDirectory = rootDirectory;        mMaxCacheSizeInBytes = maxCacheSizeInBytes;    }

rootDirectory是缓存径路，DEFAULT_DISK_USAGE_BYTES默认值是5 * 1024 * 1024，也就是5M，表示最大缓存容量。

我们来看看它的initialize方法：

/**     * Initializes the DiskBasedCache by scanning for all files currently in the     * specified root directory. Creates the root directory if necessary.     *      * 初始化缓存，将缓存文件全部读入内存中     */    @Override    public synchronized void initialize() {    // 如果文件不存在，说明无缓存        if (!mRootDirectory.exists()) {            if (!mRootDirectory.mkdirs()) {                VolleyLog.e("Unable to create cache dir %s", mRootDirectory.getAbsolutePath());            }            return;        }        // 获取缓存文件数组        File[] files = mRootDirectory.listFiles();        if (files == null) {            return;        }        for (File file : files) {            FileInputStream fis = null;            try {                fis = new FileInputStream(file);                CacheHeader entry = CacheHeader.readHeader(fis);                entry.size = file.length();                putEntry(entry.key, entry);            } catch (IOException e) {                if (file != null) {                   file.delete();                }            } finally {                try {                    if (fis != null) {                        fis.close();                    }                } catch (IOException ignored) { }            }        }    }

前面很简单，判断缓存路径是否存在，否创建缓存路径，如果创建失败，那么初始化也就失败了。

然后获取缓存路径下的所有缓存文件，用字节流读取解析，CacheHeader是DiskBasedCache中的静态内部类，里面定义了很多字段，比如size数据长度，key缓存的键，其实就是URL，还有serverDate服务器的返回时间等等，readHeader方法就是对读取缓存文件进行了封装，考虑到涉及到的方法太多，我就不一一贴出来了，得到了CacheHeader这个缓存实体，putEntry方法就是将它放入内存：

/**     * Puts the entry with the specified key into the cache.     * @param key The key to identify the entry by.     * @param entry The entry to cache.     *      * 将缓存读入内存     */    private void putEntry(String key, CacheHeader entry) {    // 如果内存中没有该缓存，累加当前缓存大小，如果存在，计算缓存容量差，再进行累计        if (!mEntries.containsKey(key)) {            mTotalSize += entry.size;        } else {            CacheHeader oldEntry = mEntries.get(key);            mTotalSize += (entry.size - oldEntry.size);        }        mEntries.put(key, entry);    }

mEntries是一个Map集合，定义在DiskBasedCache的成员变量中

/** Map of the Key, CacheHeader pairs 初始位16，扩展0.75倍，使用排序*/    private final Map<String, CacheHeader> mEntries =            new LinkedHashMap<String, CacheHeader>(16, .75f, true);

initialize方法我们分析完了，回过头继续看CacheDispatcher的run方法，同NetworkDispatcher一样的写法，后面也是一个while死循环，mCacheQueue同样是一个优先级队列，试图从队列中获取一个request，判断request是否取消，是结束该次请求，request.getCacheKey()返回的就是URL，试图从缓存中查找对应的缓存，如果找不到，扔进网络队列中，它就不管了，如果获取到的缓存已经过期，还是扔进网络队列，当个甩手掌柜，到这里可以确定缓存有效，封装成Response准备返回，下面这个!entry.refreshNeeded()对缓存过期的再次判断，是我也不太理解的地方，但代码是很清晰的，如果没有过期，分发结果，如果过期了，它依然会返回结果，但会向网络请求一次，也就是说，该request会得到两个response，一个是缓存的，一个是网络的。

到这里大家可能已经急不可待想揭开mDelivery的神秘面纱了，但我们下一篇再说，在CacheDispatcher还有一个我们熟悉的方法：

/**     * Forces this dispatcher to quit immediately.  If any requests are still in     * the queue, they are not guaranteed to be processed.     *      * 标记退出，并中断线程     */    public void quit() {        mQuit = true;        interrupt();    }

作用就不必我多说了吧，我们下篇博客再见！