Volley-Request的源码解析

Android控件跟框架 Android源码分析

前言

Request是一个抽象类，Request被称为请求，通过继承Request来自定义request，为volley提供了更加灵活的接口。

Request中的泛型T，是指解析response以后的结果。ResponseDelivery会把response分派给对应的request。在我们定义的请求中，需要重写parseNetworkResponse(NetworkResponse response)这个方法，解析请求，解析出来的结果，就是T类型的。

继承关系

Request请求接口结构如下所示：

• Request：用来构造一个请求对象
• StringRequest ：响应的主体为字符串
• JsonRequest：发送和接收JSON相关的接口
• JsonObjectRequest：发送和接收JSON对象
• JsonArrayRequest ：发送和接收JSON数组
• ImageRequest ：发送和接收Image
• ClearCacheRequest： 一个模拟的用来清理缓存的请求

源码分析

成员变量

接下来对Request的源码进行解析，首先看成员变量：

public abstract class Request<T> implements Comparable<Request<T>> {
    //默认编码
    private static final String DEFAULT_PARAMS_ENCODING = "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;
    }
    //用于跟踪请求的生存时间，用于调试 
    private final MarkerLog mEventLog = MarkerLog.ENABLED ? new MarkerLog() : null;
    //请求方式
    private final int mMethod;
    //请求URL
    private final String mUrl;
    //流量统计标签  
    private final int mDefaultTrafficStatsTag;
    //错误监听器
    private final Response.ErrorListener mErrorListener;
    //请求序号，用于fifo算法 
    private Integer mSequence;
    // 请求所在的请求队列 
    private RequestQueue mRequestQueue;
    //是否使用缓存响应请求或者是否允许请求响应被缓存
    private boolean mShouldCache = true;
    //该请求是否被取消
    private boolean mCanceled = false;
    //该请求的结果是否已经被分发
    private boolean mResponseDelivered = false;
    //请求重试策略  
    private RetryPolicy mRetryPolicy;
    //缓存记录。当请求可以从缓存中获得响应，但必须从网络上更新时。我们保留这个缓存记录，所以一旦从网络上获得的响应带有Not Modified (没有更新)时，来保证这个缓存没有被回收. 
    private Cache.Entry mCacheEntry = null;
    //用于自定义标记，可以理解为用于请求的分类  撤销请求的时候会用到
    private Object mTag;
    ....
}    

1. DEFAULT_PARAMS_ENCODING = "UTF-8" 默认编码

2. mMethod 请求方式

3. mUrl 请求地址

4. mDefaultTrafficStatsTag 流量统计标签

5. mErrorListener 错误监听器

6. mSequence 请求序列号，就是这个request在队列中的序号(不是顺序)，用于fifo算法

7. mRequestQueue 请求所在的请求队列

8. mShouldCache 是否使用缓存响应请求或者是否允许请求响应被缓存

9. mCanceled 该请求是否被取消

10. mResponseDelivered 该请求的结果是否已经被分发

11. mRetryPolicy 请求重试策略

12. mCacheEntry 缓存记录,这个记录用于缓存响应头等

13. mTag 用于自定义标记，可以理解为用于请求的分类 撤销请求的时候会用到

构造方法

    //根据请求方式，创建新的请求(需要地址，错误监听器等参数) 
    @Deprecated
    public Request(String url, Response.ErrorListener listener) {
        this(Method.DEPRECATED_GET_OR_POST, url, listener);
    }
    public Request(int method, String url, Response.ErrorListener listener) {
        mMethod = method;
        mUrl = url;
        mErrorListener = listener;
        setRetryPolicy(new DefaultRetryPolicy());
        mDefaultTrafficStatsTag = findDefaultTrafficStatsTag(url);
    }

public Request<?> setRetryPolicy(RetryPolicy retryPolicy) {
        mRetryPolicy = retryPolicy;
        return this;
}

首先是请求方式，请求地址的设定，这是作为一个请求必须有的。然后是监听器的设定，注意这里只是设置了ErrorListner，说明errorListener是必须的，但是正确响应，我们有可能不处理。这样设定是合理的，因为出错了，我们必须处理，至于请求成功，我们可以不处理。那么我们想处理成功的请求怎么办呢，这需要在子类中重写构造方法(例如StringRequest)。

    private final Listener<String> mListener;
    public StringRequest(int method, String url, Listener<String> listener,
            ErrorListener errorListener) {
        super(method, url, errorListener);
        mListener = listener;
    }

接着是设置重试策略，关于重试策略，建议阅读：Volley的请求重试策略相关源码分析，接下来是流量标志的设置，所谓流量标志，是用于调试日志记录的，不是重点。

finish方法

    void finish(final String tag) {
        if (mRequestQueue != null) {
            mRequestQueue.finish(this);
        }
        //调试相关，不是重点，暂时不用关心
        if (MarkerLog.ENABLED) {
            final long threadId = Thread.currentThread().getId();//线程id 
            if (Looper.myLooper() != Looper.getMainLooper()) {//请求不是在主线程 
                //如果我们不是在主线程记录log，我们需要在主线程做这项工作来保证正确的顺序 
                Handler mainThread = new Handler(Looper.getMainLooper());
                mainThread.post(new Runnable() {
                    @Override
                    public void run() {
                        mEventLog.add(tag, threadId);
                        mEventLog.finish(this.toString());
                    }
                });
                return;
            }
            //如果在主线程，直接记录  
            mEventLog.add(tag, threadId);
            mEventLog.finish(this.toString());
        }
    }

finish方法，主要是做了一些日志记录的工作，最重要的是调用了mRequestQueue的finish()方法，来从队列中去除这个请求，关于具体的细节，建议阅读：中对RequestQueue的finish方法的介绍。

compareTo方法

Request继承了Comparable>接口，重写了compareTo()方法，用于对请求进行排列。

    //优先级枚举类
    public enum Priority {
        LOW,
        NORMAL,
        HIGH,
        IMMEDIATE
    }
    public Priority getPriority() {
        return Priority.NORMAL;
    }
    @Override
    public int compareTo(Request<T> other) {
        Priority left = this.getPriority();
        Priority right = other.getPriority();
        //优先级越高，在请求队列中排得越前
        //相同优先级的按照序号进行排列，序号越低，排得越前。
        return left == right ?
                this.mSequence - other.mSequence :
                right.ordinal() - left.ordinal();
    }

在Volley中，一个Request是放在优先级阻塞队列中的，由阻塞线程和请求线程从队列中取出Request进行处理，排在队列前面的Request会优先被处理。有的请求比较重要，希望早点执行，我们可以让它排在请求队列的前头。通过比较方法，我们就可以设定请求在请求队列中排队顺序的根据，从而让优先级高的排在前面。

Request中提供了getPriority方法，默认返回Priority.NORMAL，如果我们想要修改Request的优先级，在创建Request的时候直接重写Request的这个方法即可，如下所示。

 StringRequest stringRequest = new StringRequest(1,"",null,null){
    @Override
    public Priority getPriority() {
           return Priority.HIGH;
    }
 };

响应处理方法

    //解析响应
    abstract protected Response<T> parseNetworkResponse(NetworkResponse response);
    //解析网络错误 
    protected VolleyError parseNetworkError(VolleyError volleyError) {
        return volleyError;
    }
    //分发响应
    abstract protected void deliverResponse(T response);
    //分发网络错误
    public void deliverError(VolleyError error) {
        if (mErrorListener != null) {
            mErrorListener.onErrorResponse(error);
        }
    }

parseNetworkError和deliverError用于相应失败的情况，parseNetworkError()用于解析Volleyerror，deliverError()方法回调了前面提到的ErrorListener。

parseNetworkError()是在NetworkDispatcher的run方法中调用的，deliverError()是在ExecutorDelivery中调用的。

parseNetworkResponse和deliverResponse用于处理相应成功的情况，parseNetworkResponse(NetworkResponse response)用于将网络response解析为本地response，解析出来的response,会交给deliverResponse(T response)方法。

parseNetworkResponse()是在NetworkDispatcher的run方法中调用的，deliverResponse()是在ExecutorDelivery中调用的。

关于为什么要解析，其实开头已经说过，要将结果解析为T类型。Volley中提供的各种Request都重写了这这个方法，将结果解析成自己定义的类型。

getHeaders()方法

public Map<String, String> getHeaders() throws AuthFailureError {
        return Collections.emptyMap();
}

返回包含首部信息的Map，key为首部字段，value为首部字段的值，默认返回为空Map，如果用户想要设置某些请求首部，创建Request的时候，重写这个方法即可。

StringRequest stringRequest = new StringRequest(1,"",null,null){
    @Override
    public Map<String, String> getHeaders() throws AuthFailureError {
        Map<String, String> headers = new HashMap<>();
        return headers;
    }
};

设置在Map中的首部信息，会在HttpStack的实现类的performRequest方法中，被取出，设置给网络请求。

    @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);
        ....
        URL parsedUrl = new URL(url);
        HttpURLConnection connection = openConnection(parsedUrl, request);
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }
        ....
        return response;
    }

post相关方法

我们可以设置Request为各种http请求方式，最常见的是get方式和post方式。通过get方式请求数据的时候，数据是通过组拼url提交的，也就是说如果我们的Request为get请求方式，我们直接将数据附加在url上即可。但是当我通过post方式提交数据的时候，数据是被添加在请求体中提交的，所以如果我们想要设置Request为post请求方式，我们需要重写getParams()方法，将我们的参数附加在map中：

StringRequest stringRequest = new StringRequest(1,"",null,null){
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> params = new HashMap<>();
            params.put("userName", "zhangsan");
            params.put("password", "123");
            return params;
        }
};

我们通过getParams()返回的含有的参数值的Map最终也是在HttpStack的实现类的performRequest方法中，被取出，设置给网络请求。

    @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);
        ....
        URL parsedUrl = new URL(url);
        HttpURLConnection connection = openConnection(parsedUrl, request);
        for (String headerName : map.keySet()) {
            connection.addRequestProperty(headerName, map.get(headerName));
        }
        setConnectionParametersForRequest(connection, request);
        ....
        return response;
    }

设置的操作，就发生在HttpStack的实现类的setConnectionParametersForRequest方法中：

static void setConnectionParametersForRequest(HttpURLConnection connection,
            Request<?> request) throws IOException, AuthFailureError {
        switch (request.getMethod()) {
            ....
            case Method.POST:
                connection.setRequestMethod("POST");
                addBodyIfExists(connection, request);
                break;
            ....
            default:
                throw new IllegalStateException("Unknown method type.");
        }
    }

我们可以看到当Request位post请求方式的时候，会执行如下代码：

 connection.setRequestMethod("POST");
 addBodyIfExists(connection, request);

设置HttpUrlConnection的请求方式为post请求方式，同时将提交的数据设置到HttpUrlConnection中，设置的最终操作就是HttpStack的实现类的addBodyIfExists方法中：

    private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
            throws IOException, AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            connection.setDoOutput(true);
            connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(body);
            out.close();
        }
    }

在addBodyIfExists方法中，会调用Request的getBody()方法，getBody()中调用了我们重写的Request的getParams方法，获取到了含有我们要提交的数据的map。

    Request中的方法：
    public byte[] getBody() throws AuthFailureError {
        Map<String, String> params = getParams();
        if (params != null && params.size() > 0) {
            return encodeParameters(params, getParamsEncoding());
        }
        return null;
    }
    private static final String DEFAULT_PARAMS_ENCODING = "UTF-8";
    protected String getParamsEncoding() {
        return DEFAULT_PARAMS_ENCODING;
    }

getBody方法中取出我们要提交的数据之后，会按照我们设置的编码方式，将数据进行编码。

Request中的方法：
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);
        }
}

继续回到HttpStack的实现类的addBodyIfExists方法：

    private static final String HEADER_CONTENT_TYPE = "Content-Type";
    private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
            throws IOException, AuthFailureError {
        byte[] body = request.getBody();
        if (body != null) {
            connection.setDoOutput(true);
            connection.addRequestProperty(HEADER_CONTENT_TYPE, request.getBodyContentType());
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(body);
            out.close();
        }
    }

得到按照特定的编码方式编码的要提交的数据的字节数组之后，通过输出流将数据提到到服务器，在提交之前，设置了请求的 "Content-Type"首部字段：

Request中的方法：
public String getBodyContentType() {
    return "application/x-www-form-urlencoded; charset=" + getParamsEncoding();
}

这样，设置Request为post方式提交数据的时候，Request的几个方法是如何调用的，我们已经很清楚了。

最后再看下当我们不设置Request的请求方式的时候，Request中的几个相关方法是如何调用的，当我们不设置Request的请求方式的时候，请求方式mMethod的值为：

Method.DEPRECATED_GET_OR_POST

我们在直接看HttpStack的实现类的setConnectionParametersForRequest方法，是如何处理的。

static void setConnectionParametersForRequest(HttpURLConnection connection,
            Request<?> request) throws IOException, AuthFailureError {
        switch (request.getMethod()) {
            case Method.DEPRECATED_GET_OR_POST:
                byte[] postBody = request.getPostBody();
                if (postBody != null) {
                    connection.setDoOutput(true);
                    connection.setRequestMethod("POST");
                    connection.addRequestProperty(HEADER_CONTENT_TYPE,
                            request.getPostBodyContentType());
                    DataOutputStream out = new DataOutputStream(connection.getOutputStream());
                    out.write(postBody);
                    out.close();
                }
                break;
            ....
            default:
                throw new IllegalStateException("Unknown method type.");
        }
}

当请求方式为Method.DEPRECATED_GET_OR_POST的时候，先调用Request的getPostBody()方法，检查有没有要提交的数据，如果没有数据的话，则认为这个请求方式是get方法，注意我们看到这里并没有执行设置connection为get请求方式，

 connection.setRequestMethod("GET");

这是因为HttpUrlConnection默认就是get方式的，所以这里并没有进行设置。如果有提交的数据的话，则和前面处理方式一样，通过输出流将数据写到服务器，在提交之前，同样设置了请求的"Content-Type"首部字段，只不过这里调用的是getPostBodyContentType()，其实最终调用的还是getBodyContentType()方法，我们看下getPostBodyContentType()的源码：

    Request中的方法：
    @Deprecated
    public String getPostBodyContentType() {
        return getBodyContentType();
    }

最后看下getPostBody()的实现，getPostBody()的源码如下所示：

    @Deprecated
    public byte[] getPostBody() throws AuthFailureError {
        Map<String, String> postParams = getPostParams();
        if (postParams != null && postParams.size() > 0) {
            return encodeParameters(postParams, getPostParamsEncoding());
        }
        return null;
    }

getPostBody()中调用了getPostParams()方法，getPostParams()的源码如下所示：

    @Deprecated
    protected Map<String, String> getPostParams() throws AuthFailureError {
        return getParams();
    }

getPostParams()最终调用了getParams()方法。

在对数据进行编码的encodeParameters方法中，调用了getPostParamsEncoding()方法，getPostParamsEncoding()的源码如下所示：

    @Deprecated
    protected String getPostParamsEncoding() {
        return getParamsEncoding()。;
    }

getPostParamsEncoding()最终是调用了getParamsEncoding()方法。

至此，关于Request的源码分析就结束了，撒欢。

参考链接：

详细解读Volley（一）—— 基本Request对象 & RequestQueue

Volley库源码解析----主要是Request

Volley学习(三)ImageRequest、ImageLoader、NetworkImageView源码简读

volley源码解析(二)--Request类的介绍（只介绍了Request类，参考完）

Volley源码解析<三> Request请求