Volley源码学习（一）：Volley类，RequestQueue类

一.volley的用途

主要用于网络操作，获取数据，并缓存到本地SD卡，有默认4个线程处理网络请求。

二.源码解析

1.volley类：获得RequestQueue,并start

public class Volley {

    /** Default on-disk cache directory. */
    private static final String DEFAULT_CACHE_DIR = "andbase";

    /**
     * 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 = null;
    	if(!AbFileUtil.isCanUseSD()){
    		cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);
		}else{
			cacheDir = new File(AbFileUtil.getCacheDownloadDir(context));
		}

        String userAgent = "andbase/0";
    	PackageInfo info = AbAppUtil.getPackageInfo(context);
        userAgent = info.packageName + "/" + info.versionCode;

        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);
<span style="white-space:pre">	</span>//获得requestQueue
        RequestQueue queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();

        return queue;
    }

volley主要方法newRequestQueue(Context,httpStack),context用于生成DiskBasedCache，stack用于生成network.DiskBasedCache是专门管理cache的put,get,将数据写到目标文件夹。network用于网络请求获得response.

注意：sdk>9,网络请求使用HurlStack,内部使用httpconnection。<9使用httpclientstack,内部使用httpclient。httpconnetion API少，bug少，更易扩展。

2.RequestQueue类：

控制中心，处理request,判断后交由CacheQueue或NetworkQueue处理，文件由Cache进行缓存，ResponseDelivery将response传递给request的listener.

主要方法：

方法：start():启动cacheDispatcher和默认4个NetworkDispatcher线程来自动处理request

方法:add(request):添加请求，内部逻辑判断后，将request交由CacheQueue或NetWorkQueue

流程：①mCurrentRequests.add(request)添加request→!request.shouldCache()，不需缓存，就添加到NetworkQueue→判断mWaitingRequests.containsKey(cacheKey)是，mWaitingRequests添加一个stageRequest→

否，mWaitingRequests添加cacheKey，表明正在处理request,同时CacheQueue添加request

方法：finish:结束时从mCurrentRequest里移除，并移除mWaitingRequest的request,如果mWaitingRequest的request不为null,添加到cache里。（为什么？request没处理完被结束掉，mCacheQueue可以继续处理？？）

    public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;       //用于put,get cache文件
        mNetwork = network;   //进行网络操作的类，需要传入url
        mDispatchers = new NetworkDispatcher[threadPoolSize];  //网络请求分发处理类，是个线程，
        mDelivery = delivery;       //将response post给request
    }

    public void start() {     //启动cacheDispatcher和默认4个NetworkDispatcher线程来自动处理request
        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();
        }
    }

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