volley源码的简单分析（1）

最新推荐文章于 2022-02-13 12:19:44 发布

huidawoxiaozi

最新推荐文章于 2022-02-13 12:19:44 发布

阅读量277

点赞数 1

分类专栏： android

本文链接：https://blog.csdn.net/u012911421/article/details/52640039

版权

android 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

先看着句代码**RequestQueue queue =
Volley.newRequestQueue(MainActivity.this);**都干了什么。当版本大于9时会创建HurlStack，它主要是对HttpURLConnection请求的封装
。小于9创建HttpClientStack，它是对HttpClient的封装。BasicNetwork对HttpStack进行管理，由BasicNetwork真正的去处理网络请求.RequestQueue主要是对缓存（数据缓存和网络请求缓存）和网络请求进行管理。

    public static RequestQueue newRequestQueue(Context context, HttpStack stack, int maxDiskCacheBytes) {
        File cacheDir = new File(context.getCacheDir(), DEFAULT_CACHE_DIR);

        String userAgent = "volley/0";
        try {
            String packageName = context.getPackageName();
            PackageInfo info = context.getPackageManager().getPackageInfo(packageName, 0);
            userAgent = packageName + "/" + info.versionCode;
        } catch (NameNotFoundException e) {
        }

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

        RequestQueue queue;
        if (maxDiskCacheBytes <= -1)
        {
            // No maximum size specified
            queue = new RequestQueue(new DiskBasedCache(cacheDir), network);
        }
        else
        {
            // Disk cache size specified
            queue = new RequestQueue(new DiskBasedCache(cacheDir, maxDiskCacheBytes), network);
        }

        queue.start();

        return queue;
    }

从start()方法中可以看出，并没有采用线程池来管理线程，只是采用size为4的线程数组mCacheDispatcher来管理单个线程NetworkDispatcher，是一种生产-消费的模式。NetworkDispatcher真正用来处理网络请求

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

add()方法主要判断当前请求加入请求队列mCurrentRequests，当缓存不可用的时候把当前的请求加入网络请求队列mNetworkQueue，直接返回request对象。否则判断当前缓存是否可用，可用的话执行mWaitingRequests.put(cacheKey, stagedRequests);这句代码，意思是有一个请求正在用着，要排队等着处理，不可用时把这个请求加入缓存队列中。

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