网络框架之----Volley的封装

Volley封装get请求和post请求

• 定义请求回调的接口

public interface NetListener {
    //参数 就是解析后的数据
    void successListener(T response );
    //参数 对错误信息进行操作
    void errorListener(VolleyError error);
}

• 创建Volley请求

/**
 * 这个请求可以直接将数据进行解析,所以可以直接使用请求后的数据
 */

public class GsonRequest<T> extends Request<T> {
    private Gson mGson;
    private Response.Listener mListener;
    private Class mClass;
    //这是用于post请求的map
    private HashMap map;



    //用于get请求
    public GsonRequest(int method, String url, Response.ErrorListener listener, Response.Listener listener1, Class aClass) {
        super(method, url, listener);
        mListener = listener1;
        mClass = aClass;
        mGson = new Gson();
    }

    //这是用于post接口数据的请求
    public GsonRequest(int method, String url, Response.ErrorListener listener, Response.Listener listener1, Class aClass, HashMap map) {
        super(method, url, listener);
        mGson = new Gson();
        mListener = listener1;
        mClass = aClass;
        this.map = map;
    }

    //请求网络数据
    @Override
    protected Response parseNetworkResponse(NetworkResponse response) {
        try {
            //这是我们请求下来的数据
            String data = new String(response.data,
                    HttpHeaderParser.parseCharset(response.headers));
            //我们直接将请求好的数据写在请求成功的方法之中
            //第一参数是解析好的的数据
            //第二参数是缓存类
            return Response.success(mGson.fromJson(data, mClass),
                    HttpHeaderParser.parseCacheHeaders(response));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            //这是网络请求失败的返回结果
            return Response.error(new ParseError(e));
        }

    }

    @Override
    protected Map getParams() throws AuthFailureError {
        return map;
    }

    //分发事件
    @Override
    protected void deliverResponse(T response) {
        mListener.onResponse(response);
    }
    //数据缓存
    @Override
    public void deliverError(VolleyError error) {
        //判断 如果没有网络连接 这时我们要使用缓存数据
        if(error instanceof NoConnectionError){

            Log.d("GsonRequest", "我是缓存的数据");
            //获取缓存数据
            Cache.Entry entry = this.getCacheEntry();
            //创建请求 请求的数据就是我们自己缓存的数据
            Response response = parseNetworkResponse
                    (new NetworkResponse(entry.data,entry.responseHeaders));
            deliverResponse(response.result);
        }
        super.deliverError(error);
    }
}

• NetHelper工具类

public class NetHelper {
    private RequestQueue mRequestQueue;

    private static NetHelper ourInstance = new NetHelper();

    //在单例模式中我们对外提供了一个方法来获取对象
    public static NetHelper getInstance() {
        return ourInstance;
    }
    //为什么要把构造方法私有化?
    //不想让别人创建出对象,所以私有化 我们只使用对外提供的方法获取本类的对象
    private NetHelper() {
        getRequestQueue();
    }

    //双重校验锁
    private RequestQueue getRequestQueue(){
        //第一个判断是用于提高代码效率的
        //如果多个地方使用了这个单例,那么第一层判断就可以直接创建队列,
        // 不为空的情况就直接返回队列
        if (mRequestQueue == null){
            //加锁 保证线程不会拥挤阻塞
            synchronized (NetHelper.class){
                //如果队列为空 创建我们自己的队列
                if (mRequestQueue == null){
                    mRequestQueue = Volley.newRequestQueue(MyApp.getmContext());
                }
            }
        }
        return mRequestQueue;
    }
    /************************私有化的方法************************************/
    //这是最最基本的请求方式
    private  void baseRequest(Request request){
        mRequestQueue.add(request);
    }



    private  void baseGsonRequest(String url , Class mClass, final NetListener listener){
        GsonRequest gsonRequest = new GsonRequest(Request.Method.GET, url, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                listener.errorListener(error);
            }
        }, new Response.Listener() {
            @Override
            public void onResponse(T response) {
                listener.successListener(response);
            }
        },mClass);
        mRequestQueue.add(gsonRequest);
    }




    private  void baseGsonPostRequest(String url, Class mClass,final NetListener listener, HashMap map){
        GsonRequest gsonRequest = new GsonRequest(Request.Method.POST, url, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                listener.errorListener(error);
            }
        }, new Response.Listener() {
            @Override
            public void onResponse(T response) {
                listener.successListener(response);
            }
        },mClass,map);
        mRequestQueue.add(gsonRequest);
    }





    private void baseStringRequest(String url, final NetListener listener){
        StringRequest stringRequest = new StringRequest(url, new Response.Listener() {
            @Override
            public void onResponse(String response) {
                listener.successListener(response);
            }
        }, new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                listener.errorListener(error);
            }
        });
          mRequestQueue.add(stringRequest);

    }
    /******************对外提供的方法************************************/

    public static  void MySRequest(String url,NetListener listener){
        getInstance().baseStringRequest(url,listener);
    }
    public static  void MyRequest(String url,Class mClass,NetListener listener){
        getInstance().baseGsonRequest(url,mClass,listener);
    }
    public static  void MyRequest(String url,Class mClass,NetListener listener,HashMap map){
        getInstance().baseGsonPostRequest(url,mClass,listener,map);
    }
}

• 在Activity中使用

//get请求用法
        NetHelper.MyRequest(url,实体类.class,定义的请求回调)

//post请求用法
        HashMap<String,String> map = new HashMap<>();
        map.put(key,value);
        NetHelper.MyRequest(url,实体类.class,定义的请求回调);