谷歌Volley框架讲解——第二篇

Volley提供的功能

简单的讲，提供了如下主要的功能：

1、封装了的异步的RESTful 请求API；

2、一个优雅和稳健的请求队列；

3、一个可扩展的架构，它使开发人员能够实现自定义的请求和响应处理机制；

4、能够使用外部HTTP Client库；

5、缓存策略；

6、自定义的网络图像加载视图（NetworkImageView，ImageLoader等);

使用请求队列

Volley的所有请求都放在一个队列，然后进行处理，这里是你如何将创建一个请求队列：

RequestQueue mRequestQueue = Volley.newRequestQueue(this); // 'this' is Context

理想的情况是把请求队列集中放到一个地方，最好是初始化应用程序类中初始化请求队列，下面类做到了这一点：

public class ApplicationController extends Application {

    public static final String TAG = "VolleyPatterns";

    private RequestQueue mRequestQueue;

    private static ApplicationController sInstance;

    @Override

    public void onCreate() {

        super.onCreate();

        // initialize the singleton

        sInstance = this;

    }

    public static synchronized ApplicationController getInstance() {

        return sInstance;

    }

    public RequestQueue getRequestQueue() {

        // lazy initialize the request queue, the queue instance will be

        // created when it is accessed for the first time

        if (mRequestQueue == null) {

            mRequestQueue = Volley.newRequestQueue(getApplicationContext());

        }

        return mRequestQueue;

    }

    public  void addToRequestQueue(Request req, String tag) {

        // set the default tag if tag is empty

        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        VolleyLog.d("Adding request to queue: %s", req.getUrl());

        getRequestQueue().add(req);

    }

    public  void addToRequestQueue(Request req) {

        // set the default tag if tag is empty

        req.setTag(TAG);

        getRequestQueue().add(req);

    }

    public void cancelPendingRequests(Object tag) {

        if (mRequestQueue != null) {

            mRequestQueue.cancelAll(tag);

        }

    }

异步的JSON、String请求

Volley提供了以下的实用工具类进行异步HTTP请求：

JsonObjectRequest — To send and receive JSONObject from the Server

JsonArrayRequest — To receive JSON Array from theServer

StringRequest — To retrieve response body asString (ideally if you intend to parse the response byyourself)

JsonObjectRequest

这个类可以用来发送和接收JSON对象。这个类的一个重载构造函数允许设置适当的请求方法（DELETE，GET，POST和PUT）。如果您正在使用一个RESTful服务端，可以使用这个类。下面的示例显示如何使GET和POST请求。

GET请求：

ffinal String URL = "/volley/resource/12";

// pass second argument as "null" for GET requests

JsonObjectRequest req = new JsonObjectRequest(URL, null,

       new Response.Listener() {

           @Override

           public void onResponse(JSONObject response) {

               try {

                   VolleyLog.v("Response:%n %s", response.toString(4));

               } catch (JSONException e) {

                   e.printStackTrace();

               }

           }

       }, new Response.ErrorListener() {

           @Override

           public void onErrorResponse(VolleyError error) {

               VolleyLog.e("Error: ", error.getMessage());

           }

       });

// add the request object to the queue to be executed

ApplicationController.getInstance().addToRequestQueue(req);

POST请求：

final String URL = "/volley/resource/12";

// Post params to be sent to the server

HashMap params = new HashMap();

params.put("token", "AbCdEfGh123456");

JsonObjectRequest req = new JsonObjectRequest(URL, new JSONObject(params),

       new Response.Listener() {

           @Override

           public void onResponse(JSONObject response) {

               try {

                   VolleyLog.v("Response:%n %s", response.toString(4));

               } catch (JSONException e) {

                   e.printStackTrace();

               }

           }

       }, new Response.ErrorListener() {

           @Override

           public void onErrorResponse(VolleyError error) {

               VolleyLog.e("Error: ", error.getMessage());

           }

       });

// add the request object to the queue to be executed

ApplicationController.getInstance().addToRequestQueue(req);

JsonArrayRequest

这个类可以用来接受 JSON Arrary，不支持JSON Object。这个类现在只支持 HTTPGET。由于支持GET，你可以在URL的后面加上请求参数。类的构造函数不支持请求参数。

final String URL = "/volley/resource/all?count=20";

JsonArrayRequest req = new JsonArrayRequest(URL, new Response.Listener () {

    @Override

    public void onResponse(JSONArray response) {

        try {

            VolleyLog.v("Response:%n %s", response.toString(4));

        } catch (JSONException e) {

            e.printStackTrace();

        }

    }

}, new Response.ErrorListener() {

    @Override

    public void onErrorResponse(VolleyError error) {

        VolleyLog.e("Error: ", error.getMessage());

    }

});

StringRequest

这个类可以用来从服务器获取String，如果想自己解析请求响应可以使用这个类，例如返回xml数据。它还可以使用重载的构造函数定制请求。

final String URL = "/volley/resource/recent.xml";

StringRequest req = new StringRequest(URL, new Response.Listener() {

    @Override

    public void onResponse(String response) {

        VolleyLog.v("Response:%n %s", response);

    }

}, new Response.ErrorListener() {

    @Override

    public void onErrorResponse(VolleyError error) {

        VolleyLog.e("Error: ", error.getMessage());

    }

});

// add the request object to the queue to be executed

ApplicationController.getInstance().addToRequestQueue(req);

取消请求

Volley提供了强大的API取消未处理或正在处理的请求。取消请求最简单的方法是调用请求队列cancelAll（tag）的方法，前提是你在添加请求时设置了标记。这样就能使标签标记的请求挂起。

给请求设置标签：

request.setTag("My Tag");

使用ApplicationController添加使用了标签的请求到队列中：

ApplicationController.getInstance().addToRequestQueue(request, "My Tag");

取消所有指定标记的请求：

mRequestQueue.cancelAll("My Tag");

重试失败的请求，自定义请求超时

Volley中没有指定的方法来设置请求超时时间，可以设置RetryPolicy来变通实现。DefaultRetryPolicy类有个initialTimeout参数，可以设置超时时间。要确保最大重试次数为1，以保证超时后不重新请求。

Setting Request Timeout

request.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1,1.0f));

设置请求头（HTTP headers）      如果你想失败后重新请求（因超时），您可以指定使用上面的代码，增加重试次数。注意最后一个参数，它允许你指定一个退避乘数可以用来实现“指数退避”来从RESTful服务器请求数据。

有时候需要给HTTP请求添加额外的头信息，一个常用的例子是添加 “Authorization”到HTTP请求的头信息。Volley请求类提供了一个 getHeaers（）的方法，重载这个方法可以自定义HTTP 的头信息。

添加头信息：

JsonObjectRequest req = new JsonObjectRequest(URL, 

         new JSONObject(params),
           new Response.Listener() {

             @Override
               public void onResponse(JSONObject response) {
                   // handle response 

           } 

         }, new Response.ErrorListener() {

              @Override
               public void onErrorResponse(VolleyError error) {
                   // handle error 

                  }
           }) {

             @Override 

                public Map getHeaders() throws AuthFailureError { 

                           HashMap headers = new HashMap();
           headers.put("CUSTOM_HEADER", "Yahoo");                                     headers.put("ANOTHER_CUSTOM_HEADER", "Google"); 

                            return headers; 

                 }

           };

使用Cookies

Volley中没有直接的API来设置cookies，Volley的设计理念就是提供干净、简洁的API来实现RESTfulHTTP请求，不提供设置cookies是合理的。

下面是修改后的ApplicationController类，这个类修改了getRequestQueue()方法，包含了设置cookie方法，这些修改还是有些粗糙。

private DefaultHttpClient mHttpClient;

public RequestQueue getRequestQueue() {

    // lazy initialize the request queue, the queue instance will be

    // created when it is accessed for the first time

    if (mRequestQueue == null) {

        // Create an instance of the Http client. 

        // We need this in order to access the cookie store

        mHttpClient = new DefaultHttpClient();

        // create the request queue

        mRequestQueue = Volley.newRequestQueue(this, new HttpClientStack(mHttpClient));

    }

    return mRequestQueue;

}

public void setCookie() {

    CookieStore cs = mHttpClient.getCookieStore();

    // create a cookie

    cs.addCookie(new BasicClientCookie2("cookie", "spooky"));

}

// add the cookie before adding the request to the queue

setCookie();

// add the request to the queue

mRequestQueue.add(request);

错误处理

正如前面代码看到的，在创建一个请求时，需要添加一个错误监听onErrorResponse。如果请求发生异常，会返回一个VolleyError实例。

以下是Volley的异常列表：

AuthFailureError：如果在做一个HTTP的身份验证，可能会发生这个错误。

NetworkError：Socket关闭，服务器宕机，DNS错误都会产生这个错误。

NoConnectionError：和NetworkError类似，这个是客户端没有网络连接。

ParseError：在使用JsonObjectRequest或JsonArrayRequest时，如果接收到的JSON是畸形，会产生异常。

SERVERERROR：服务器的响应的一个错误，最有可能的4xx或5xx HTTP状态代码。

TimeoutError：Socket超时，服务器太忙或网络延迟会产生这个异常。默认情况下，Volley的超时时间为2.5秒。如果得到这个错误可以使用RetryPolicy。

可以使用一个简单的Help类根据这些异常提示相应的信息：

public class VolleyErrorHelper {

  public static String getMessage(Object error, Context context) {

      if (error instanceof TimeoutError) {

          return context.getResources().getString(R.string.generic_server_down);

      }

      else if (isServerProblem(error)) {

          return handleServerError(error, context);

      }

      else if (isNetworkProblem(error)) {

          return context.getResources().getString(R.string.no_internet);

      }

      return context.getResources().getString(R.string.generic_error);

  }

  private static boolean isNetworkProblem(Object error) {

      return (error instanceof NetworkError) || (error instanceof NoConnectionError);

  }

  private static boolean isServerProblem(Object error) {

      return (error instanceof ServerError) || (error instanceof AuthFailureError);

  }

  private static String handleServerError(Object err, Context context) {

      VolleyError error = (VolleyError) err;

      NetworkResponse response = error.networkResponse;

      if (response != null) {

          switch (response.statusCode) {

            case 404:

            case 422:

            case 401:

                try {

                    // server might return error like this { "error": "Some error occured" }

                    // Use "Gson" to parse the result

                    HashMap result = new Gson().fromJson(new String(response.data),

                            new TypeToken

                            }.getType());

                    if (result != null && result.containsKey("error")) {

                        return result.get("error");

                    }

                } catch (Exception e) {

                    e.printStackTrace();

                }

                // invalid request

                return error.getMessage();

            default:

                return context.getResources().getString(R.string.generic_server_down);

            }

      }

        return context.getResources().getString(R.string.generic_error);

  }

}

总结：

Volley是一个非常好的库，你可以尝试使用一下，它会帮助你简化网络请求，带来更多的益处。