Volley HTTP库系列教程(5)自定义一个Volley请求

Implementing a Custom Request

Previous  Next

1.This lesson teaches you to

1. Write a Custom Request

2. parseNetworkResponse

3. deliverResponse
4. GsonRequest example

2.Write a Custom Request

　　Most requests have ready-to-use implementations in the toolbox; if your response is a string, image, or JSON, you probably won't need to implement a custom Request.

For cases where you do need to implement a custom request, this is all you need to do:

• Extend the Request<T> class, where <T> represents the type of parsed response the request expects. So if your parsed response is a string, for example, create your custom request by extending Request<String>. See the Volley toolbox classes StringRequest and ImageRequest for examples of extending Request<T>.
• Implement the abstract methods parseNetworkResponse() and deliverResponse(), described in more detail below.

2.1 parseNetworkResponse

　　A Response encapsulates a parsed response for delivery, for a given type (such as string, image, or JSON). Here is a sample implementation of 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
 　　//...
 }

　　Note the following:

• parseNetworkResponse() takes as its parameter a NetworkResponse, which contains the response payload as a byte[], HTTP status code, and response headers.
• Your implementation must return a Response<T>, which contains your typed response object and cache metadata or an error, such as in the case of a parse failure.

　　If your protocol has non-standard cache semantics, you can build a Cache.Entry yourself, but most requests are fine with something like this:

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

　　Volley calls parseNetworkResponse() from a worker thread. This ensures that expensive parsing operations, such as decoding a JPEG into a Bitmap, don't block the UI thread.

2.2 deliverResponse

　　Volley calls you back on the main thread with the object you returned in parseNetworkResponse(). Most requests invoke a callback interface here, for example:

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

2.3 Example: GsonRequest

　　Gson is a library for converting Java objects to and from JSON using reflection. You can define Java objects that have the same names as their corresponding JSON keys, pass Gson the class object, and Gson will fill in the fields for you. Here's a complete implementation of a Volley request that uses Gson for parsing:

 import java.io.UnsupportedEncodingException;
 import java.util.Map;

 import com.android.volley.AuthFailureError;
 import com.android.volley.NetworkResponse;
 import com.android.volley.ParseError;
 import com.android.volley.Request;
 import com.android.volley.Response;
 import com.android.volley.Response.ErrorListener;
 import com.android.volley.Response.Listener;
 import com.android.volley.toolbox.HttpHeaderParser;
 import com.google.gson.Gson;
 import com.google.gson.JsonSyntaxException;

 public 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 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,
             Listener<T> listener, 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));
         }
     }
 }

　　使用代码

 　　/*
      * 自定义一个request
      */
     public void onClickCustomRequest(View btn){
         String url = "http://192.168.1.100/gsonrequest.php";//返回json数据
         //1,得到一个RequestQueue
         RequestQueue queue = Volley.newRequestQueue(this);
         //2,构造一个自定义请求,返回Person,Person是自定义的类
         //3,构造请求的header
         Map<String,String> headers = new HashMap<String, String>();
         headers.put("XXX", "XXX");
         headers.put("XXX", "XXX");

         //4,构造自定义的请求
         GsonRequest<Person> jsonRequest = new GsonRequest<Person>(url, Person.class, headers
             , new Response.Listener<Person>() {
                 @Override
                 public void onResponse(Person person) {
                     output.append("onResponse");
                 }
             }, new Response.ErrorListener() {
                 @Override
                 public void onErrorResponse(VolleyError paramVolleyError) {
                     output.append(paramVolleyError.getMessage());
                 }
             });
         //5,将请求加到请求队列中.
         queue.add(jsonRequest);
     }

　　Volley provides ready-to-use JsonArrayRequest and JsonArrayObject classes if you prefer to take that approach. See Using Standard Request Types for more information.