volley二次封装

android应用很多都要涉及网络操作，Android SDK中提供了HttpClient 和 HttpUrlConnection两种方式用来处理网络操作， 但当应用比较复杂的时候需要我们编写大量的代码处理很多东西：
很容易就会写出不少重复代码。
一些Android网络通信框架也就应运而生，比如volley，是非常适合去进行数据量不大，但通信频繁的网络操作，而对于大数据量的网络操作，比如说下载文件等，Volley的表现就会非常糟糕。
对volley进行二次封装，使应用编写代码是特别简单。
1、引进volley jar

compile 'eu.the4thfloor.volley:com.android.volley:2015.05.28'

2、在自定义application创建全局的请求队列

public class BaseApplication extends Application {

    //建立全局的请求队列
    public static RequestQueue mQueues;

    @Override
    public void onCreate() {
        super.onCreate();

        mQueues= Volley.newRequestQueue(getApplicationContext());
    }

    public static RequestQueue getHttpQueue(){
        return mQueues;
    }
}

3、封装volley成功回调和失败回调的方法

public abstract class VolleyInterface {
    public Context mContext;
    public static Response.Listener<String> mListener;
    public static Response.ErrorListener mErrorListener;

    public VolleyInterface(Context mContext,Response.Listener<String> mListener,Response.ErrorListener mErrorListener) {
        this.mContext = mContext;
        this.mListener=mListener;
        this.mErrorListener=mErrorListener;
    }

    public abstract void onSuccess(String result);
    public abstract void onError(VolleyError error);

    /**
     * 成功回调
     * @return Response.Listener<String>
     */
    public Response.Listener<String> loadingListener(){
        mListener=new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
                onSuccess(response);
            }
        };
        return mListener;
    }

    /**
     * 失败回调
     * @return
     */
    public Response.ErrorListener errorListener(){
        mErrorListener=new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                onError(error);
            }
        };
        return mErrorListener;
    }
}

4、自定义volley get、post方法

public class VolleyRequest {
    public static Context mContext;
    public static StringRequest mStringRequest;

    /**
     * get请求
     * @param mContext
     * @param url
     * @param tag
     * @param vif
     */
    public static void requestGet(Context mContext,String url,String tag,VolleyInterface vif){
        BaseApplication.getHttpQueue().cancelAll(tag);
        mStringRequest=new StringRequest(Request.Method.GET,url,vif.loadingListener(),vif.errorListener());
        mStringRequest.setTag(tag);
        BaseApplication.getHttpQueue().add(mStringRequest);
        BaseApplication.getHttpQueue().start();
    }

    /**
     * post请求（带有map传递参数）
     * @param mContext
     * @param url
     * @param tag
     * @param params
     * @param vif
     */
    public static void requestPost(Context mContext, String url, String tag, final Map<String, String> params,VolleyInterface vif){
        BaseApplication.getHttpQueue().cancelAll(tag);
        mStringRequest = new StringRequest(Request.Method.POST,url, vif.loadingListener(), vif.errorListener()) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                System.out.println("params:"+params);
                return params;
            }
        };

        mStringRequest.setTag(tag);
        BaseApplication.getHttpQueue().add(mStringRequest);
        BaseApplication.getHttpQueue().start();

    }

    /**
     * post请求(带有参数map 重写传递参数方法)
     *
     * @param mContext
     * @param url 地址
     * @param tag  标签
     * @param params 参数
     * @param vif 接口
     * void
     *
     */
    public static void requestSpecPost(Context mContext, String url, String tag, final Map<String, String> params,
                                       VolleyInterface vif) {
        BaseApplication.getHttpQueue().cancelAll(tag);
        mStringRequest = new StringRequest(Request.Method.POST,url, vif.loadingListener(), vif.errorListener()) {
            @Override
            protected Map<String, String> getParams() throws AuthFailureError {
                System.out.println("params:"+params);
                return params;
            }

            @Override
            public byte[] getBody() throws AuthFailureError {
                Map<String, String> params = getParams();
                if (params != null && params.size() > 0) {
                    try {
                        return params.get("data").getBytes("UTF-8");
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                }
                return null;
            }
        };

        mStringRequest.setTag(tag);
        BaseApplication.getHttpQueue().add(mStringRequest);
        BaseApplication.getHttpQueue().start();
    }
}

5、volley访问失败会有很多种情况，如访问服务器失败，网络连接失败等等，吧volley错误失败封装一个工具类

public class VolleyErrorHelper {

    /**
     * volley返回信息
     *
     *
     * @param error
     * @param context
     * @return String
     */
    public static String getMessage(Object error,Context context){
        if(error instanceof TimeoutError){
            return "连接服务器超时";
        }else if(isServerProblem(error)){
            return handleServerError(error,context);
        }else if(isNetworkError(error)){
            return "当前网络不稳定，请重新再试";
        }else if(isNoConnectionError(error)){
            return "无网络连接";
        }
        return "当前网络不稳定，请重新再试";
    }

    private static  boolean isNetworkError(Object error) {
        return (error instanceof NetworkError);
    }

    private static  boolean isNoConnectionError(Object error) {
        return (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:
                    return "连接服务器失败";

                default:
                    return "连接服务器超时";
            }
        }
        return "当前网络不稳定，请重新再试";
    }
}

6、volley接口、方法等写好后，在需要网络访问服务器数据时，只需调用写好的接口即可，如

private void loginPost() {
        String url="http://123.15.53.83/dcapi/api/app/gys/login";//访问地址

        //传递参数
        Map<String, String> params = new HashMap<String, String>();
        params.put("userName", "1111111");
        params.put("userPass", "0");

        VolleyRequest.requestPost(mContext, url, "", params, new VolleyInterface(this, VolleyInterface.mListener,VolleyInterface.mErrorListener) {
            @Override
            public void onSuccess(String result) {
            //访问结果
                Log.d("********************",result);
            }

            @Override
            public void onError(VolleyError error) {
              //返回失败的原因  Log.d("%%%%%%%%%%%%%",VolleyErrorHelper.getMessage(error,mContext));
            }
        });
    }