Volley框架的基本解读(六)

接上一遍内容，我们继续解析，来揭开mDelivery的神秘面纱，它的类是ResponseDelivery，来看源码：

public interface ResponseDelivery {    /**     * Parses a response from the network or cache and delivers it.     */    public void postResponse(Request<?> request, Response<?> response);    /**     * Parses a response from the network or cache and delivers it. The provided     * Runnable will be executed after delivery.     */    public void postResponse(Request<?> request, Response<?> response, Runnable runnable);    /**     * Posts an error for the given request.     */    public void postError(Request<?> request, VolleyError error);}

这里接口，里面有三个方法，分别用于分发正确结果，分发正确结果并执行Runnable，分发错误结果。

实例的创建是在RequestQueue的构造方法中

public RequestQueue(Cache cache, Network network, int threadPoolSize) {        this(cache, network, threadPoolSize,                new ExecutorDelivery(new Handler(Looper.getMainLooper())));    }

那么我们先从ExecutorDelivery的构造方法看起

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

代码很清晰，只是执行了handler.post方法，ResponseDelivery接口抽象方法的复写

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

仅有三句代码，分别是标记分发事件完毕，调试信息，执行一个Runnable，ResponseDeliveryRunnable就是Runnable，看源码

private class ResponseDeliveryRunnable implements Runnable

看run方法

@SuppressWarnings("unchecked")        @Override        public void run() {            // If this request has canceled, finish it and don't deliver.        // 如果该request已经取消，则停止分发            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是否取消，这段代码已经出现多次了，在判断请求是否成功，我们点进去看看

/**     * Returns whether this response is considered successful.     *      * 是否成功     */    public boolean isSuccess() {        return error == null;    }

error就是VolleyError，在网络请求的时候我们说过，仅有两种方式可以跳出循环，要么请求成功，要么抛出异常，先说请求成功BasicNetwork将服务器返回信息封装成NetworkResponse给予返回，NetworkDispatcher有这样一句代码对它进行解析：

// 交由Request进行解析Response                Response<?> response = request.parseNetworkResponse(networkResponse);

parseNetworkResponse是定义在request中的抽象方法，我们找一个具体子类看看，StringRequest的源码：

@Override    protected Response<String> parseNetworkResponse(NetworkResponse response) {        String parsed;        try {            parsed = new String(response.data, HttpHeaderParser.parseCharset(response.headers));        } catch (UnsupportedEncodingException e) {            parsed = new String(response.data);        }        return Response.success(parsed, HttpHeaderParser.parseCacheHeaders(response));    }

HttpHeaderParser.parseCharset(response.headers)是从请求头中找出编码格式，绝大多数结果都是UTF-8，重点在return的这段代码，HttpHeaderParser.parseCacheHeaders(response)意思是从response中解析出一个实体。

/**      * Returns a successful response containing the parsed result.      *      * 成功     */    public static <T> Response<T> success(T result, Cache.Entry cacheEntry) {        return new Response<T>(result, cacheEntry);    }

private Response(T result, Cache.Entry cacheEntry) {        this.result = result;        this.cacheEntry = cacheEntry;        this.error = null;    }

看到重点了吗？this.error = null，成功error就是null。

思路回到BasicNetwork如果抛出异常，NetworkDispatcher调用这段代码：

mDelivery.postError(request, new VolleyError(e));

看ExecutorDelivery的具体实现

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

重点来了，Response<?> response = Response.error(error);上代码：

/**     * Returns a failed response containing the given error code and an optional     * localized message displayed to the user.     *      * 失败     */    public static <T> Response<T> error(VolleyError error) {        return new Response<T>(error);    }

private Response(VolleyError error) {        this.result = null;        this.cacheEntry = null;        this.error = error;    }

看到了吧，this.error = error，失败error不为null。

mResponse.isSuccess()就可以做出正确的判断，request调用deliverResponse分发结果，这也是一个抽象方法，在拿StringRequest的实现看看：

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

mListener这就是我们给的成功回调

deliverError是定义在request的方法

public void deliverError(VolleyError error) {        if (mErrorListener != null) {            mErrorListener.onErrorResponse(error);        }    }

mErrorListener正是错误回调

接着主线走，mResponse.intermediate是命中过期缓存标志，是打出调试信息，否结束request，最后mRunnable不为null，给予执行。

夫万象森罗，不离两仪所育；百法纷凑，无越三教之境。

至此Volley主线以全部走通，后面会单独解析Request与Response这两个重中之重。