Volley-NetworkDispatcher源码解析

Android控件跟框架 Android源码分析

在RequestQueue中存在两个队列，一个是缓存请求队列，另一个是网络请求队列，缓存请求队列中存放的是允许使用本地缓存的请求，网络请求队列中存放的是不允许使用缓存或者是本地不存在缓存的请求。在RequestQueue.add方法中，如果使用缓存，就直接将Request放入缓存队列mCacheQueue中了，如果不允许缓存，就直接将请求放入网络请求队列。

在RequestQueue中存在一个缓存线程，缓存线程从缓存请求队列中，取出请求，查找本地缓存，如果查找不到本地缓存，就将这个请求放入网络请求队列中去，如果查找到混存，就直接分发缓存结果。同时在RequestQueue中存在四条请求线程，负责从网絡请求队列中取出请求，从网络中获取数据。CacheDispatcher就是前面提到的缓存线程，而网络请求线程是NetworkDispatcher。

接下来对NetworkDispatcher的源码进行分析。

成员变量：

    /** 请求队列，是一个阻塞队列 */
    private final BlockingQueue<Request<?>> mQueue;
    /** 网络请求的具体实现类 */
    private final Network mNetwork;
    /** Volley缓存的操作类 */
    private final Cache mCache;
    /** Volley的响应分发类 */
    private final ResponseDelivery mDelivery;
    /** 请求线程的中断标志位 */
    private volatile boolean mQuit = false;

• mQueue，请求队列，是一个阻塞队列，用于保存网络请求
• mNetwork，网络请求接口，具体实现类BasicNetwork，用于进行网络请求
• mCache，缓存接口，具体实现类DiskBasedCache，用于进行数据缓存
• ResponseDelivery，响应分发接口，具体实现类：ExecutorDelivery，用于分发响应
• mQuit，请求线程的中断标志位

构造方法：

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

就是对成员变量赋值。

run方法（主要方法）：

@Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        while (true) {
            long startTimeMs = SystemClock.elapsedRealtime();
            Request<?> request;
            try {
                // 从队列中获取一个请求，如果没有请求，则会一直阻塞 
                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 (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }
                //流量统计用的
                addTrafficStatsTag(request);
                // 调用mNetwork请求数据
                NetworkResponse networkResponse = mNetwork.performRequest(request);
                request.addMarker("network-http-complete");
                // 如果服务器返回一个未修改（304）的响应，并且这个请求已经发送过响应对象，不需要再继续，因为没改过  
                if (networkResponse.notModified && request.hasHadResponseDelivered()) {
                    //如果是相同的请求，那么服务器就返回一次响应
                    request.finish("not-modified");
                    continue;
                }
                // 解析响应数据，返回Response对象 
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");
              // 根据request的shouldCache字段来判断是不是需要缓存，如果需要，则将其放到mCache中。 
                if (request.shouldCache() && response.cacheEntry != null) {
                    // 缓存数据
                    mCache.put(request.getCacheKey(), response.cacheEntry);
                    request.addMarker("network-cache-written");
                }
                // 标记请求已经被分发
                request.markDelivered();
                //调用 mDelivery将Response对象传回主线程进行UI的更新。  
                mDelivery.postResponse(request, response);
            } catch (VolleyError volleyError) {
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                parseAndDeliverNetworkError(request, volleyError);
            } catch (Exception e) {
                VolleyLog.e(e, "Unhandled exception %s", e.toString());
                VolleyError volleyError = new VolleyError(e);
                volleyError.setNetworkTimeMs(SystemClock.elapsedRealtime() - startTimeMs);
                //有错误，也会调用到mDelivery，将错误信息传回到主线程，进行提示  
                mDelivery.postError(request, volleyError);
            }
        }
}

网络线程（NetworkDispatcher）主要做了几件事情：
1）调用 mQueue的take（）方法从队列中获取请求，如果没有请求，则一直阻塞在那里等待，直到队列中有新的请求到来。
2）判断请求有没有被取消，如果被取消，则重新获取请求。
3）调用Network对象将请求发送到网络中，并返回一个 NetworkResponse对象。
4）调用请求的pareseNetworkResonse方法，将NetworkResponse对象解析成相对应的Response对象。
5）判断请求是否需要缓存，如果需要缓存，则将其Response中cacheEntry对象放到缓存mCache中。
6）调用 mDelivery将Response对象传到主线程中进行UI更新。

quit方法：

//用于判断线程是否结束,用于退出线程
private volatile boolean mQuit = false;
//出线程
public void quit() {
    mQuit = true;
    interrupt();
}

关于volatile，建议阅读：volatile型变量的特殊访问规则。

quit方法的作用是中断当前的网络请求线程。quit方法中做的事情就是对中断标志位置位，同时调用interrupt()方法中断当前的网络请求线程，我们知道mQueue是一个阻塞队列，所以当没有请求的时候，take方法会阻塞网络请求线程，这时候调用interrupt()方法会抛出InterruptedException异常，这样代码就会进入catch代码块，这时候由于中断标志位已经被置位了，所以会执行return语句，结束while循环，当前的网络请求线程，就终止运行了。

while (true) {
    Request<?> request;
    try {
        request = mQueue.take();
    } catch (InterruptedException e) {
        if (mQuit) {
            return;
        }
        continue;
    }
}

Volley源码分析(三)NetWorkDispatcher分析
Android中关于Volley的使用（七）认识 NetworkDispatcher 和 BasicNetwork

Volley源码解析<五> CacheDispatcher和NetworkDispatcher

Android中TrafficStats流量监控类