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这两个重中之重。