安卓中自定義並使用Volley框架請求網路

大家好，今天我們講一下如何使用Volley框架請求網路，為何要使用Volley框架，這就要先說一下使用Volley框架請求網路的優點了，volley是易於定製的，即你可以根據需求來設定volley框架，還有volley框架支持請求的優先順序設定，即你可以自主設定網路請求的優先順序，還有就是volley框 ...

　　大家好，今天我們講一下如何使用Volley框架請求網路，為何要使用Volley框架，這就要先說一下使用Volley框架請求網路的優點了，volley是易於定製的，即你可以根據需求來設定volley框架，還有volley框架支持請求的優先順序設定，即你可以自主設定網路請求的優先順序，還有就是volley框架請求支持取消單個或多個請求，這個一會設置請求的時候會特別說明，還有它可以自動調度網路請求，至於其他的如代碼的健壯性、支持多併發等等就不一一列舉了，說了那麼多下麵就介紹如何自定義並使用Volley框架：

　　第一步：定義netrequest類繼承StringRequest類

　　1、在這個類里首先要自定義三個全局變數，

 1 private Priority priority;
 2 private Map<String,String> headers ;
 3 private Map<String,String> params;
 4 
 5 /**
 6      * 初始化全局變數
 7 */
 8 private void init(){
 9 priority = Priority.NORMAL;
10 headers = new HashMap<>();
11 params = new HashMap<>();
12     }

　　2、實現兩個有參構造，在這兩個構造方法中並不需要再多些什麼，只要初始化自定義的三個全局變數。

1 public NetRequest(int method, String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
2 super(method, url, listener, errorListener);
3         init();
4     }
5 
6 public NetRequest(String url, Response.Listener<String> listener, Response.ErrorListener errorListener) {
7 super(url, listener, errorListener);
8         init();
9     }

　　3、重寫設置優先順序的方法

1 //設置優先順序
2 @Override
3 public Priority getPriority() {
4 return priority;
5     }

　　4、重寫為請求添加請求頭信息的方法

 1 //為請求添加頭信息的方法
 2 @Override
 3 public Map<String, String> getHeaders() throws AuthFailureError {
 4 return headers;
 5     }
 6 
 7 @Override
 8 public Map<String, String> getParams()throws AuthFailureError{
 9 return params;
10     }
11 
12 public NetRequest setPriority(Priority priority){
13 this.priority = priority;
14 return this;
15     }
16 
17 public NetRequest addRequestHeader(String key,String value){
18 this.headers.put(key,value);
19 return this;
20     }
21 
22 public NetRequest addParams(String key,String value){
23 this.params.put(key, value);
24 return this;
25     }

　　5、自定義一個發送請求的方法，其中VolleyUtil類為一個工具類，是自己定義的下一步就是定義它

1 /**
2      * 發送請求
3 */
4 public void start(){
5             VolleyUtil.start(this);
6         }

　　6、自定義一個靜態類Builder為網路請求傳參，這也被稱作構造者模式

 1 //構造者模式
 2 public static class Builder{
 3 
 4 　　private String url;
 5 　　private int method;
 6 　　private CallBack callBack;
 7 
 8 　　public Builder setCallBack(CallBack callBack){
 9 　　　　this.callBack  = callBack;
10 　　　　return this;
11       }
12 　　public Builder setUrl(String url){
13 　　　　this.url = url;
14 　　　　return this;
15       }
16 　　public Builder setMethod(int method){
17 　　　　this.method = method;
18 　　　　return this;
19       }
20　　}

　　7、自定義一個buileder方法請求網路返回NetRequest（這一步比較關鍵）

 1       /**
 2          * 創建一個NetRequest請求網路
 3          * @return  NetRequest
 4          */
 5     public NetRequest build(){
 6             NetRequest nr = new NetRequest(
 7                 method, 
 8                 url,
 9                 new Response.Listener<String>() {
10                     @Override
11                     public void onResponse(String response) {
12                         if (callBack!=null){
13                                 callBack.onSuccess(response);
14                             }
15                      }
16                 },
17                 new Response.ErrorListener() {
18                     @Override
19                     public void onErrorResponse(VolleyError error) {
20                         if (callBack!=null){
21                             callBack.onError(error);
22                             }
23                         }
24                  });
25         return nr;
26         }

　　8、定義一個介面Callback包含兩個抽象方法來實現請求網路四個參數的後兩個（因為網路請求是一個一步的操作，所以請求的時候需要自定義一個類實現這個藉口並重寫介面中的這兩個方法）

1 import com.android.volley.VolleyError;
2 
3     /**
4      * Created by zhangdi on 2016/8/8.
5      */
6     public interface CallBack {
7         public void onSuccess(String respone);
8         public void onError(VolleyError error);
9     }

　　第二步：自定義一個工具類（就是第一步中start方法中的那個工具類，裡面的方法都設置成靜態的方便調用，這也是工廠模式的一種）

　　1、首先要初始化請求隊列

 1 private static RequestQueue requestQueue;
 2     /**
 3      * 初始化請求隊列
 4      * @param mContext
 5      */
 6     public static void init(Context mContext){
 7         if (requestQueue==null){
 8             requestQueue = Volley.newRequestQueue(mContext);
 9         }
10     }

　　2、設置get請求方法

 1 　　 /**
 2      * get請求
 3      * @param url
 4      * @return
 5      */
 6     public static NetRequest.Builder get(String url){
 7         return new NetRequest.Builder()
 8                     .setMethod(Request.Method.GET)
 9                     .setUrl(url);
10     }

　　3、設置post請求方法

1     /**
2      * post請求
3      * @return
4      */
5     public static NetRequest.Builder post(String url){
6         return new NetRequest.Builder()
7                 .setMethod(Request.Method.POST)
8                 .setUrl(url);
9     }

　　4、定義開始運行start方法（即將請求添加到請求隊列）

1     /**
2      *將請求添加到請求隊列
3      */   
4     public  static void start(NetRequest nr){
5         requestQueue.add(nr);
6     }

　　5、設置取消請求方法(利用方法重載來實現取消一個和取消一組)

1     //方法重載
2     public static void cancel(Object tag){
3         requestQueue.cancelAll(tag);
4     }
5 
6     public static void cancel(RequestQueue.RequestFilter filter){
7         requestQueue.cancelAll(filter);
8     }

這裡的cancel()方法第一個請求取消方法是把所有請求都取消，第二個請求取消方法是自定義選擇性的取消某個請求

　　第三步：調用封裝好的靜態類實現請求網路

　　<1>先講一下使用get請求網路

　　　　1、定義一個內部類即網路回調，實現Callback介面並重寫其中的兩個方法，需要如何重寫我已經在代碼塊中說明瞭，大家仔細閱讀

 1     private  class NetCallBack1 implements CallBack {
 2         @Override
 3         public void onSuccess(String respone) {
 4            這裡是請求成功是執行的操作
 5            記住網路請求都是非同步的，所以載入數據更新界面的功能都必須在這裡實現
 6            不然會報空指針的錯誤
 7         }
 8 
 9        @Override
10        public void onError(VolleyError error) {
11             這裡是執行網路請求不成功後執行的操作
12        }
13 }

　　　　2、利用工廠模式進行請求網路

1 VolleyUtil.get(你請求的網路介面)
2                 .setCallBack(new NetCallBack())//這是上一步自定義的回調函數
3                 .build()
4                 .setPriority(Request.Priority.HIGH)
5                 .addRequestHeader("apikey","你自己的apiley")
6                 .start();

　　<2>再講一下如何使用post請求

　　　　我這裡就直接在在調用的時候就實現了callback介面，不再單獨實現了

 1 VolleyUtil.post("http://192.168.191.1:8080/Server/doReg.jsp")
 2                  .setCallBack(new CallBack() {
 3                     @Override
 4                     public void onSuccess(String respone) {
 5                           請求成功是執行的步驟
 6                     }
 7 
 8                    @Override
 9                     public void onError(VolleyError error) {
10                           請求不成功時執行的步驟
11                     }
12                 })
13                 .build()
14                 .addParams("name","張三")
15                 .addParams("pwd","12345678")
16                 .setTag("post")
17                 .start();

其中addParams方法是在第二步NetRequest中有專門的定義，代碼可以在第一步中尋找到

　　至此使用volley框架請求網路的步驟就算完成了，看起來定義比較麻煩，但是這是一勞永逸的，你在工程中只需要定義一遍，就可以在工程中需要網路請求的地方直接可以調用，註意的是網路請求還需要設置請求許可權（如果大家不清楚如何設置可以去我寫的關於定位的那篇文章中找到），這個需要在清單文件中申明，還有是如果你想一勞永逸還需要給工具類VolleyUtil進行初始化，這段代碼可以放在全局類中即Application類中，代碼如下：

 1 /**
 2  * Created by zhangdi on 2016/8/23.
 3  */
 4 public class MyApplication extends Application {
 5 
 6     @Override
 7     public void onCreate() {
 8         super.onCreate();
 9         VolleyUtil.init(this);//初始化請求隊列
10     }
11 
12 }

　　好了，到此自定義並使用Volley框架請求網路數據的步驟就算全部結束了，當然網路請求框架有很多種，Volley並不是最好的，但是它的優點也特別顯明，所以在對於輕量級的請求網路數據時，使用Volley框架還是弊大於利的，這裡筆者還是比較建議使用的。還是如果大家感覺這篇文章還不錯的話就麻煩給推薦一下，若是有哪些地方總結的不對或是知識點有錯誤的地方還是希望大家評論指正，謝謝。