Volley的简单封装

vollery请求管理类

public class SvcCallHelper{
    private static SvcCallHelper INSTANCE;
    private static Object LOCK = new Object();

    public static final String VolleyRequestTag = "VolleyPatterns";

    private RequestQueue mVolleyReqQueue;
    private JsonObjectRequest mJSONObjectRequest = null;
    private StringRequest mStringRequest = null;
    @SuppressWarnings("unused")
    private JSONObject mJSONRspObj;
    @SuppressWarnings("unused")
    private JSONArray mJSONArray;

    private Context mCtx;

    private SvcCallHelper(Context ctx) {
        this.mCtx = ctx;
    }

    public static SvcCallHelper GetInstance(Context ctx) {
        if (INSTANCE == null) {
            synchronized (LOCK) {
                INSTANCE = new SvcCallHelper(ctx);
            }
        }
        return INSTANCE;
    }

     /**
     * @return The Volley Request queue, the queue will be created if it is null
     */
    private RequestQueue getRequestQueue() {
        if (this.mVolleyReqQueue == null) {
            HTTPSTrustManager.Companion.allowAllSSL();//信任所有证书
            this.mVolleyReqQueue = Volley.newRequestQueue(this.mCtx);
        }

        return this.mVolleyReqQueue;
    }

    /**
     * Adds the specified request to the global queue using the Default TAG.
     *
     * @param req
     */
    private <T> void addToRequestQueue(Request<T> req) {
        // set the default tag if tag is empty
        req.setTag(VolleyRequestTag);

        getRequestQueue().add(req);
    }

     /**
     * Cancels all pending requests by the specified TAG, it is important to
     * specify a TAG so that the pending/ongoing requests can be cancelled.
     *
     * @param tag
     */
    @SuppressWarnings("unused")
    private void cancelPendingRequests(Object tag) {
        if (this.mVolleyReqQueue != null) {
            this.mVolleyReqQueue.cancelAll(tag);
        }
    }

    public void postStringRequest(String url,
                                  Response.Listener<String> scsLstn,
                                  Response.ErrorListener flrLstn,
                                  final Map<String, String> params) {
        this.mStringRequest = new StringRequest(Request.Method.POST, url, scsLstn, flrLstn) {

            @Override
            protected Map<String, String> getParams() {
                return params;
            }
        };
        this.mStringRequest.setRetryPolicy(new DefaultRetryPolicy(60 * 1000, 0, 1.0f));
        this.addToRequestQueue(this.mStringRequest);
    }

    public void postStringRequest(String url,
                                  Response.Listener<String> scsLstn,
                                  Response.ErrorListener flrLstn,
                                  final Map<String, String> params, RetryPolicy retryPolicy) {
        this.mStringRequest = new StringRequest(Request.Method.POST, url, scsLstn, flrLstn) {

            @Override
            protected Map<String, String> getParams() {
                return params;
            }
        };
        this.mStringRequest.setRetryPolicy(retryPolicy);
        this.addToRequestQueue(this.mStringRequest);
    }


    public void getStringRequest(String url,
                                 Response.Listener<String> scsLstn,
                                 Response.ErrorListener flrLstn,
                                 final Map<String, String> params) {

        try {
            this.mStringRequest = new StringRequest(Request.Method.GET, url + getHttpParams(params), scsLstn, flrLstn);
            this.mStringRequest.setRetryPolicy(new DefaultRetryPolicy(60 * 1000, 0, 1.0f));
            this.addToRequestQueue(this.mStringRequest);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void getStringRequest(String url,
                                 Response.Listener<String> scsLstn,
                                 Response.ErrorListener flrLstn,
                                 final Map<String, String> params, RetryPolicy retryPolicy) {

        try {
            this.mStringRequest = new StringRequest(Request.Method.GET, url + getHttpParams(params), scsLstn, flrLstn);
            this.mStringRequest.setRetryPolicy(retryPolicy);
            this.addToRequestQueue(this.mStringRequest);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

     public static String getHttpParams(Map<String, String> params) throws IOException {
        String renParams = "";
        if (params != null) {
            StringBuffer buffer = new StringBuffer();
            Set<String> paramsSet = params.keySet();
            if (paramsSet.size() > 0) {
                buffer.append("?");
                for (String key : params.keySet()) {
                    buffer.append(key + "=" + URLEncoder.encode(params.get(key), "utf-8")).append("&");
                }
                renParams = buffer.toString();
                renParams = renParams.substring(0, renParams.length() - 1);
            }
        }
        return renParams;
    }
}

使用实例

    private void getGroupInforFromServer() {
        Response.Listener<String> listener = new Response.Listener<String>() {
            @Override
            public void onResponse(String response) {
               //请求成功回调
        };
        Response.ErrorListener errorListener = new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
              //请求失败回调
            }
        };
        //参数
        Map<String, String> params = new HashMap<String, String>();

        SvcCallHelper.GetInstance(this).postStringRequest("URL地址", listener, errorListener, params);
    }

自定义自己的request

class MyRequest<T> : Request<T> {

    private var successListener: Response.Listener<T>? = null
    private var paramsMap: Map<String, String>? = null
    private var typeToken: TypeToken<T>? = null
    private val gson = Gson()
    private val TAG = javaClass.simpleName


    /**
     * @param method: get/post
     * @param url:接口地址
     * @param successListener:请求成功回调
     * @param errorListener:请求失败回调
     * @param typeToken: gson解析需要用到的Token
     */
    constructor(method: Int, url: String, successListener: Response.Listener<T>,
                errorListener: Response.ErrorListener?, params: Map<String, String>, typeToken: TypeToken<T>) : super(method, url, errorListener) {
        this.successListener = successListener
        this.paramsMap = params
        this.typeToken = typeToken
        Log.d(TAG, "请求接口网址：$url,   请求参数：${gson.toJson(params)}")
    }
    override fun cancel() {
        super.cancel()
        synchronized(Any()) {
            successListener = null
        }


    }

    override fun getParams(): MutableMap<String, String> {
        return paramsMap as MutableMap<String, String>
    }

    override fun getPostParams(): MutableMap<String, String> {
        return params ?: super.getParams()
    }

    override fun getHeaders(): MutableMap<String, String> {
        return headers ?: super.getHeaders()
    }

    override fun parseNetworkResponse(response: NetworkResponse): Response<T> {
        //根据headers里的编码格式 解码
        var json = String(response.data, charset(HttpHeaderParser.parseCharset(response.headers)))
        Log.d(TAG, "请求返回的原始数据为：$json")
        json = json.trim()//去除字符串两端的特殊字符
        var jsonReader = JsonReader(StringReader(json))
        jsonReader.isLenient = true
        return Response.success(gson.fromJson(jsonReader, typeToken?.type), HttpHeaderParser.parseCacheHeaders(response))
    }

    override fun deliverResponse(response: T) {
        successListener?.onResponse(response)
    }
}

自定义的请求管理类

class SVCDCallHelper<T> constructor(ctx: Context) {

    private var ctx: Context = ctx
    private var mVolleyReqQueue: RequestQueue? = null
    private var mRequest: MyRequest<T>? = null
    private val VolleyRequestTag = "VolleyPatterns"


    fun getHttpParams(params: Map<String, String>): String {
        var renParams: String = ""
        val buffer: StringBuffer = StringBuffer()
        val paramsSet: Set<String> = params.keys
        if (paramsSet.isNotEmpty()) {
            buffer.append("?")
            for (key: String in params.keys) {
                buffer.append(key + "=" + URLEncoder.encode(params[key], "utf-8")).append("&")
            }
            renParams = buffer.toString()
            renParams = renParams.substring(0, renParams.length - 1)
        }
        return renParams
    }


    /**
     * 给get请求拼接URL地址
     */
    fun getURLForGetMethod(url: String, params: Map<String, String>): String {
        var sb: StringBuffer = StringBuffer(url)
        for ((k, v) in params) {
            if (sb.indexOf("?") > 0) {
                //网址里包含“？”
                if (sb.indexOf("?") != sb.length - 1) {
                    sb.append("&")
                }
            } else {
                sb.append("?")
            }

            if (v.isNotBlank()) {
                sb = sb.append(k).append("=").append(URLEncoder.encode(v, "utf-8"))
            }
        }

        if (sb.isNotEmpty()) {
            sb.deleteCharAt(sb.length - 1)
        }
        return sb.toString()
    }


    /**
     * @return The Volley Request queue, the queue will be created if it is null
     */
    private fun getRequestQueue(): RequestQueue {
        if (mVolleyReqQueue == null) {
            HTTPSTrustManager.allowAllSSL() //信任所有证书
            mVolleyReqQueue = Volley.newRequestQueue(ctx)
        }
        return mVolleyReqQueue!!
    }

    /**
     * 将请求加入请求队列
     */
    private fun <T> addToRequestQueue(req: Request<T>) {
        req.tag = VolleyRequestTag

        getRequestQueue().add(req)
    }

    /**
     * 取消队列里的所有请求
     */
    fun cancelPendingRequests(tag: Any) {
        if (mVolleyReqQueue != null) {
            mVolleyReqQueue!!.cancelAll(tag)
        }
    }

    /**
     * post请求,设置了默认RetryPolicy
     *
     * @param url：接口地址
     * @param scsLstn:
     * @param flrLstn:
     * @param params:
     * @param typeToken:gson 解析需要的Token
     */
    fun postStringRequest(url: String, scsLstn: Response.Listener<T>,
                          flrLstn: Response.ErrorListener, params: Map<String, String>, typeToken: TypeToken<T>) {
        mRequest = MyRequest(Request.Method.POST, url, scsLstn, flrLstn, params, typeToken)
        mRequest!!.retryPolicy = DefaultRetryPolicy(60 * 1000, 0, 1.0F)
        addToRequestQueue(mRequest!!)
    }

    /**
     * get请求,设置了默认RetryPolicy
     */
    fun getStringRequest(url: String, scsLstn: Response.Listener<T>,
                         flrLstn: Response.ErrorListener, params: Map<String, String>, typeToken: TypeToken<T>) {
        val finalUrl:String = getURLForGetMethod(url,params)
        mRequest = MyRequest(Request.Method.GET, finalUrl, scsLstn, flrLstn, params, typeToken)
        mRequest!!.retryPolicy = DefaultRetryPolicy(60 * 1000, 0, 1.0F)
        addToRequestQueue(mRequest!!)
    }


    /**
     * post请求,未设置默认RetryPolicy
     */
    fun postStringRequest(url: String, scsLstn: Response.Listener<T>,
                          flrLstn: Response.ErrorListener, params: Map<String, String>, typeToken: TypeToken<T>,
                          retryPolicy: RetryPolicy) {
        mRequest = MyRequest(Request.Method.POST, url, scsLstn, flrLstn, params, typeToken)
        mRequest!!.retryPolicy = retryPolicy
        addToRequestQueue(mRequest!!)
    }

    /**
     * get请求,未设置默认RetryPolicy
     */
    fun getStringRequest(url: String, scsLstn: Response.Listener<T>,
                         flrLstn: Response.ErrorListener, params: Map<String, String>, typeToken: TypeToken<T>,
                         retryPolicy: RetryPolicy) {
        val finalUrl:String = getURLForGetMethod(url,params)
        mRequest = MyRequest(Request.Method.GET, finalUrl, scsLstn, flrLstn, params, typeToken)
        mRequest!!.retryPolicy = retryPolicy
        addToRequestQueue(mRequest!!)
    }

}