Volley框架解读（二）

Volley.java中的newRequestQueue方法中有三个非常重要的类，今天先讲解RequestQueue类，它是框架的核心。

• RequestQueue

这个类在请求队列中默认使用的构造方法为：

public RequestQueue(Cache cache, Network network) {
        this(cache, network, DEFAULT_NETWORK_THREAD_POOL_SIZE);    
}

Cache对象是new DiskBasedCache(cacheDir)，network是Network network = new BasicNetwork(stack);DEFAULT_NETWORK_THREAD_POOL_SIZE默认值为4，也就是网络任务分配的最大线程数是4，对于一般的app来说足以。初始化完毕以后运行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();
        }
    }

首先stop，里边是停止缓存的dispatcher，然后遍历4个网络线程的dispatcher，并且停止他们。stop完毕，新建CacheDispatcher对象，传入4个参数，mCacheQueue，mNetworkQueue是声明的PriorityBlockingQueue对象，mCache是实现了Cache接口的对象，mDelivery是获取内容的反馈对象。接着根据dispatcher的数量，初始化网络工作线程对象。每个线程管理对象都传入mNetworkQueue, mNetwork,mCache, mDelivery四个对象。这两天有两个重要的对象，分别是CacheDispatcher和NetworkDispatcher对象。

• CacheDispatcher

这个对象的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();

首先设置线程的优先级，然后初始化cache对象

    @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) { }
            }
        }
    }

1. 如果不存在缓存目录就是创建目录，并返回。
2. 如果存在缓存目录，列出所有文件，如果文件为空，则返回。
3. 遍历所有的缓存文件，读取文件头信息，这个时候实体信息没有设置到entry中

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

从缓存队列中取出请求对象，如果请求已经取消，直接跳出本次循环。否则，根据键值，获取entry实体对象。如果没有缓存这个对象就会交给网络任务队列处理。实体对象如果过期了，把实体对象缓存，同时把请求加入请求队列中。

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

如果实体对象不需要刷新，则把请求中缓存的应用结果返回。否则把返回设置中间返回值（稍后会有新的返回结果），然后把请求放入网络请求队列。