Volley自定义Request及使用单例封装RequestQueue

一.自定义Request

Volley的所有的请求的超类型是Resuest，所有我们常用的请求都是这个类的子类，那么我们自定义View肯定也是基于这个类的。

案例：

 package com.zhy.velloydemo;
 
 import java.io.UnsupportedEncodingException;
 import java.util.HashMap;
 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 JsonRequestWithAuth<T> extends Request<T>
 {
     private final Gson gson = new Gson();
     private final Class<T> clazz;
     private final Listener<T> listener;
 
     private static Map<String, String> mHeader = new HashMap<String, String>();
     /**
      * 设置访问自己服务器时必须传递的参数，密钥等
      */
     static
     {
         mHeader.put("APP-Key", "LBS-AAA");
         mHeader.put("APP-Secret", "ad12msa234das232in");
     }
 
     /**
      * @param url
      * @param clazz
      *            我们最终的转化类型
      * @param headers
      *            请求附带的头信息
      * @param listener
      * @param appendHeader
      *            附加头数据
      * @param errorListener
      */
     public JsonRequestWithAuth(String url, Class<T> clazz, Listener<T> listener, Map<String, String> appendHeader,
             ErrorListener errorListener)
     {
         super(Method.GET, url, errorListener);
         this.clazz = clazz;
         this.listener = listener;
         mHeader.putAll(appendHeader);
     }
 
     @Override
     public Map<String, String> getHeaders() throws AuthFailureError
     {
         // 默认返回 return Collections.emptyMap();
         return mHeader;
     }
 
     @Override
     protected void deliverResponse(T response)
     {
         listener.onResponse(response);
     }
 
     @Override
     protected Response<T> parseNetworkResponse(NetworkResponse response)
     {
         try
         {
             /**
              * 得到返回的数据
              */
             String jsonStr = new String(response.data, HttpHeaderParser.parseCharset(response.headers));
             /**
              * 转化成对象
              */
             return Response.success(gson.fromJson(jsonStr, clazz), HttpHeaderParser.parseCacheHeaders(response));
         } catch (UnsupportedEncodingException e)
         {
             return Response.error(new ParseError(e));
         } catch (JsonSyntaxException e)
         {
             return Response.error(new ParseError(e));
         }
     }
 }

这里说一下，我在Header中放置了APP-key等数据，也就是说只要我们这个请求发的都会有这几个值，大家开发app时肯定有很多请求参数是需要每次都发往服务器校验的，可以在这里设置。

二  使用单例模式（封装RequestQueue ）

如果app连接网络比较频繁，最合理的方式就是把RequestQueue实现为单实例类型，并这个实例在app运行的整个生命周期中存活。有两种方式实现 单实例，推荐的一种做法就是实现一个封装了请求队列和其他volley功能的单例类。还有一种不建议使用的方式就是创建一个继承Application的 字类，并在Application.onCreate（）方法中创建请求队列。一个静态的单实例类能够以模块化的方式提供同样的功能。

使 用推荐的方式实现单实例最重要的概念就是请求队列对象必须以应用上下文（application context）而不是活动上下文（activity context）的形式进行实例化。以此确保了请求队列对象在app运行的整个生命周期中存在，而不是随着活动的重新创建而创建。结合设计模式单例模式的 实现，来看看MySingleton.java类的实现，这个类提供了一个请求队列和图片加载：

 private static MySingleton mInstance;
     private RequestQueue mRequestQueue;
     private ImageLoader mImageLoader;
     private static Context mCtx;
 
     private MySingleton(Context context){
         mCtx = context;
         mRequestQueue = getRequestQueue();
 
         mImageLoader = new ImageLoader(mRequestQueue,n
               new ImageLoader.ImageCache(){
                   private final LruCache<String,Bitmap>(20)
                       cache = new LruCache<String,Bitmap>(20);
 
                    @Override
                    public Bitmap getBitmap(String url){
                        return cache.get(url)；
                    }
                    @Override
                    public void putBitmap(String url,Bitmap bitmap){
                        cache.put(url,bitmap);
                    }
               });
     }
 
 //异步获取单实例
 public static synchronized MySingleton getInstance(Context context){
     if(mInstance == null){
         mInstance = new MySingleton(context);
     }
     return mInstance
 }
 
 public RequestQueue getRuquestQueue(){
     if(mRequestQueue == null){
         //getApplication()方法返回一个当前进程的全局应用上下文，这就意味着
         //它的使用情景为：你需要一个生命周期独立于当前上下文的全局上下文，
         //即就是它的存活时间绑定在进程中而不是当前某个组建。
         mRequestQueue = Volley.newRequestQueue(mCtx.getApplication());
     }
     return mRequestQueue;
 }
 
 public <T> void addToRequestQueue(Request<T>req){
     getRequestQueue.add(req);
 }
 
 public ImageLoader getImageLoader(){
     return mImageLoader;
 }

在上面的代码中，构造方法中封装了请求队列和图片加载，接着就是异步获取实例、获取请求队列、把请求添加到请求队列、获取图片加载。

最后我们使用这个单例类执行请求队列操作：

 //获取请求队列
 RequestQueue queue = MySingleton.getInstance(this.getApplication().
         getRequest();
 .......
 //把请求（在这个例子中请求为StringRequest）添加到请求队列
 MySingleton.getInstance(this).addToRequestQueue(StringRequest);

参考自：

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

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