Android Volley框架的使用（二）

  此博文源碼下載地址  https://github.com/Javen205/VolleyDemo.git

使用請求隊列RequestQueue

Volley中的Request都需要添加到RequestQueue中才能執行，所以首先需要創建一個RequestQueue

RequestQueue = Volley.newRequestQueue(mContext);

通常情況在一個應用中需要統一管理一個請求隊列，所以采用單例模式（注意：這不是必須的），創建一個類並在這個類中初始化RequestQueue等核心對象，以及實現一些我們所需的方法；

代碼如下：

package com.javen.volley;

import android.content.Context;
import android.text.TextUtils;

import com.android.volley.Request;
import com.android.volley.RequestQueue;
import com.android.volley.toolbox.ImageLoader;
import com.android.volley.toolbox.Volley;

public class VolleyController {

    // 創建一個TAG，方便調試或Log
    private static final String TAG = "VolleyController";

    // 創建一個全局的請求隊列
    private RequestQueue reqQueue;
    private ImageLoader imageLoader;

    // 創建一個static ApplicationController對象，便於全局訪問
    private static VolleyController mInstance;
    
    private Context mContext;

    private VolleyController(Context context) {
        mContext=context;
    }

    /**
     * 以下為需要我們自己封裝的添加請求取消請求等方法
     */

    // 用於返回一個VolleyController單例
    public static VolleyController getInstance(Context context) {
        if (mInstance == null) {
            synchronized(VolleyController.class)
            {
                if (mInstance == null) {
                    mInstance = new VolleyController(context);
                }
            }
        }
        return mInstance;
    }

    // 用於返回全局RequestQueue對象，如果為空則創建它
    public RequestQueue getRequestQueue() {
        if (reqQueue == null){
            synchronized(VolleyController.class)
            {
                if (reqQueue == null){
                    reqQueue = Volley.newRequestQueue(mContext);
                }
            }
        }
        return reqQueue;
    }
    
    
//    public ImageLoader getImageLoader(){
//        getRequestQueue();
//        //如果imageLoader為空則創建它，第二個參數代表處理圖像緩存的類
//        if(imageLoader==null){
//            imageLoader=new ImageLoader(reqQueue, new LruBitmapCache());
//        }
//        return imageLoader;
//    }


    /**
     * 將Request對象添加進RequestQueue，由於Request有*StringRequest,JsonObjectResquest...
     * 等多種類型，所以需要用到*泛型。同時可將*tag作為可選參數以便標示出每一個不同請求
     */

    public <T> void addToRequestQueue(Request<T> req, String tag) {
        // 如果tag為空的話，就是用默認TAG
        req.setTag(TextUtils.isEmpty(tag) ? TAG : tag);

        getRequestQueue().add(req);
    }

    public <T> void addToRequestQueue(Request<T> req) {
        req.setTag(TAG);
        getRequestQueue().add(req);
    }

    // 通過各Request對象的Tag屬性取消請求
    public void cancelPendingRequests(Object tag) {
        if (reqQueue != null) {
            reqQueue.cancelAll(tag);
        }
    }
}

 

執行異步請求

上篇文章已經提到過，Volley主要提供了以下幾種類型的異步請求：

• JsonObjectRequest 用來接收和發送JsonObject類型的數據
• JsonArrayRequest 用來接收和發送JsonArray類型的數據
• StringRequest 用來接收和發送響應主體為String的數據
  
  

JsonObjectRequest

這是一個用來發送和接收JSON數據最常用的類,覆寫這個類中的一些方法可以發送（GET,POST,DELETE,PUT）等適當的HTTP請求，常見操作代碼示例：

 

final String url="http://xxx";

JsonObjectRequest req=new JsonObjectRequest(url,null,
                            new Response.Listener<JsonObject>(){
    @Override
    public void onResponse(JsonObject response){
    //正確響應時回調此函數
    }

},new ResponseError.Listener(){

    @Override
    public void onErrorResponse(VolleyError error){
            //未正確響應時回調此函數
    }
});
//將請求添加至全局RequestQueue
VolleyController.getInstance(context).addToRequestQueue(req);

 

發送包含HTTP 請求方法(Post Put Get Delete)的 Request：

如果我們想要發送Post,Delete等請求，可通過一個帶請求參數的JsonObject對象來實現

 

//用來保存post參數
HashMap<String,String> params=new HashMap<String,String>();
params.put("user","xxx");

//new JsonObject(params) 作為 JsonObjectRequest 參數
JsonObjectRequest req=new JsonObjectRequest(url,
                        new JsonObject(params),
                    new Response.Listener<JsonObject>(){...},
                    new Response.ErrorListener(){...});

 

發送JsonArrayRequest StringRequest與JsonObjectRequest類似：

JsonArrayRequest req=new JsonArrayRequest(url,
        new Response.Listener<JsonArray>(){..},
        new Response.ErrorListener(){..});
StringRequest req=new StringRequest(url,
        new Response.Listener<String>(){..},
        new Response.ErrorListener(){..});

取消Request

Volley框架提供了強大的API來支持取消正在等待或者運行的一個或多個請求，還記得我們先前提到的setTag()方法嗎，正是通過Tag來標示每個Request，我們特可以通過這個Tag來取消Request

//可以通過setTag方法為每一個Request添加tag
req.setTag("Tag");
//也可以在我們實現的添加進RequestQueue的時候設置
VolleyController.getInstance(context).cancelPendingRequests("Tag");

//取消Request
reqQueue.cancelAll("Tag");
//我們前面實現的方法
VolleyController.getInstance(context).cancelPendingRequests("Tag");

》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》》

學習完上面三個方面的知識，我們就已經差不多掌握了Volley最常用的方法，如果想讓你的應用更健壯，還需要了解Volley中的錯誤處理，設置請求失敗重試機制和超時機制，設置請求優先級，設置請求頭部等等

 

 

拓展部分

請求失敗時的重試和請求自定義超時

 

Volley中提供了一個方案：可以通過Request對象調用setRetryPolicy()方法,設置超時和重試請求

 

 

// 第一個代表超時時間：即超過20S認為超時，第三個參數代表最大重試次數，這里設置為1.0f代表如果超時，則不重試
        req.setRetryPolicy(new DefaultRetryPolicy(20 * 1000, 1, 1.0f));

設置請求優先級

在實際開發中我們常常需要提高一些請求的優先級以便優先執行，可以通過覆寫getPrioriity()方法

//優先級有LOW，NORMAL,HIGH,IMMEDIATE
private Priority priority = Priority.HIGH;

StringRequest strReq = new StringRequest(Method.GET,
          Const.URL_STRING_REQ, 
          new Response.Listener<String>() {

     @Override
     public void onResponse(String response) {
             Log.d(TAG, response.toString());
             msgResponse.setText(response.toString());
             hideProgressDialog();
         }
     }, new Response.ErrorListener() {

      @Override
      public void onErrorResponse(VolleyError error) {
              VolleyLog.d(TAG, "Error: " + error.getMessage());
              hideProgressDialog();
      }
  }) {
     @Override
      public Priority getPriority() { return priority; }
};

 

設置請求頭部（HTTP 頭部）

很多時候需要給HTTP Request添加頭部，一個典型的場景就是基本的HTTP 授權認證，Request類中提供了getHeaders()方法，你需要覆寫並添加自己的自定義頭部

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
    HashMap<String, String> headers = new HashMap<String, String>();
    headers.put("CUSTOM_HEADER", "Yahoo");
    headers.put("ANOTHER_CUSTOM_HEADER", "Google");
    return headers;
}

錯誤處理

你可能已經注意到了在創建Request對象時，構造參數中有new Response.ErrorListener(),這就是典型的錯誤處理

volley中錯誤主要有以下幾類：

• AuthFailureError — 基本的Http身份認證（授權）錯誤.
• NetworkError — 網絡錯誤
• NoConnectionError — 網絡連接錯誤.
• ParseError — 數據解析錯誤.
• ServerError — 服務端錯誤.
• TimeoutError — 超時錯誤.

你可以實現自己的錯誤處理類，用來返回具體的錯誤信息

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<String, String> result = new Gson().fromJson(new String(response.data),
                        new TypeToken<Map<String, String>>() {}.getType());

            if (result != null && result.containsKey("error")) {
                return result.get("error");
            }

            } catch (Exception e) {
                e.printStackTrace();
            }

            return error.getMessage();

            default:
                return context.getResources().getString(R.string.generic_server_down);
            }
        }
        return context.getResources().getString(R.string.generic_error);
      }
    }

總結：

    綜上，我們已經基本上學完了Volley框架的大部分知識，唯一還沒有涉及到且比較重要的就是圖像緩存方面的內容，將在下篇博客中介紹

參考資料：Asynchronous HTTP Requests in Android Using Volley  blog