Volley简单学习使用三——源码分析一（修改）

Volley                   ：Volley 对外暴露的 API，类中只有两个函数

                                通过 newRequestQueue(…) 函数新建并启动一个请求队列RequestQueue。

Request<T>          ：表示一个请求的抽象类。

                                StringRequest、JsonRequest、ImageRequest 都是它的子类，表示某种类型的请求。

                                也可自定义自己的Request

RequestQueue      ：表示请求队列，一个RequestQueue对象包含：

                               一个CacheDispatcher(用于处理走缓存请求的调度线程)、

                               一个NetworkDispatcher数组(默认数组大小为4，用于处理走网络请求的调度线程)，

                               一个ResponseDelivery(返回结果分发接口)，

                               在start() 函数启动时会创建启动CacheDispatcher和NetworkDispatchers。

CacheDispatcher   ：Cache层中的一个线程，用于调度处理缓存的请求。

                               启动后会不断从缓存请求队列中取请求处理，队列为空则等待，请求处理结束则将结果传递给ResponseDelivery去执行后续处理。

                               当结果未缓存过、缓存失效或缓存需要刷新的情况下，该请求都需要重新进入NetworkDispatcher去调度处理。

NetworkDispatcher：NetWork层中的一个线程，用于调度处理走网络的请求。

                                启动后会不断从网络请求队列中取请求处理，队列为空则等待，

                                请求处理结束则将结果传递给ResponseDelivery去执行后续处理，并判断结果是否要进行缓存。

ResponseDelivery ：返回结果分发接口，在创建RequestQueue对象时进行了初始化

                              在目前只有基于ExecutorDelivery的在入参 handler 对应线程内进行分发。

HttpStack             ：处理 Http 请求，返回请求结果。在newRequestQueue中被初始化。

                              目前 Volley 中有基于 HttpURLConnection 的HurlStack和 基于 Apache HttpClient 的HttpClientStack。

                              上一篇中已经对其如何根据Android版本进行选择做了解析。

Network               ：调用HttpStack处理请求，并将结果转换为可被ResponseDelivery处理的NetworkResponse。

                               在newRequestQueue中被初始化

Cache                   ：缓存请求结果，Volley 默认使用的是基于 sdcard 的DiskBasedCache。

                  NetworkDispatcher得到请求结果后判断是否需要存储在 Cache，CacheDispatcher会从 Cache 中取缓存结果。

下面附上每个类之间的关系图：

    /**
     * Starts the dispatchers in this queue.
     */
    publicvoid 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();
        }
    }

    /** Stops the cache and network dispatchers.*/
    public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (int i = 0; i < mDispatchers.length; i++) {
            if (mDispatchers[i] != null) {
                mDispatchers[i].quit();
            }
        }
    }

   /**
     * The set of all requests currently being processed by this RequestQueue. A Request
     * will be in this set if it is waiting in any queue or currently being processed by any dispatcher.
     */
    private final Set<Request> mCurrentRequests = new HashSet<Request>();
    
    /**
     * 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);  //见附I Request设置其对应的RequestQueue
        synchronized (mCurrentRequests) { //mCurrentRequests表示当前该RequestQueue持有的requests，由HashSet来保存
            mCurrentRequests.add(request);
        }
 
        // 为新添加的request进行一系列的初始化设置
        request.setSequence(getSequenceNumber());
        request.addMarker("add-to-queue");
 
        // 见附II 判断request是否允许缓存
        if (!request.shouldCache()) {
            mNetworkQueue.add(request);
            return request;
        }
 
        //request如果允许缓存 
        //Insert request into stage if there's already a request with the same cache key in flight.
        synchronized (mWaitingRequests) {  // 见附III
            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.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);
                mCacheQueue.add(request);
            }
            return request;
        }
    }

private final Set<Request<?>> mCurrentRequests = new HashSet<Request<?>>();

    /** The request queue this request is associated with. */
    private RequestQueue mRequestQueue;   
    /**
     * Associates this request with the given queue. The request queue will be notified when this
     * request has finished.
     */
    public void setRequestQueue(RequestQueue requestQueue) {
        mRequestQueue = requestQueue;
    }

    /** The queue of requests that are actually going out to the network. */
    private final PriorityBlockingQueue<Request> mNetworkQueue = new PriorityBlockingQueue<Request>();

    /**
     * Staging area for requests that already have a duplicate request in flight.
     * <ul>
     *     <li>containsKey(cacheKey) indicates that there is a request in flight for the given cache
     *          key.</li>
     *     <li>get(cacheKey) returns waiting requests for the given cache key. The in flight request
     *          is <em>not</em> contained in that list. Is null if no requests are staged.</li>
     * </ul>
     */
    private final Map<String, Queue<Request>> mWaitingRequests = new HashMap<String, Queue<Request>>();

mCacheQueue和

mNetworkQueue是想对应存在的：

mCacheQueue 放在缓存请求队列中的 Request，将通过缓存获取数据；

mNetworkQueue放在网络请求队列中的 Request，将通过网络获取数据。

private final PriorityBlockingQueue<Request<?>> mCacheQueue = new PriorityBlockingQueue<Request<?>>();
private final PriorityBlockingQueue<Request<?>> mNetworkQueue = new PriorityBlockingQueue<Request<?>>();