深入了解Volley如何执行一个Request的流程

深入了解Volley如何执行一个Request的流程

Volley主要类构成

Volley: 框架同名类，负责创建RequestQueue对象 Request:代表一个网络请求的抽象类，具体实现子类有(StringRequest,JsonRequest,ImageRequest)，需添加到RequestQueue中操作。包含了url,请求方法，请求Header,请求Body,请求的优先等级信息。 RequestQueue:核心类，负责维护所有的Request对象，完成请求操作。该类中有两个基于优先级的Request队列mCacheQueue,mNetWorkQueue(PriorityBlockingQueue),分别是缓存请求队列，网络请求队列。该数据结构支持对添加进来的Request进行优先级排序（所以可以将理财列表内的请求设置成优先级最高），还有一个mCurrentRequest(SetRequest类型，用来维护一个已经加入到Request中，并且还没有完成的请求；还有一个等待请求的集合，mWaitingQueue,如果一个请求正在处理并且可以被缓存，那么后续的相同的url的请求，将被放入到等待队列。 CacheDispatcher:缓存调度线程类，不停的从缓存队列中取出Request请求，进行处理。 NetworkDispatcher:网络调度线程类，不断的从网络请求队列中取出Request去处理。 Cache:缓存接口，代表了一个可以获取请求结果，存储请求结果的缓存。 DiskBasedCache:基于disk的缓存实现类。 BasicNetwork:Volley中默认的网络接口实现类 Response:封装了经过解析后的数据，用于传输 ByteArrayPool:byte[] 的回收池，用于byte[]的再回收利用，减少了内存的分配和回收，是Volley提高性能的优化之一。 RetryPolicy:重试策略接口类 ResponseDelivery:请求结果的传输接口，用于传递请求结果或请求错误。 ExcutorDelivery:请求结果传输接口具体实现类。利用Handler将缓存调度线程或网络调度线程中产生的请求结果和请求错误传输到主线程的回调函数中。

Volley一个请求的执行过程

volley官方文档给出的执行一个请求的步骤是：

RequestQueue mQueue = Volley.newRequestQueue(context);  
mQueue.add(request);

为什么创建一个mQueue以后，直接放入一个request，就可以执行该request了呢？发起网络请求的代码在哪里呢？这里看下newRequestQueue()做了哪些操作：

public static RequestQueue newRequestQueue(Context context, HttpStack stack) {
        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 = new RequestQueue(new DiskBasedCache(cacheDir), network);
        queue.start();

        return queue;
    }

可以看到创建RequestQueue后，调用了start()方法，再看下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;
            VolleyCompat.getInstance().setNetworkDispatcherPriorityMax(networkDispatcher);
            networkDispatcher.start();
        }
    }

通过源码可以查看到,CacheDispatcher,NetworkDispatcher都是继承了Thread类，这里相当于启动了一个缓存调度线程，四个网络调度线程，这里先不分析缓存，看网络调度线程做了些什么操作：

 @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            Request request;
            try {
                // Take a request from the queue.
                request = mQueue.take();
            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }

            try {
                request.addMarker("network-queue-take");

                // If the request was cancelled already, do not perform the
                // network request.
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }

                addTrafficStatsTag(request);

                NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");

                // If the server returned 304 AND we delivered a response already,
                // we're done -- don't deliver a second identical response.
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }

                // Parse the response here on the worker thread.
                Response response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

                // Write to cache if applicable.
                // TODO: Only update cache metadata instead of entire record for 304s.
                if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }

                // Post the response back.
                request.markDelivered();
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {

//                    volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
//                    parseAndDeliverNetworkError(request, volleyError);

                //volley扩展:(2015-11-10)当出现错误，如设备无网络，请求服务器出错，并且有缓存时，需要将缓存内容展示出来
                VolleyCompat.getInstance().showCacheWhenErrorOccur(mCache,request,mDelivery,volleyError,startTimeMs);

            } catch (Exception e) {
                e.printStackTrace();
//                    VolleyLog.e(e, "Unhandled exception %s", e.toString());
//                    VolleyError volleyError = new VolleyError(e);
//                    volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
//                    mDelivery.postError(request, volleyError);

                //volley扩展:(2015-11-10)当出现错误，如设备无网络，请求服务器出错，并且有缓存时，需要将缓存内容展示出来
                VolleyError volleyError = new VolleyError(e);
                VolleyCompat.getInstance().showCacheWhenErrorOccur(mCache,request,mDelivery,volleyError,startTimeMs);
            }
        }
    }

很简单，网络调度线程先是从队列mQueue里取出一个request,然后判断该request是否已经取消，如果没有被用户取消，则调用mNetwork的performRequest(request)发起网络请求，这里的mNetWork是一个BasicNetWrok,看下performRequest()的实现，

@Override
    public NetworkResponse performRequest(Request request) t