Volley源码分析(一)RequestQueue分析

Volley源码分析

虽然在2017年，volley已是一个逐渐被淘汰的框架，但其代码短小精悍，网络架构设计巧妙，仍是有不少值得学习的地方。
第一篇文章，分析了请求队列的代码，请求队列也是咱们使用Volley的关键一步。
第二篇文章会分析Dispatcher

RequestQueue

建立RequestQueue对象的方式是采用以下的代码：

RequestQueue queue = Volley.newRequestQueue(getApplicationContext());

该队列是用来发起Http请求。主要看newRequestQueue方法
该方法的核心实现是2个参数的方法

newRequestQueue(Context context, HttpStack stack)

该方法作的事情以下：

1. 建立一个CacheDir目录
2. 建立一个userAgent，默认是volly/0，实际是包名 + 版本代码。若是出异常，userAgent就是默认值
3. 初始化stack,若是是Android2.3一下 就用HttpClientStack建立对象，HttpClientStack是用HttpClient实现的。若是是Android2.3以上，就用HurlStack建立对象。后面咱们在分析这个类的做用。
4. 用建立好的stack去初始化NetWork对象，即 Network network = new BasicNetwork(stack); 用建立好的CacheDir去初始化DiskBasedCache对象，从而完成RequestQueue对象的初始化，RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
5. 调用queue对象的start方法。

下面，咱们看一下HttpStack的做用，以及DiskBasedCache和NetWork的做用，最后看一下start方法作了什么。

HttpStack是一个接口，该接口只有两个实现类，一个是HttpClientStack,另外一个是HulStack。咱们先不看具体的实现类，只看接口方法的声明。

HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)
        throws IOException, AuthFailureError;

该方法的做用是用来真正进行网络请求的，具体用那种http实现类去请求，就分红了HttpClient以及HttpUrl。

再看NetWork接口，该接口只有一个实现类，BasicNetWork，咱们仍是先不看具体的实现类，只看接口的方法声明：

NetworkResponse performRequest(Request<?> request) throws VolleyError;

该方法的说明是执行一个指定的Request。

最后再看DiskBasedCache的功能。该类是Cache的一个具体的实现类，该类的功能是用缓存的文件存在硬盘中，默认的硬盘大小是5M。
上面的几个接口的功能都说完了，经过其实现类的对象最终构造了RequestQueue。接下来咱们看一下构造器方法的执行。

RequestQueue的成员变量以及方法

咱们先看一下RequestQueue的成员变量都有什么：

• mSequenceGenerator 该类型为AtomicInteger，其功能是统计请求的个数，采用原子类的整形。
• mWaitingRequests 该类型是一个HashMap，其功能是存储request,key是cachekey。存储的quest是重复的request。
• mCurrentRequests 该类型是一个HashSet，其功能是存储request，该request能被放入的条件是当前正在被分派或者在等待。
• mCacheQueue 该类型是PriorityBlockingQueue，其功能是存储缓存的队列。
• mNetworkQueue 该类型是PriorityBlockingQueue，其功能是正在进行工做的队列
• DEFAULT_NETWORK_THREAD_POOL_SIZE 默认的分派器的线程 初始值为4
• mCache 该类型是Cache 功能是存储响应报文的对象response
• mNetWork 该类型是NetWork 功能是进行网络请求。
• mDelivery 该类型是ResponseDelivery，其功能是分派response
• mDispatchers 该类型是NetworkDispatcher[] 其功能是NetWork分派器
• mCacheDispatcher 该类型是CacheDispatcher[] 其功能是Cache分派器

下面咱们继续看构造方法：

public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

不管几个参数的构造方法，最终都会执行这个。上面在 new RequestQueue中，咱们的传入的构造方法只有Cache和NetWork对象，这样的话，threadPoolSize默认就是4，而delivery就是 new ExecutorDelivery(new Handler(Looper.getMainLooper()))
关于这个ExecutorDelivery这个后面在分析。

下面，咱们主要看RequestQueue的几个关键方法：

• start
• stop
• cancel
• finsh
• add

stop方法

public void stop() {
        if (mCacheDispatcher != null) {
            mCacheDispatcher.quit();
        }
        for (final NetworkDispatcher mDispatcher : mDispatchers) {
            if (mDispatcher != null) {
                mDispatcher.quit();
            }
        }
    }

stop方法的所有代码很是少，主要的作的事情以下：

1. 若是CacheDispatcher不为空，则调用quit方法退出他。
2. 若是NetWorkDispatcher不为空，则调用quit方法退出他。

关键就在于quit方法。

quit方法的代码以下：

public void quit() {
        mQuit = true;
        interrupt();
    }

CacheDispatcher是继承与Thread。quit方法的做用是设置一个退出的标志位，而且调用interrupt方法，这样在run方法执行的过程当中，因为线程已经中断，会执行catch语句块的内容，检查标志位，直接return。

下面是去掉了与自身功能相关的代码之后，剩下的部分。能够看出是很标准的线程退出写法。
。

public void run() {
        //执行初始化的操做，省略掉
        while (true) {
            try {
                 //执行业务代码，省略掉
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
            }
        }
    }

stop的方法分析完毕

start方法

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方法比较简洁，所以我在这里放出所有的方法源码。start方法主要作了如下几件事情。

1. 调用stop方法中止了正在运行的dispatchers。
2. 建立CacheDispatcher，而且启动它。
3. 根据初始化的线程数量建立NetworkDispatcher，并启动他。

stop方法上面已经分析了，就不在说了，先调用stop的目的就是先中止已经启动的dispatcher。

建立CacheDispather，NetWorkDispatcher，他们其实就是一堆线程，调用他们的start方法。关于他们的分析，后面在具体介绍。

cancel方法

cancel方法其实是cancalAll方法，但实际上最终都会调用cancelAll(RequestFilter filter) filter的做用其实是过滤出要取消的request。而后调用request.cancel。
关于request类，这个放到后面的分析。

finish方法

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

finish方法是一个泛型方法，该finish方法执行了如下几个事情：

1. 从CurrentRequest中移除掉该request.
2. 调用finishListener
3. 判断该request是否须要缓存，对须要缓存的request，将其余放到CacheQueue。

从上面的成员变量说明上，能够看出CurrentRequst实际上存储正在分派或者执行的request,对于finish天然是从该队列中移除。

/** Callback interface for completed requests. */
    public interface RequestFinishedListener<T> {
        /** Called when a request has finished processing. */
        void onRequestFinished(Request<T> request);
    }

该接口的目的是提供一个request结束之后回调的接口。

判断request是否须要缓存，能够经过setShouldCache设置，而后从mWaitingReuqests中移除该key对应的队列，而后将队列加入cacheQueue。也就说，若是waitingQueue中还存在同样的request，则所有移除掉。

add方法

add方法是添加request的方法，其所有的代码以下：

public <T> Request<T> add(Request<T> request) {
        // Tag the request as belonging to this queue and add it to the set of current requests.
        request.setRequestQueue(this);
        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.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;
        }
    }

将request关联到当前的requestQueue，而后mCurrentRequeue添加添加该request,request设置加入队列的次序，判断该request是否须要缓存，若是不须要缓存，就直接加入netWorkQueue中，等待被执行。
若是须要缓存，就先判断该WaitingRequest中是否有该request，若是有就获得该cacheKey对应的队列，把该request加进去，若是没有，就建立一个stagedRequests，将它加进去。而后将stagedRequests放入WaitiingRequest中。若是没有cacheKey，waitingRequest就插入一个key为cacheKey，value为null的值进入，而后将request加入cacheQueue。

至此，RequestQueue的部分就分析完了，其主要的功能是根据传入的Request来决定将该Request加入到那个Queue中，而后在经过Dispatcher进行调度。