文章摘要
1、volley 自定义Request
2、volley GsonRequest 案例

---

英文文献

一、自定义Request

大多数请求在toolbox中具有实用型实现; 如果您的请求响应是字符串，图像或JSON，则可能不需要实现自定义请求。对于您需要实现自定义请求的情况，您需要执行以下操作：

• 1、扩展Request<T>类，其中<T>表示Request期望的解析响应的类型。 因此，如果您的解析响应是字符串，那么，通过扩展Request<String>来创建自定义请求。

• 2、实现抽象方法parseNetworkResponse（）和deliverResponse（），如下面更详细的描述。

二、parseNetworkResponse

对于给定的类型（如字符串，图像或JSON），响应封装了用于传递的解析响应。 以下是parseNetworkResponse（）的示例实现：

@Override
protected Response<T> parseNetworkResponse(
        NetworkResponse response) {
    try {
        String json = new String(response.data,
        HttpHeaderParser.parseCharset(response.headers));
    return Response.success(gson.fromJson(json, clazz),
    HttpHeaderParser.parseCacheHeaders(response));
    }
    // handle errors
...
}

• parseNetworkResponse() 中的一个参数NetworkResponse，它在byte []中包含响应数据，HTTP状态代码和响应Headers。
• 您的实现必须返回Response<T>，其中包含响应类型对象和缓存元数据或错误信息，比如在解析失败信息。

如果您的协议具有非标准缓存语义，您可以自行构建一个Cache Entry，但大多数请求都是这样的：

return Response.success(myDecodedObject,
        HttpHeaderParser.parseCacheHeaders(response));

Volley从Worker 线程调用parseNetworkResponse()。 这确保大量的数据解析操作（例如将JPEG解码为位图，），不会阻塞UI线程。

三、deliverResponse

Volley使用在主线程上通过parseNetworkResponse()中返回的对象，大多数请求在这里执行回调，例如：

protected void deliverResponse(T response) {
        listener.onResponse(response);

四、示例：GsonRequest

Gson库使用反射将Java对象转换为JSON。 您可以定义与其对应的JSON键具有相同名称的Java对象，将Gson传递给类对象，Gson将为您填写字段。 以下是使用Gson进行解析的Volley请求的完整实现：

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        final TextView mTextView = (TextView) findViewById(R.id.text);

        //1、获得RequestQueue
        RequestQueue queue = MySingleton.getInstance(this.getApplicationContext()).
                getRequestQueue();

        //2、初始化GSON Request
        String url = "http://www.sojson.com/api/beian/sojson.com";/*http://www.google.com*/
        GsonRequest<ComplanyWebSiteInfo> gsonRequest = new GsonRequest<>(url,ComplanyWebSiteInfo.class,
            null,new Response.Listener<ComplanyWebSiteInfo>(){
                @Override
                public void onResponse(ComplanyWebSiteInfo response) {
                    Log.d("hlwang","CustomVolleyRequest onResponse ComplanyWebSiteInfo is:"+response);
                    mTextView.setText(response.toString());
                }
            },new Response.ErrorListener(){
                @Override
                public void onErrorResponse(VolleyError error) {
                    Log.d("hlwang","CustomVolleyRequest onErrorResponse error:"+error.getMessage());
                    mTextView.setText("That didn't work!");
                }
            });
        //3、加入RequestQueue
        queue.add(gsonRequest);
    }

    class ComplanyWebSiteInfo{
        private String indexUrl;
        private String icp;

        public String getIndexUrl() {
            return indexUrl;
        }

        public void setIndexUrl(String indexUrl) {
            this.indexUrl = indexUrl;
        }

        @Override
        public String toString() {
            return "ComplanyWebSiteInfo{" +
                    "indexUrl='" + indexUrl + '\'' +
                    ", icp='" + icp + '\'' +
                    '}';
        }
    }

    class GsonRequest<T> extends Request<T> {
        private final Gson gson = new Gson();
        private final Class<T> clazz;
        private final Map<String, String> headers;
        private final Response.Listener<T> listener;

        /**
         * Make a GET request and return a parsed object from JSON.
         *
         * @param url URL of the request to make
         * @param clazz Relevant class object, for Gson's reflection
         * @param headers Map of request headers
         */
        public GsonRequest(String url, Class<T> clazz, Map<String, String> headers,
                           Response.Listener<T> listener, Response.ErrorListener errorListener) {
            super(Method.GET, url, errorListener);
            this.clazz = clazz;
            this.headers = headers;
            this.listener = listener;
        }

        @Override
        public Map<String, String> getHeaders() throws AuthFailureError {
            return headers != null ? headers : super.getHeaders();
        }

        @Override
        protected void deliverResponse(T response) {
            listener.onResponse(response);
        }

        @Override
        protected Response<T> parseNetworkResponse(NetworkResponse response) {
            try {
                String json = new String(
                        response.data,
                        HttpHeaderParser.parseCharset(response.headers));
                return Response.success(
                        gson.fromJson(json, clazz),
                        HttpHeaderParser.parseCacheHeaders(response));
            } catch (UnsupportedEncodingException e) {
                return Response.error(new ParseError(e));
            } catch (JsonSyntaxException e) {
                return Response.error(new ParseError(e));
            }
        }
    }

附：演示效果：

•