Volley

Volley网络通信框架非常适合去进行数据量不大，但通信频繁的网络操作

将volley.jar文件复制到libs目录下

public static RequestQueue mVolleyQueue;

public static void sendRequest(final Request request, String tag, HttpCallBackListener listener) {
    if (listener != null) {
        listener.onStart();

        if (mVolleyQueue == null) {
            mVolleyQueue = Volley.newRequestQueue(GlobalUtil.mContext);
        }

        request.setTag(tag);

        //设置超时时间
        request.setRetryPolicy(new DefaultRetryPolicy(3 * 1000,  3, DefaultRetryPolicy
                .DEFAULT_BACKOFF_MULT));

        mVolleyQueue.add(request);

    }
}

private static Request initGetRequest(String urlAddress, final HttpCallBackListener listener) {
    return new StringRequest(Request.Method.POST, urlAddress,
            new Response.Listener<String>() {
                @Override
                public void onResponse(String response) {

                    if (listener != null) {
                        listener.onAccess(response);
                    }
                }
            },
            new Response.ErrorListener() {
                @Override
                public void onErrorResponse(VolleyError error) {
                    if (listener == null) {
                        return;
                    }
                    if (error instanceof TimeoutError) {
                        listener.onError(TIMEOUTERROR);
                    } else if (error instanceof ServerError) {
                        listener.onError(SERVERERROR);
                    } else if (error instanceof NoConnectionError) {
                        listener.onError(NOCONNECTIONERROR);
                    } else {
                        listener.onError(OTHERERROR);
                    }
                }
            });
}

/**
 * get请求，默认tag
 *
 * @param urlAddress
 * @param listener
 */
public static void sendGet(final String urlAddress, HttpCallBackListener listener) {
    Request request = initGetRequest(urlAddress, listener);
    sendRequest(request, TAG, listener);
}

/**
 * 初始化Post请求
 *
 * @param urlAddress
 * @param data
 * @param listener
 * @return
 */
private static Request initPostRequest(final String urlAddress, final String data, final
HttpCallBackListener listener) {
    return new StringRequest(Request.Method.POST, urlAddress, new
            Response.Listener<String>() {
                @Override
                public void onResponse(String response) {
                    LogUtils.json(response);
                    if (listener != null) {
                        try {
                            if (urlAddress.equals(LOGOUT)) {
                                listener.onAccess(response);
                            } else {
                                JSONObject jsonObject = new JSONObject(response);
                                String status = jsonObject.optString("status");
                                if (status.equals("2")) {
                                    String loginTime = jsonObject.optString("loginTime");
                                    String deviceName = jsonObject.optString("deviceName");
                                    ActivityManager.forceLogOut(loginTime, deviceName);
                                } else {
                                    listener.onAccess(response);
                                }
                            }

                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                }
            }, new Response.ErrorListener() {
        @Override
        public void onErrorResponse(VolleyError error) {
            if (listener == null) {
                return;
            }
            if (error instanceof TimeoutError) {
                listener.onError(TIMEOUTERROR);
            } else if (error instanceof ServerError) {
                listener.onError(SERVERERROR);
            } else if (error instanceof NoConnectionError) {
                listener.onError(NOCONNECTIONERROR);
            } else {
                listener.onError(OTHERERROR);
            }
        }
    }) {
        @Override
        protected Map<String, String> getParams() throws AuthFailureError {
            Map<String, String> map = new HashMap<>();
            map.put("req", data);
            return map;
        }
    };
}

/**
 * post请求数据，默认tag
 *
 * @param data
 * @param listener
 */

public static void sendPost(final String urlAddress, final String data, final
HttpCallBackListener listener) {

    LogUtils.e(POST_URL, urlAddress);
    LogUtils.json(POST_PARAMS, data);

    Request request = initPostRequest(urlAddress, data, listener);

    sendRequest(request, TAG, listener);
}

/**
 * post请求数据，自定义tag
 *
 * @param urlAddress
 * @param data
 * @param tag
 * @param listener
 */
public static void sendPost(final String urlAddress, String data, String tag,
                            HttpCallBackListener listener) {

    LogUtils.e(POST_URL, urlAddress);
    LogUtils.json(POST_PARAMS, data);

    Request request = initPostRequest(urlAddress, data, listener);

    sendRequest(request, tag, listener);
}

/**
 * 取消请求
 */
public static void cancelRequest() {
    if (mVolleyQueue != null) {
        mVolleyQueue.cancelAll(TAG);
    }
}

/**
 * 取消某一请求
 * @param tag
 */
public static void cancelRequest(String tag) {
    if (mVolleyQueue != null) {
        mVolleyQueue.cancelAll(tag);
    }
}

注意这里拿到的RequestQueue是一个请求队列对象，它可以缓存所有的HTTP请求，然后按照一定的算法并发地发出这些请求。RequestQueue内部的设计就是非常合适高并发的，因此我们不必为每一次HTTP请求都创建一个RequestQueue对象，这是非常浪费资源的，基本上在每一个需要和网络交互的Activity中创建一个RequestQueue对象就足够了。

如果是Post请求，提交给服务器的参数又该怎么设置呢？

我们只需要在StringRequest的匿名类中重写getParams()方法，在这里设置POST参数就可以了

执行原理 ：

其中蓝色部分代表主线程，绿色部分代表缓存线程，橙色部分代表网络线程。我们在主线程中调用RequestQueue的add()方法来添加一条网络请求，这条请求会先被加入到缓存队列当中，如果发现可以找到相应的缓存结果就直接读取缓存并解析，然后回调给主线程。如果在缓存中没有找到结果，则将这条请求加入到网络请求队列中，然后处理发送HTTP请求，解析响应结果，写入缓存，并回调主线程。