Volley自定義Request及使用單例封裝RequestQueue

一.自定義Request

Volley的全部的請求的超類型是Resuest，全部咱們經常使用的請求都是這個類的子類，那麼咱們自定義View確定也是基於這個類的。

案例：

 1 package com.zhy.velloydemo;
 2 
 3 import java.io.UnsupportedEncodingException;
 4 import java.util.HashMap;
 5 import java.util.Map;
 6 
 7 import com.android.volley.AuthFailureError;
 8 import com.android.volley.NetworkResponse;
 9 import com.android.volley.ParseError;
10 import com.android.volley.Request;
11 import com.android.volley.Response;
12 import com.android.volley.Response.ErrorListener;
13 import com.android.volley.Response.Listener;
14 import com.android.volley.toolbox.HttpHeaderParser;
15 import com.google.gson.Gson;
16 import com.google.gson.JsonSyntaxException;
17 
18 public class JsonRequestWithAuth<T> extends Request<T>
19 {
20     private final Gson gson = new Gson();
21     private final Class<T> clazz;
22     private final Listener<T> listener;
23 
24     private static Map<String, String> mHeader = new HashMap<String, String>();
25     /**
26      * 設置訪問本身服務器時必須傳遞的參數，密鑰等
27      */
28     static
29     {
30         mHeader.put("APP-Key", "LBS-AAA");
31         mHeader.put("APP-Secret", "ad12msa234das232in");
32     }
33 
34     /**
35      * @param url
36      * @param clazz
37      *            咱們最終的轉化類型
38      * @param headers
39      *            請求附帶的頭信息
40      * @param listener
41      * @param appendHeader
42      *            附加頭數據
43      * @param errorListener
44      */
45     public JsonRequestWithAuth(String url, Class<T> clazz, Listener<T> listener, Map<String, String> appendHeader,
46             ErrorListener errorListener)
47     {
48         super(Method.GET, url, errorListener);
49         this.clazz = clazz;
50         this.listener = listener;
51         mHeader.putAll(appendHeader);
52     }
53 
54     @Override
55     public Map<String, String> getHeaders() throws AuthFailureError
56     {
57         // 默認返回 return Collections.emptyMap();
58         return mHeader;
59     }
60 
61     @Override
62     protected void deliverResponse(T response)
63     {
64         listener.onResponse(response);
65     }
66 
67     @Override
68     protected Response<T> parseNetworkResponse(NetworkResponse response)
69     {
70         try
71         {
72             /**
73              * 獲得返回的數據
74              */
75             String jsonStr = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
76             /**
77              * 轉化成對象
78              */
79             return Response.success(gson.fromJson(jsonStr, clazz), HttpHeaderParser.parseCacheHeaders(response));
80         } catch (UnsupportedEncodingException e)
81         {
82             return Response.error(new ParseError(e));
83         } catch (JsonSyntaxException e)
84         {
85             return Response.error(new ParseError(e));
86         }
87     }
88 }

這裏說一下，我在Header中放置了APP-key等數據，也就是說只要咱們這個請求發的都會有這幾個值，你們開發app時確定有不少請求參數是須要每次都發往服務器校驗的，能夠在這裏設置。

二  使用單例模式（封裝RequestQueue ）

    若是app鏈接網絡比較頻繁，最合理的方式就是把RequestQueue實現爲單實例類型，並這個實例在app運行的整個生命週期中存活。有兩種方式實現 單實例，推薦的一種作法就是實現一個封裝了請求隊列和其餘volley功能的單例類。還有一種不建議使用的方式就是建立一個繼承Application的 字類，並在Application.onCreate（）方法中建立請求隊列。一個靜態的單實例類可以以模塊化的方式提供一樣的功能。

使 用推薦的方式實現單實例最重要的概念就是請求隊列對象必須以應用上下文（application context）而不是活動上下文（activity context）的形式進行實例化。以此確保了請求隊列對象在app運行的整個生命週期中存在，而不是隨着活動的從新建立而建立。結合設計模式單例模式的 實現，來看看MySingleton.java類的實現，這個類提供了一個請求隊列和圖片加載：

 

 1 private static MySingleton mInstance;
 2     private RequestQueue mRequestQueue;
 3     private ImageLoader mImageLoader;
 4     private static Context mCtx;
 5      
 6     private MySingleton(Context context){
 7         mCtx = context;
 8         mRequestQueue = getRequestQueue();
 9          
10         mImageLoader = new ImageLoader(mRequestQueue,n
11               new ImageLoader.ImageCache(){
12                   private final LruCache<String,Bitmap>(20)
13                       cache = new LruCache<String,Bitmap>(20);
14                      
15                    @Override
16                    public Bitmap getBitmap(String url){
17                        return cache.get(url)；                   
18                    }
19                    @Override
20                    public void putBitmap(String url,Bitmap bitmap){
21                        cache.put(url,bitmap);
22                    }
23               });
24     }
25  
26 //異步獲取單實例
27 public static synchronized MySingleton getInstance(Context context){
28     if(mInstance == null){
29         mInstance = new MySingleton(context);
30     }
31     return mInstance
32 }
33  
34 public RequestQueue getRuquestQueue(){
35     if(mRequestQueue == null){
36         //getApplication()方法返回一個當前進程的全局應用上下文，這就意味着
37         //它的使用情景爲：你須要一個生命週期獨立於當前上下文的全局上下文，
38         //即就是它的存活時間綁定在進程中而不是當前某個組建。
39         mRequestQueue = Volley.newRequestQueue(mCtx.getApplication());
40     }
41     return mRequestQueue;
42 }
43  
44 public <T> void addToRequestQueue(Request<T>req){
45     getRequestQueue.add(req);
46 }
47  
48 public ImageLoader getImageLoader(){
49     return mImageLoader;
50 }

在上面的代碼中，構造方法中封裝了請求隊列和圖片加載，接着就是異步獲取實例、獲取請求隊列、把請求添加到請求隊列、獲取圖片加載。

最後咱們使用這個單例類執行請求隊列操做：

1 //獲取請求隊列
2 RequestQueue queue = MySingleton.getInstance(this.getApplication().
3         getRequest();
4 .......
5 //把請求（在這個例子中請求爲StringRequest）添加到請求隊列
6 MySingleton.getInstance(this).addToRequestQueue(StringRequest);

 

參考自：

http://my.oschina.net/huangwenwei/blog/287611

http://blog.csdn.net/lmj623565791/article/details/24589837