[Android]Volley源码分析(五)消息分发器Dispatcher

在[Android]Volley源码分析(四)请求队列中提及到：当新增一个消息请求时，如果使用缓存，则先将请求放入缓存队列，否则直接加入网络请求队列。首先我们看看缓存队列mCacheQueue的使用对象CacheDispatcher。通过类图，可以发现CacheDispatcher继承与Thread类，其主要的实现方法是run()，具体代码如下：

<span style="font-size:14px;">    @Override
    public void run() {
        if (DEBUG) VolleyLog.v("start new dispatcher");
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

        // Make a blocking call to initialize the cache.
        mCache.initialize();

        while (true) {
            try {
                // Get a request from the cache triage queue, blocking until
                // at least one is available.
                final Request<?> request = mCacheQueue.take();
                request.addMarker("cache-queue-take");

                // 如果请求取消，则结束请求
                if (request.isCanceled()) {
                    request.finish("cache-discard-canceled");
                    continue;
                }

                // 首先判断缓存是否存在，如果没有，则加入网络请求队列
                Cache.Entry entry = mCache.get(request.getCacheKey());
                if (entry == null) {
                    VolleyLog.d(" Cache miss; send off to the network dispatcher.");
                    request.addMarker("cache-miss");
                    // Cache miss; send off to the network dispatcher.
                    mNetworkQueue.put(request);
                    continue;
                }

                // 如果缓存过期，也将请求加入网络请求队列
                if (entry.isExpired()) {
                    request.addMarker("cache-hit-expired");
                    request.setCacheEntry(entry);
                    mNetworkQueue.put(request);
                    continue;
                }

               
                request.addMarker("cache-hit");
                Response<?> response = request.parseNetworkResponse(
                        new NetworkResponse(entry.data, entry.responseHeaders));
                request.addMarker("cache-hit-parsed");

                if (!entry.refreshNeeded()) {
                    VolleyLog.d("unexpired cache hit. Just deliver the response.");
                    // 如果缓存没过期，则将缓存中的请求结果返回
                    mDelivery.postResponse(request, response);
                } else {
                    VolleyLog.d("Soft-expired cache hit.eed to also send the request to the network for refreshing");
                    //如果需要更新，那需要返回缓存里的请求结果
                    // 同时需要向网络请求最新的结果，更新缓存
                    // 以及返回结果
                    request.addMarker("cache-hit-refresh-needed");
                    request.setCacheEntry(entry);

                    // Mark the response as intermediate.
                    response.intermediate = true;

                    // Post the intermediate response back to the user and have
                    // the delivery then forward the request along to the network.
                    mDelivery.postResponse(request, response, new Runnable() {
                        @Override
                        public void run() {
                            try {
                                mNetworkQueue.put(request);
                            } catch (InterruptedException e) {
                                // Not much we can do about this.
                            }
                        }
                    });
                }

            } catch (InterruptedException e) {
                // We may have been interrupted because it was time to quit.
                if (mQuit) {
                    return;
                }
                continue;
            }
        }
    }</span>

通过代码可以知道， CacheDispatcher首先检查缓存里是否存在请求结果，如果没有则通过网络请求，返回请求结果。下面我们看看NetworkDispatcher的run()方法是如何实现消息派发的：

<span style="font-size:18px;">   </span><span style="font-size:14px;"> @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
        Request<?> request;
        while (true) {
            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 the request was cancelled already, do not perform the
                // network request.
                if (request.isCanceled()) {
                    request.finish("network-discard-cancelled");
                    continue;
                }

                addTrafficStatsTag(request);

                // 执行网络请求
                VolleyLog.d("current thread:"+getId()+" start 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;
                }

                // 解析网络请求结果
                Response<?> response = request.parseNetworkResponse(networkResponse);
                request.addMarker("network-parse-complete");

                // 如果需要缓存，加入缓存
                // 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");
                }

                //返回请求和请求结果
                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));
            }
        }
    }</span>

通过代码可以看出， NetworkDispatcher通过Network向网络发出请求，然后将请求结果解析，如果需要缓存则加入缓存，最好通过ResponseDelivery返回请求以及解析后的请求结果给主线程。

通过类图可以看出，ResponseDelivery是由ExecutorDelivery实现的，ExecutorDelivery通过主线程的handler返回消息结果：

<span style="font-size: 18px;">  </span><span style="font-size:14px;">public ExecutorDelivery(final Handler handler) {
        // Make an Executor that just wraps the handler.
        mResponsePoster = new Executor() {
            @Override
            public void execute(Runnable command) {
                handler.post(command);
            }
        };
    }

    /**
     * Creates a new response delivery interface, mockable version
     * for testing.
     * @param executor For running delivery tasks
     */
    public ExecutorDelivery(Executor executor) {
        mResponsePoster = executor;
    }

    @Override
    public void postResponse(Request<?> request, Response<?> response) {
        postResponse(request, response, null);
    }

    @Override
    public void postResponse(Request<?> request, Response<?> response, Runnable runnable) {
        request.markDelivered();
        request.addMarker("post-response");
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, runnable));
    }</span>

具体是通过ResponseDeliveryRunnable的run()实现的：

  public void run() {
            // If this request has canceled, finish it and don't deliver.
            if (mRequest.isCanceled()) {
                mRequest.finish("canceled-at-delivery");
                return;
            }

            // Deliver a normal response or error, depending.
            if (mResponse.isSuccess()) {
                mRequest.deliverResponse(mResponse.result);
            } else {
                mRequest.deliverError(mResponse.error);
            }

            // If this is an intermediate response, add a marker, otherwise we're done
            // and the request can be finished.
            if (mResponse.intermediate) {
                mRequest.addMarker("intermediate-response");
            } else {
                mRequest.finish("done");
            }

            // If we have been provided a post-delivery runnable, run it.
            if (mRunnable != null) {
                mRunnable.run();
            }
       }

可以看出，消息返回后，执行Request的finish()方法。

Volley的消息分发流程到此结束了。