Volley的框架解读五（网络调度NetworkDispatcher）

先看UML

 

NetworkDispatcher也是volley中的核心类，该类的是一个线程，主要是在从阻塞队列中获取request，然后去请求网络，然后获得响应后ResponseDelivery，去分发

要知道，在定义该类的时候public class NetworkDispatcher extends Thread {} ，很明显这是一个线程。则必然有run()方法，因此从队列中获取request并执行都是在run()方法内执行的。所以在RequestQueue类中的start()方法内，有创建NetworkDispatcher并start

    for (int i = 0; i < mDispatchers.length; i++) {
            NetworkDispatcher networkDispatcher = new NetworkDispatcher(mNetworkQueue, mNetwork,
                    mCache, mDelivery);
            mDispatchers[i] = networkDispatcher;
            networkDispatcher.start();
        }

NetworkDispatcher中的四个核心的成员变量：

1. private final BlockingQueue mQueue 这是一个阻塞的队列，所有的网络请求的request都存放在该队列中，线程会一直从该队列中获取request并执行。需要注意的是，网络调度线程默认是四个的，因此四个线程要共享该请求队列。
2. private final Network mNetwork; 前面的文章已经介绍过这个类，这是执行网络请求的类，执行请求后返回可被传递的响应
3. private final Cache mCache; 缓存，网络请求拿回数据后，如果该request是可以被缓存的，那么就需要将返回的数据进行存储
4. private final ResponseDelivery mDelivery; 传递响应的类

 

在构造方法内需要传入这四个成员：

public NetworkDispatcher(BlockingQueue<Request> queue, Network network,  
            Cache cache, ResponseDelivery delivery) {  
        mQueue = queue;  
        mNetwork = network;  
        mCache = cache;  
        mDelivery = delivery;  
    }

 

在run方法内，有一个while(true)，表示这个线程会一直开启，先从请求队列中获取request，然后执行请求，再对响应进行传递。

    @Override
    public void run() {
        // 设置该线程的优先级
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        // 从网络请求队列中获取的请求
        Request<?> request;
        //会一直在网络请求队列中读取request  如果网络请求队列为空则等待
        while (true) {
            try {
                // 方法.take()是一个阻塞方法，如果网络队列中没有请求，那么会一直等待。直到获取一个请求
                request = mQueue.take();
            } catch (InterruptedException e) {
                // 如果该请求被interrupt了 那么就放弃该请求，开始获取下一个请求
                if (mQuit) {
                    return;
                }
                continue;
            }

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

                // network request. 如果该请求被取消了，那么就放弃当前请求 开始下一个请求
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }

                addTrafficStatsTag(request);

                // Perform the network request.
                // 访问网络，得到数据
                NetworkResponse networkResponse = mNetwork
                        .performRequest(request);
                request.addMarker("network-http-complete");
                //如果响应状态码是304（304表示该次响应返回值与上次没变化，也就是说可以使用上次的响应），并且该请求已经被分发了，那么就开始下一次请求
                if (networkResponse.notModified
                        && request.hasHadResponseDelivered()) {
                    request.finish("not-modified");
                    continue;
                }
                //将响应解析出来
                Response<?> response = request
                        .parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");
                // 写入缓存
                if (request.shouldCache() && response.cacheEntry != null) {
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }

                //标记还请求已经被分配响应了
                request.markDelivered();
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {
                //如果出现错误，那就传递错误信息  
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                mDelivery.postError(request, new VolleyError(e));
            }
        }
    }