Volley简单封装

public interface IRequest {

/**
* 获取头部信息
*
* @return
*/
public Map<String, String> getHeaderMap();

/**
* 获取参数集合
*
* @return
*/
public Map<String, String> getParamMap();
}

public abstract class BaseRequest<T> extends Request<T> implements IRequest {

private Class<T> mClazz;
private Listener<T> mListener;
private ErrorListener mErrorListener = null;

public BaseRequest(String url, Class<T> clazz, Listener<T> listener,ErrorListener errorListener) {
this(Method.POST, url, clazz, listener, errorListener);
}

public BaseRequest(int method, String url, Class<T> clazz,
Listener<T> listener, ErrorListener errorListener) {
super(method, url, errorListener);
this.mListener = listener;
this.mErrorListener = errorListener;
this.mClazz = clazz;
}

@Override
public Map<String, String> getHeaders() throws AuthFailureError {
Map<String, String> map = getHeaderMap();
if (map == null || map.size() == 0) {
return super.getHeaders();
}
return map;
}

@Override
protected Map<String, String> getParams() throws AuthFailureError {
Map<String, String> map = getParamMap();
if (map == null || map.size() == 0) {
return super.getParams();
}
return map;
}

@Override
protected Response<T> parseNetworkResponse(NetworkResponse response) {
// TODO Auto-generated method stub
try {
String jsonStr = new String(response.data,HttpHeaderParser.parseCharset(response.headers));
Print.i("网络请求返回：" + jsonStr);
return Response.success(JSON.parseObject(jsonStr, mClazz),HttpHeaderParser.parseCacheHeaders(response));//fastjson解析
} catch (UnsupportedEncodingException e) {
Print.e("请求异常 -> UnsupportedEncodingException");
return Response.error(new ParseError(e));
}
}

@Override
protected void deliverResponse(T response) {
// TODO Auto-generated method stub
mListener.onResponse(response);
}

public void deliverError(VolleyError error) {
Print.e("请求异常 -> VolleyError" + error.getMessage());
if (mErrorListener != null) {
mErrorListener.onErrorResponse(error);
}
}
}

public class RequestImpl<T> extends BaseRequest<T> {

private String DESParams;// 加密参数字符串
private Map<String, Object> mParams = new HashMap<String, Object>();

public RequestImpl(String url, Class<T> clazz, Map<String, Object> params,
Listener<T> listener, ErrorListener errorListener) {
super(url, clazz, listener, errorListener);
Print.i("url:" + url);
this.mParams = params;
getBodyString();
}

public RequestImpl(int method, String url, Class<T> clazz,
Map<String, Object> params, Listener<T> listener,ErrorListener errorListener) {
super(method, url, clazz, listener, errorListener);
Print.i("url:" + url);
this.mParams = params;
getBodyString();
}

@Override
public Map<String, String> getHeaderMap() {
// TODO Auto-generated method stub
Map<String, String> headers = new HashMap<String, String>();
// 添加自己所需的全局参数
return headers;
}

@Override
public Map<String, String> getParamMap() {
// TODO Auto-generated method stub
Map<String, String> params = new HashMap<String, String>();
// 添加自己所需的全局参数
params.put("body", DESParams);
return params;
}

/**
* @return String
* @Title: getBodyString
* @Description: 获取参数信息
*/
private String getBodyString() {
String jsonString = JSON.toJSONString(mParams);//fastjson解析
Print.i("加密前参数mParams：" + jsonString);
try {
DESParams = DES.encryptThreeDESECB(jsonString,Constants.SECRETKEY);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Print.i("加密后参数DESParams：" + DESParams);
return DESParams;
}
}

public class VolleyManager {

public static final VolleyManager volleyManager = new VolleyManager();

private VolleyManager() {

}

public static VolleyManager getInstance() {
return volleyManager;
}

@SuppressWarnings("unchecked")
public <T> void requestNetwork(RequestQueue requestQueue, Class<T> clazz, String url, Map<String, Object> params, final ResultListener<T> listener) {
//此处需要请检查网络
RequestImpl request = new RequestImpl(url, clazz, params, listener, listener);
requestQueue.add(request);
}

@SuppressWarnings("unchecked")
public <T> void requestNetwork(RequestQueue requestQueue,int method, Class<T> clazz, String url, Map<String, Object> params, final ResultListener<T> listener) {
//此处需要请检查网络
RequestImpl request = new RequestImpl(method , url, clazz, params, listener, listener);
requestQueue.add(request);
}

}

public abstract class ResultListener<T> implements Listener<T>, ErrorListener {

public static final int STATUS_200 = 200;

@Override
public void onResponse(T response) {
if (response == null) {
Print.d("请求成功，请求结果为空！");
isEmpty();
return;
}

if (response instanceof BaseBean) {
BaseBean baseModel = (BaseBean) response;
if (baseModel.result == 0) {
fail(null);
} else {
success(response);
}
}
}

@Override
public void onErrorResponse(VolleyError error) {
// 请求失败！
fail(error);
}

public abstract void success(final T response);

public abstract void fail(final VolleyError error);

public abstract void isEmpty();
}

public class BaseBean implements Serializable {

private static final long serialVersionUID = -5603527602912717757L;
// 添加公有返回参数
public int result;

public String message;

}

public class Constants {

public static final String SECRETKEY = "12345678";
}

public class DES {

/**
* 加密
*
* @param src
* 明文
* @param key
* 密钥
* @return 加密后的字符串
* @throws Exception
*/

@SuppressLint({ "TrulyRandom", "DefaultLocale" })
public static String encryptThreeDESECB(String src, String key)
throws Exception {
DESKeySpec dks = new DESKeySpec(key.getBytes("UTF-8"));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
SecretKey securekey = keyFactory.generateSecret(dks);
Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, securekey);
StringBuilder str = new StringBuilder();
byte[] bts = cipher.doFinal(src.getBytes());
for (byte b : bts) {
String hex = Integer.toHexString(b & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
str.append(hex.toUpperCase());
}
return str.toString();
}
}

public class Print {

public static final boolean DEBUG = true;
public static final String TAG = "DRIVER";

public static void v(String msg) {
if (DEBUG) {
Log.v(TAG, msg);
}
}

public static void v(String tag, String msg) {
if (DEBUG) {
Log.v(tag, msg);
}
}

public static void d(String msg) {
if (DEBUG) {
Log.d(TAG, msg);
}
}

public static void d(String tag, String msg) {
if (DEBUG) {
Log.d(tag, msg);
}
}

public static void e(String msg) {
if (DEBUG) {
Log.e(TAG, msg);
}
}

public static void e(String tag, String msg) {
if (DEBUG) {
Log.e(tag, msg);
}
}

public static void i(String msg) {
if (DEBUG) {
Log.i(TAG, msg);
}
}

public static void i(String tag, String msg) {
if (DEBUG) {
Log.i(tag, msg);
}
}

public static void w(String msg) {
if (DEBUG) {
Log.w(TAG, msg);
}
}

public static void w(String tag, String msg) {
if (DEBUG) {
Log.w(tag, msg);
}
}

}