文章摘要
1、volley 消息传递工 工作原理

---

附：获取Volley源代码

Demos案例源码：https://github.com/HailouWang/DemosForApi

简介：

volley有两个主要的民工，CacheDispatcher以及NetworkDispatcher，也是两个线程，管理并处理Request任务。

volley为了保证大批量的网络请求以及数据解析不会影响到主线程的用户交互，使用了很多线程以及线程封装技巧。包括这里的Cache。

在用户发起网络请求后，volley就将用户的请求，丢到了本文介绍的缓存进程，缓存线程如果没有能力处理，就丢给网络线程，并告诉它，老大需要数据结果，你赶紧去网络上去拿。老大只要结果，不要过程。

主线程很忙，ResponseDelivery负责传递消息，伴君如伴虎，为了防止打扰到主线程的工作，ResponseDelivery也可以有一个线程，在目前的源码里，ResponseDelivery充分利用Handler的MessageQueue优势，管理并小心的将结果传递给主线程。

那么，本文就来介绍下消息传递工(ResponseDelivery)的工作原理：

1、传递工人（ResponseDelivery）初始化。

在初始化RequestQueue工具类时，会初始化传递工。传递工使用Handler来管理队列，Handler的Looper来自主线程。

    /**
     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
     *创建一个工作池，非start方法调用前，不会开始执行
     * @param cache A Cache to use for persisting responses to disk
     * 1、缓存者。将相应数据持久化到硬盘
     * @param network A Network interface for performing HTTP requests
     * 2、网络处理者。处理HTTP请求的Network 接口
     * @param threadPoolSize Number of network dispatcher threads to create
     * 3、网络请求分发者。默认4个分发线程池
     * @param delivery A ResponseDelivery interface for posting responses and errors
     * 4、响应传递者。传递响应数据，以及错误日志信息
     */
    public RequestQueue(Cache cache, Network network, int threadPoolSize,
            ResponseDelivery delivery) {
        mCache = cache;
        mNetwork = network;
        mDispatchers = new NetworkDispatcher[threadPoolSize];
        mDelivery = delivery;
    }

    /**
     * Creates the worker pool. Processing will not begin until {@link #start()} is called.
     *
     * @param cache A Cache to use for persisting responses to disk
     * @param network A Network interface for performing HTTP requests
     * @param threadPoolSize Number of network dispatcher threads to create
     */
    public RequestQueue(Cache cache, Network network, int threadPoolSize) {
        this(cache, network, threadPoolSize,
                new ExecutorDelivery(new Handler(Looper.getMainLooper())));
    }

在这里，原生提供了一种默认的实现：

new ExecutorDelivery(new Handler(Looper.getMainLooper()))

在这段代码中，需要传入一个Handler对象，对象中的Loop来自主线程，可以这么说，Handler工作在主线程中。

备注：我们也可以创建自己的传递工（ResponseDelivery），原生提供的实现中，类图如下：

• 

2、传递工人（ResponseDelivery）接收回调任务。

我们之前介绍过了，volley有两个默默工作的劳工，它们就是CacheDispatcher以及NetworkDispatcher，劳工们在做完工作后，是没有权利告诉主线程的，因为这是传递工人的工作。

NetworkDispatcher或者CacheDispatcher通过如下方式告诉ResponseDelivery，需要向主线程传递结果。

mDelivery.postResponse(request, response);

无论是Response还是Error，所有的这些响应都发给了ResponseDelivery中的线程池。

3、传递工人对接收到的任务的处理

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

    @Override
    public void postError(Request<?> request, VolleyError error) {
        request.addMarker("post-error");
        Response<?> response = Response.error(error);
        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, null));
    }

线程池会将得到的消息，包装一个Runnable，利用Handler发送给主线程。

// If this request has canceled, finish it and don't deliver.
//1、如果请求已经取消，则不必传递
if (mRequest.isCanceled()) {
    mRequest.finish("canceled-at-delivery");
    return;
}

// Deliver a normal response or error, depending.
if (mResponse.isSuccess()) {
    //2、如果Response没有错误，则分发result
    mRequest.deliverResponse(mResponse.result);
} else {
    //3、如果Reponse有错误，则分发error
    mRequest.deliverError(mResponse.error);
}

// If this is an intermediate response, add a marker, otherwise we're done
// and the request can be finished.
//4、如果 响应属于媒介，标记marker
if (mResponse.intermediate) {
    mRequest.addMarker("intermediate-response");
} else {
    mRequest.finish("done");
}

4、传递工人将消息回调给主线程。

通过3中可以看到，发往主线程的回调，是通过mRequest.deliverResponse来实现的。

/**
 * Subclasses must implement this to perform delivery of the parsed
 * response to their listeners.  The given response is guaranteed to
 * be non-null; responses that fail to parse are not delivered.
 * @param response The parsed response returned by
 * {@link #parseNetworkResponse(NetworkResponse)}
 */
abstract protected void deliverResponse(T response);

通过Request#deliverResponse，我们看到，这是一个Abstract方法，不同的实现，传递方式也不同。这里介绍下原生的实现：
StringRequest.java

@Override
protected void deliverResponse(String response) {
    mListener.onResponse(response);
}