关于volley的一些分析-发送与接收

request的默认编码方式是UTF-8，它一共有八种交互方式：

    public interface Method {        int DEPRECATED_GET_OR_POST = -1;        int GET = 0;        int POST = 1;        int PUT = 2;        int DELETE = 3;        int HEAD = 4;        int OPTIONS = 5;        int TRACE = 6;        int PATCH = 7;    }

request的全局变量：

    //网络交互的方式    private final int mMethod;    /** URL of this request. */    private final String mUrl;    //报错时的回调方法    private final Response.ErrorListener mErrorListener;    //request的编号，用于执行先进先出的顺序    private Integer mSequence;    //request的队列    private RequestQueue mRequestQueue;    //request所对应的response是否应该被缓存    private boolean mShouldCache = true;    //该request是否被取消了    private boolean mCanceled = false;    //request所对应的response是否到达    private boolean mResponseDelivered = false;    //阙值，当超过此值时须在log中打印出来    private static final long SLOW_REQUEST_THRESHOLD_MS = 3000;    //重试策略    private RetryPolicy mRetryPolicy;    //当request可以从缓存中恢复但是又必须在网络中刷新时，缓存将在此保存，当返回的状态码为304时，这代表不必将它从缓存中驱逐    private Cache.Entry mCacheEntry = null;    //一个标记，用于批量取消request    private Object mTag;

接下来看一下他的一些方法：

    //返回request交互的方式    public int getMethod() {        return mMethod;    }    //可以调用cancelAll取消所有带同一tag的request    public Request<?> setTag(Object tag) {        mTag = tag;        return this;    }    //为request设置重试策略    public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {        mRetryPolicy = retryPolicy;        return this;    }    //通知消息队列该request已经完成。    void finish(final String tag) {        if (mRequestQueue != null) {            mRequestQueue.finish(this);        }        .        .        .        .    }    //被RequestQueue调用，为request设置编号    public final Request<?> setSequence(int sequence) {        mSequence = sequence;        return this;    }    /**     * Returns the URL of this request.     */    public String getUrl() {        return mUrl;    }    //返回request对应的缓存键，默认情况下为url。    public String getCacheKey() {        return getUrl();    }    //取消该任务    public void cancel() {        mCanceled = true;    }    //返回额外的HTTP请求头。    public Map<String, String> getHeaders() throws AuthFailureError {        return Collections.emptyMap();    }    //返回用于POST或PUT的键值对参数。或者可以直接重写getBody()，传输自定义的数据。    protected Map<String, String> getParams() throws AuthFailureError {        return null;    }    //编码方式。用于转换从getParams得到的参数。并将其传入POST或PUT的内容content中    protected String getParamsEncoding() {        return DEFAULT_PARAMS_ENCODING;    }    //返回POST或PUT的content类型    public String getBodyContentType() {        return "application/x-www-form-urlencoded; charset=" + getParamsEncoding();    }    //返回POST或PUT即将发送的内容。默认情况下，内容由通过application/x-www-form-urlencoded编码的params组成。当重写该方法时，务必考虑是否要重写getBodyContentType    public byte[] getBody() throws AuthFailureError {        Map<String, String> params = getParams();        if (params != null && params.size() > 0) {            return encodeParameters(params, getParamsEncoding());        }        return null;    }    //将params按照application/x-www-form-urlencoded的编码方式转换    private byte[] encodeParameters(Map<String, String> params, String paramsEncoding) {        StringBuilder encodedParams = new StringBuilder();        try {            for (Map.Entry<String, String> entry : params.entrySet()) {                encodedParams.append(URLEncoder.encode(entry.getKey(), paramsEncoding));                encodedParams.append('=');                encodedParams.append(URLEncoder.encode(entry.getValue(), paramsEncoding));                encodedParams.append('&');            }            return encodedParams.toString().getBytes(paramsEncoding);        } catch (UnsupportedEncodingException uee) {            throw new RuntimeException("Encoding not supported: " + paramsEncoding, uee);        }    }    /**     * Returns the socket timeout in milliseconds per retry attempt. (This value can be changed     * per retry attempt if a backoff is specified via backoffTimeout()). If there are no retry     * attempts remaining, this will cause delivery of a {@link TimeoutError} error.     */    public final int getTimeoutMs() {        return mRetryPolicy.getCurrentTimeout();    }    //将此request标记为response已返回    public void markDelivered() {        mResponseDelivered = true;    }    //子类必须复写该方法解析网络交互返回来的数据并return正确的数据类型。此方法将会在工作线程中调用。如果return null，response将不会被发送。    abstract protected Response<T> parseNetworkResponse(NetworkResponse response);    //子类必须复写该方法解析网络错误。    protected VolleyError parseNetworkError(VolleyError volleyError) {        return volleyError;    }    //子类必须复写该方法执行发送已经被解析好的数据。    abstract protected void deliverResponse(T response);

接下来讲解一下”重试策略“RetryPolicy。该接口只有三个方法,该接口有一个实现类：DefaultRetryPolicy。默认重试次数为1次，超时时间为2.5秒

    //返回当前超时总时间    public int getCurrentTimeout();    //返回当前重试次数    public int getCurrentRetryCount();    //申请超时补偿，准备下一次重试    public void retry(VolleyError error) throws VolleyError;

在NetworkDispatcher中可以看到，request的发送是通过调用BasicNetwork.performRequest(request),而该方法其实是在内部调用了HrulStack.performRequest(request)。那么接下来我们看一下HrulStack的调用过程。

@Override    public HttpResponse performRequest(Request<?> request, Map<String, String> additionalHeaders)            throws IOException, AuthFailureError {        String url = request.getUrl();        HashMap<String, String> map = new HashMap<String, String>();        map.putAll(request.getHeaders());        map.putAll(additionalHeaders);        if (mUrlRewriter != null) {            String rewritten = mUrlRewriter.rewriteUrl(url);            if (rewritten == null) {                throw new IOException("URL blocked by rewriter: " + url);            }            url = rewritten;        }        URL parsedUrl = new URL(url);        //配置HttpURLConnection的连接超时时间，读取超时时间等等        HttpURLConnection connection = openConnection(parsedUrl, request);        //将给定属性添加到请求头        for (String headerName : map.keySet()) {            connection.addRequestProperty(headerName, map.get(headerName));        }        //根据网络交互方式的不同将connection设置为GET或POST等等，其中如果交互方式为POST,PUT，那connection将调用request.getBody填充需发送的内容和request.getBosyContentType定义发送内容类型        setConnectionParametersForRequest(connection, request);        // Initialize HttpResponse with data from the HttpURLConnection.        ProtocolVersion protocolVersion = new ProtocolVersion("HTTP", 1, 1);        int responseCode = connection.getResponseCode();        //返回的状态码为-1代表交互失败        if (responseCode == -1) {            // -1 is returned by getResponseCode() if the response code could not be retrieved.            // Signal to the caller that something was wrong with the connection.            throw new IOException("Could not retrieve response code from HttpUrlConnection.");        }        //将HTTP协议文本，服务器发回的响应状态代码，状态码的文本描述传入        StatusLine responseStatus = new BasicStatusLine(protocolVersion,                connection.getResponseCode(), connection.getResponseMessage());        BasicHttpResponse response = new BasicHttpResponse(responseStatus);                //将返回的消息内容，长度，类型，编码方式传入      response.setEntity(entityFromConnection(connection));        //填充响应头        for (Entry<String, List<String>> header : connection.getHeaderFields().entrySet()) {            if (header.getKey() != null) {                Header h = new BasicHeader(header.getKey(), header.getValue().get(0));                response.addHeader(h);            }        }        return response;    }

接下来是BasicNetwork的performRequest.“重试策略”RetryPolicy便是在这里生效的。可以观察到的是该方法被while（true）包裹起来了。当发生SocketTimeoutException，ConnectTimeoutException，IOException（该错误视情况而重试）时，就会调用attemptRetryOnException（），该方法会调用request.getRetryPolicy（），进而调用RetryPolicy.retry进行重试。一旦重试次数超过设定的次数，就会抛出VolleyError。此外，这里还有部分关于Http状态码的判定，详细可参考：301、404、200、304等HTTP状态

@Override    public NetworkResponse performRequest(Request<?> request) throws VolleyError {        long requestStart = SystemClock.elapsedRealtime();        while (true) {            HttpResponse httpResponse = null;            byte[] responseContents = null;            Map<String, String> responseHeaders = Collections.emptyMap();            try {                // Gather headers.                Map<String, String> headers = new HashMap<String, String>();                addCacheHeaders(headers, request.getCacheEntry());                httpResponse = mHttpStack.performRequest(request, headers);                StatusLine statusLine = httpResponse.getStatusLine();                int statusCode = statusLine.getStatusCode();                responseHeaders = convertHeaders(httpResponse.getAllHeaders());                // Handle cache validation.                //状态码表示此次发送为第二次发送（即刷新），并且内容无改变时                if (statusCode == HttpStatus.SC_NOT_MODIFIED) {                    Entry entry = request.getCacheEntry();                    if (entry == null) {                        return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, null,                                responseHeaders, true,                                SystemClock.elapsedRealtime() - requestStart);                    }                    // A HTTP 304 response does not have all header fields. We                    // have to use the header fields from the cache entry plus                    // the new ones from the response.                    // http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.5                    entry.responseHeaders.putAll(responseHeaders);                    return new NetworkResponse(HttpStatus.SC_NOT_MODIFIED, entry.data,                            entry.responseHeaders, true,                            SystemClock.elapsedRealtime() - requestStart);                }                // Some responses such as 204s do not have content.  We must check.                //从HttpEntity中读取数据往byte[]中。其中方法entityToBytes()用的是ByteArrayOutputStream的变体PoolingByteArrayOutputStream,避免了多次分配内存，可自动根据内容大小扩充byte[].                if (httpResponse.getEntity() != null) {                  responseContents = entityToBytes(httpResponse.getEntity());                } else {                  // Add 0 byte response as a way of honestly representing a                  // no-content request.                  responseContents = new byte[0];                }                // if the request is slow, log it.                long requestLifetime = SystemClock.elapsedRealtime() - requestStart;                logSlowRequests(requestLifetime, request, responseContents, statusLine);                if (statusCode < 200 || statusCode > 299) {                    throw new IOException();                }                return new NetworkResponse(statusCode, responseContents, responseHeaders, false,                        SystemClock.elapsedRealtime() - requestStart);            } catch (SocketTimeoutException e) {                attemptRetryOnException("socket", request, new TimeoutError());            } catch (ConnectTimeoutException e) {                attemptRetryOnException("connection", request, new TimeoutError());            } catch (MalformedURLException e) {                throw new RuntimeException("Bad URL " + request.getUrl(), e);            } catch (IOException e) {                int statusCode = 0;                NetworkResponse networkResponse = null;                if (httpResponse != null) {                    statusCode = httpResponse.getStatusLine().getStatusCode();                } else {                    throw new NoConnectionError(e);                }                VolleyLog.e("Unexpected response code %d for %s", statusCode, request.getUrl());                if (responseContents != null) {                    networkResponse = new NetworkResponse(statusCode, responseContents,                            responseHeaders, false, SystemClock.elapsedRealtime() - requestStart);                    if (statusCode == HttpStatus.SC_UNAUTHORIZED ||                            statusCode == HttpStatus.SC_FORBIDDEN) {                        attemptRetryOnException("auth",                                request, new AuthFailureError(networkResponse));                    } else {                        // TODO: Only throw ServerError for 5xx status codes.                        throw new ServerError(networkResponse);                    }                } else {                    throw new NetworkError(networkResponse);                }            }        }    }

下面是介绍下BasicNetworkResponse，这个类主要用来接收数据。

    //HTTP状态码    public final int statusCode;    //返回的数据    public final byte[] data;    //响应头信息    public final Map<String, String> headers;    //当状态码为304时为true    public final boolean notModified;    //网络交互总时间    public final long networkTimeMs;

在NetworkDispatcher中会调用request.parseNetworkResponse(networkResponse)解析数据。举个例子，json解析方法为：

String jsonString = new String(response.data, HttpHeaderParser.parseCharset(response.headers, "utf-8"));

parseCharaset会从响应头中获取解码方式，如果获取失败就会使用utf-8解码。
parseNetworkResponse最终会调用下面这个方法返回Response.第二个参数会将数据解析后放入Cache.Entry中，等下在NetworkDispatcher中会存入硬存中。关于数据的解析需要掌握的是响应头等的参数，详细可参考：Android系列之网络（二）—-HTTP请求头与响应头

Response.success(new JSONObject(jsonString),HttpHeaderParser.parseCacheHeaders(response));

如果有错误就会调用：

Response.error(new ParseError(e));

下面是response的全局变量。它的实例化方法只有两个，就是如上面所述。

    //最终返回的数据类型，当为null时表明有error    public final T result;    //缓存元数据    public final Cache.Entry cacheEntry;    //错误信息    public final VolleyError error;    //当为true时，表明此次得到的数据为soft-expired,第二次刷新得到的数据将很快到达    public boolean intermediate = false;

到这里为止，数据已经处理完毕。接下来是通过回调将数据在主线程中处理。在RequestQueue接收的参数中有一个是ExecutorDelivery,这个类里面有有一个内部类ResponseDeliveryRunnable。
ExecutorDelivery会将数据封在ResponseDeliveryRunnable中，然后调用handler.post(runnable)在主线程中运行

 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);            }        };    }    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));    }    @Override    public void postError(Request<?> request, VolleyError error) {        request.addMarker("post-error");        Response<?> response = Response.error(error);        mResponsePoster.execute(new ResponseDeliveryRunnable(request, response, null));    }private class ResponseDeliveryRunnable implements Runnable {        private final Request mRequest;        private final Response mResponse;        private final Runnable mRunnable;        public ResponseDeliveryRunnable(Request request, Response response, Runnable runnable) {            mRequest = request;            mResponse = response;            mRunnable = runnable;        }        @SuppressWarnings("unchecked")        @Override        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");            }            //这句代码会在CacheDispatcher中运行，如果缓存已经Soft-expired，将会启动第二次刷新，此时CacheDispatcher将会调用            /*            mDelivery.postResponse(request, response, new Runnable() {                        @Override                        public void run() {                            try {                                mNetworkQueue.put(request);                            } catch (InterruptedException e) {                                // Not much we can do about this.                            }                        }                    });            */            if (mRunnable != null) {                mRunnable.run();            }       }    }}