本文介绍了一个基于Volley的Android网络请求框架整合方案，包括自定义请求参数类、结果处理类及具体的请求处理流程。
Android开发，Android项目打jar包，以及Http请求整合框架的使用(后付文件和使用方法)
第二个，BaseHttpResult
第四个，CustomException
第五个，HttpConstant
这些大部分都比较简单了，复制过去就能用，主要讲一下BaseRequestData这个类
然后可以看到有两个方法
看名字就知道了分别是加载开始，加载失败，加载成功
对了还有进行网络请求
本文是基于前一篇文章
前一篇也是HTTP网络请求整合框架，只是是基于HttpClient的
但是在android 5.0后，android studio就不再支持了，到了android 6.0后就直接删除了
官方推荐了Volley这个框架
我这篇主要是使用上一篇的方法，将网络请求换成了使用Volley进行整合
这里就不采用JAR包的方式，我将文件的代码都贴出来，方便阅读。
这里需要建立6个类
第一个，BaseHttpParams
package com.zx.gamarketmobile.http;
/**
* 请求 参数 JavaBean
*
* @author zsx
*
* @date 2014-06-16
*/
public abstract class BaseHttpParams<Param> {
private String apiUrl;
private HTTP_MOTHOD mothod = HTTP_MOTHOD.POST;
public static enum HTTP_MOTHOD {
POST, GET
}
/**
* @return 请求URL
*/
final String getRequestUrl(int id) {
return apiUrl;
}
/**
* 设置请求URL
*
* @param apiUrl
*/
public void setApiUrl(String apiUrl) {
this.apiUrl = apiUrl;
}
/**
* 设置请求方式
*
* @param mothod
*/
public final void setRequestMothod(HTTP_MOTHOD mothod) {
this.mothod = mothod;
}
/**
* @return 拿到请求参数
*/
protected abstract Param getParams(int id);
/**
* 拿到请求方式
*
* @return
*/
public final HTTP_MOTHOD getRequestMothod() {
return mothod;
}
}
第二个，BaseHttpResult
package com.zx.gamarketmobile.http;
public class BaseHttpResult {
private boolean isSuccess =false;
private String message;
private Object entry;
private int code;
public Object getEntry() {
return entry;
}
void setEntry(Object entry) {
// if(entry!=null){
// isSuccess=true;
// }
this.entry = entry;
}
public boolean isSuccess() {
return isSuccess;
}
public void setSuccess(boolean isSuccess) {
this.isSuccess = isSuccess;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
}
package com.zx.gamarketmobile.http;
import android.accounts.NetworkErrorException;
import android.app.ProgressDialog;
import android.content.Context;
import android.content.DialogInterface;
import android.os.Handler;
import android.util.Log;
import com.android.volley.DefaultRetryPolicy;
import com.android.volley.Request;
import com.android.volley.Response;
import com.android.volley.VolleyError;
import com.android.volley.toolbox.StringRequest;
import com.zx.gamarketmobile.R;
import com.zx.gamarketmobile.util.LogUtil;
import com.zx.gamarketmobile.util.MyApplication;
import java.io.IOException;
import java.net.SocketTimeoutException;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeoutException;
/**
* @author zsx
* @date 2013-8-9
* @description
* @param<Param> HttpClient 请求参数类型
* @param<ParamType> loadData 参数类型
* @param<Result> 返回参数
*/
public abstract class BaseRequestData<HttpClientParam, loadDataParam, Result extends BaseHttpResult> {
/**
* 默认所有请求可同时开5线程
*/
protected static final ExecutorService HTTPEXCUTORS = Executors.newFixedThreadPool(5);
protected Handler pHandler = new Handler();
private int id;
private String error_message;
private Result pBean;
private boolean b_isDownding = false;
protected OnHttpLoadingListener<Result> listener;
public void setLoadingListener(OnHttpLoadingListener<Result> listener) {
this.listener = listener;
}
public int getId() {
return id;
}
public BaseRequestData(int id) {
this.id = id;
}
public boolean isLoading() {
return b_isDownding;
}
public interface OnHttpLoadingListener<Result> {
/**
* 开始下载
*
* @param id
*/
void onLoadStart(int id);
/**
* 请求发生错误
*
* @param id
* @param isAPIError <ul>
* <li>true parStr 解析错误</li>
* <li>false 请求超时 网络连接异常等</li>
* </ul>
* @param error_message 错误消息
*/
void onLoadError(int id, boolean isAPIError, String error_message);
void onLoadComplete(int id, Result b);
}
@SafeVarargs
protected final void _loadData(loadDataParam... objects) {
requestData(objects);
}
public boolean hasCache() {
return pBean != null;
}
public void clear() {
pBean = null;
}
/**
* @return 上一次加载的数据
*/
public Result getLastData() {
return pBean;
}
@SafeVarargs
private synchronized final void requestData(loadDataParam... objects) {
if (b_isDownding) {
if (LogUtil.DEBUG) {
LogUtil.e(this, "id:" + id + "\t 正在下载");
}
return;
}
// if (Lib_BaseApplication._Current_NetWork_Status == NetType.NoneNet) {
// if (LogUtil.DEBUG) {
// LogUtil.e(this, "网络链接异常");
// }
// onRequestError(id, "网络链接异常");
// return;
// }
b_isDownding = true;
BaseHttpParams<HttpClientParam> pParams = getHttpParams(id, objects);
HTTPEXCUTORS.execute(new HttpWork(pParams));
}
/**
* 未做保护 可连续请求
*
* @param objects
*/
@SafeVarargs
protected final void queueLoadData(loadDataParam... objects) {
BaseHttpParams<HttpClientParam> pParams = getHttpParams(id, objects);
HTTPEXCUTORS.execute(new HttpWork(pParams));
}
private class HttpWork implements Runnable {
private BaseHttpParams<HttpClientParam> params;
public HttpWork(BaseHttpParams<HttpClientParam> params) {
this.params = params;
}
@SuppressWarnings("unchecked")
@Override
public void run() {
String str = null;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestStart(id);
}
});
error_message = null;
try {
HttpClientParam param = params.getParams(id);
switch (params.getRequestMothod()) {
case GET:
String getUrl = null;
if (param == null) {
getUrl = params.getRequestUrl(id);
} else if (param instanceof Map) {
Map<String, Object> m = (Map<String, Object>) param;
String getParam = null;
if (m.size() == 0) {
getParam = "";
} else {
getParam = "?";
for (String key : m.keySet()) {
Object o = m.get(key);
getParam += key + "=" + String.valueOf(o == null ? "" : o);
getParam += "&";
}
getParam = getParam.substring(0, getParam.length() - 1);
}
getUrl = params.getRequestUrl(id) + getParam;
} else {
getUrl = params.getRequestUrl(id);
}
if (LogUtil.DEBUG) {
LogUtil.e("requestData params:", String.valueOf(getUrl));
}
getJson(getUrl);
break;
case POST:
if (LogUtil.DEBUG) {
LogUtil.e("requestData params:", String.valueOf(param));
}
if (param instanceof Map) {
postJson(params.getRequestUrl(id), (Map<String, Object>) param);
} else {
postJson(params.getRequestUrl(id), param.toString());
}
break;
default:
throw new IllegalArgumentException("没有此请求方法");
}
} catch (ClassCastException e) {
LogUtil.e(e);
error_message = "参数类型错误";
} catch (URISyntaxException e) {
LogUtil.w(e);
error_message = "网络地址错误";
} catch (TimeoutException e) {
error_message = "连接超时";
LogUtil.w(e);
} catch (SocketTimeoutException e) {
error_message = "请求超时";
LogUtil.w(e);
}
// catch (ClientProtocolException e) {
// error_message = "网络协议错误";
// LogUtil.w(e);
// }
catch (NetworkErrorException e) {
error_message = "服务器未响应";
LogUtil.w(e);
} catch (
IOException e
)
{
error_message = "网络连接失败";
LogUtil.e(e);
} catch (
Exception e
)
{
error_message = "网络连接失败";
LogUtil.e(e);
}
}
}
public void postJson(String url) throws TimeoutException, IOException, NetworkErrorException, URISyntaxException {
Map<String, Object> newparams = new HashMap<>();
postJson(url, newparams);
}
public void postJson(String url, String params) throws TimeoutException, IOException, NetworkErrorException, URISyntaxException {
Map<String, Object> newparams = new HashMap<>();
newparams.put(params, params);
postJson(url, newparams);
}
/**
* post方法
*
* @param url
* @param params
* @throws URISyntaxException
* @throws SocketTimeoutException
* @throws IOException
* @throws TimeoutException
*/
public void postJson(String url, final Map<String, Object> params) throws URISyntaxException, IOException, NetworkErrorException,
TimeoutException {
StringRequest postRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.e("result", response);
if (response == null) {
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "未请求到数据");
}
});
} else {
final String returnStr = response.replaceAll("\ufeff", "");
// final String returnStr = str;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestComplete(id, pBean, returnStr);
}
});
}
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// int statusCode = error.networkResponse.statusCode;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "网络请求失败");
}
});
}
}) {
@Override
protected Map<String, String> getParams() {
Map<String, String> theParams = new HashMap<String, String>();
for (String key : params.keySet()) {
if (params.get(key) == null) {
theParams.put(key, "");
} else {
theParams.put(key, params.get(key).toString());
}
}
return theParams;
}
};
postRequest.setRetryPolicy(new DefaultRetryPolicy(5 * 1000, 1, 1.0f));
postRequest.setTag(url);
MyApplication.getQueue().add(postRequest);
}
/**
* get方法
*
* @param url
* @throws URISyntaxException
* @throws SocketTimeoutException
* @throws IOException
* @throws TimeoutException
*/
public void getJson(String url) throws URISyntaxException, IOException,
TimeoutException {
StringRequest postRequest = new StringRequest(Request.Method.GET, url, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.e("result", response);
if (response == null) {
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "null");
}
});
} else {
final String returnStr = response.replaceAll("\ufeff", "");
// final String returnStr = str;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestComplete(id, pBean, returnStr);
}
});
}
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "网络请求失败");
}
});
}
});
postRequest.setTag(url);
MyApplication.getQueue().add(postRequest);
}
private void onRequestStart(int id) {
b_isDownding = true;
if (listener != null) {
listener.onLoadStart(id);
} else {
__onStart(id);
}
}
private final void onRequestError(int id, String error_message) {
b_isDownding = false;
if (listener != null) {
listener.onLoadError(id, false, error_message);
} else {
__onError(id, false, error_message);
}
}
private final void onRequestComplete(int id, Result source, String returnStr) {
try {
pBean = parseStr(id, returnStr, source);
b_isDownding = false;
if (pBean.isSuccess()) {
if (listener != null) {
listener.onLoadComplete(id, pBean);
} else {
__onComplete(id, pBean);
}
} else {
if (listener != null) {
listener.onLoadError(id, true, pBean.getMessage());
} else {
__onError(id, true, pBean.getMessage());
}
}
} catch (Exception e) {
if (LogUtil.DEBUG) {
LogUtil.e(e);
}
b_isDownding = false;
// if (listener == null) {
// __onError(id, false, "解析发生异常");
// } else {
// listener.onLoadError(id, false, "解析发生异常");
// }
}
}
/**
* 构造请求参数
*
* @return
* @paramparams
* @paramobjects
*/
protected abstract BaseHttpParams<HttpClientParam> getHttpParams(int id, loadDataParam... objects);
/**
* @param currentDownloadText Http请求的数据
* @param lastData 上一次 parseStr()方法返回的数据
* @return 会在onComplete()中回调出去
* @throws Exception
*/
protected abstract Result parseStr(int id, String currentDownloadText, Result lastData) throws Exception;
/**
* 开始下载
*
* @param id
*/
protected void __onStart(int id) {
}
/**
* 请求发生错误
*
* @param id
* @param isAPIError <ul>
* <li>true parStr 解析错误</li>
* <li>false 请求超时 网络连接异常等</li>
* </ul>
* @param error_message 错误消息
*/
protected void __onError(int id, boolean isAPIError, String error_message) {
}
protected void __onComplete(int id, Result b) {
}
private ProgressDialog progressDialog;
private String loadMessage = "正在加载数据，请稍后..";
public final synchronized void showLoadingDialog(Context context) {
if (progressDialog == null) {
progressDialog = new ProgressDialog(context, R.style.dialogTransparent);
progressDialog.setCancelable(false);
progressDialog.setCanceledOnTouchOutside(false);
progressDialog.setMessage(loadMessage);
}
if (progressDialog.isShowing()) {
return;
}
progressDialog.show();
}
public final synchronized void cancelLoadingDialog() {
if (progressDialog != null) {
if (progressDialog.isShowing()) {
progressDialog.cancel();
progressDialog = null;
}
}
}
public final synchronized void setLoadingDialogText(String loadMessage) {
this.loadMessage = loadMessage;
if (progressDialog != null) {
progressDialog.setMessage(loadMessage);
}
}
/**
* 带取消按钮的diaolog
*
* @param context
*/
public final synchronized void showLoadingDialogHasCancel(Context context) {
if (progressDialog == null) {
progressDialog = new ProgressDialog(context, R.style.dialogTransparent);
progressDialog.setCancelable(false);
progressDialog.setCanceledOnTouchOutside(false);
progressDialog.setMessage("下载准备中...");
progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
cancelLoadingDialog();
}
});
}
if (progressDialog.isShowing()) {
return;
}
progressDialog.show();
}
}
第四个，CustomException
package com.zx.gamarketmobile.http;
public class CustomException extends Exception {
public String message;
public CustomException(String message) {
super(message);
this.message = message;
}
@Override
public String getMessage() {
return message;
}
private static final long serialVersionUID = 5498773265020269143L;
}
第五个，HttpConstant
package com.zx.gamarketmobile.http;
public class HttpConstant {
public static String AppCode = "first";
}
package com.zx.gamarketmobile.http;
import java.util.HashMap;
import java.util.Map;
public class HttpParam extends BaseHttpParams<Object> {
private Map<String, Object> map = new HashMap<String, Object>();
@Override
public Map<String, Object> getParams(int id) {
return map;
}
public void putParams(String key, Object value) {
map.put(key, value);
}
public void clear(){
map.clear();
}
}
这些大部分都比较简单了，复制过去就能用，主要讲一下BaseRequestData这个类
/**
* post方法
*
* @param url
* @param params
* @throws URISyntaxException
* @throws SocketTimeoutException
* @throws IOException
* @throws TimeoutException
*/
public void postJson(String url, final Map<String, Object> params) throws URISyntaxException, IOException, NetworkErrorException,
TimeoutException {
StringRequest postRequest = new StringRequest(Request.Method.POST, url, new Response.Listener<String>() {
@Override
public void onResponse(String response) {
Log.e("result", response);
if (response == null) {
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "未请求到数据");
}
});
} else {
final String returnStr = response.replaceAll("\ufeff", "");
// final String returnStr = str;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestComplete(id, pBean, returnStr);
}
});
}
}
}, new Response.ErrorListener() {
@Override
public void onErrorResponse(VolleyError error) {
// int statusCode = error.networkResponse.statusCode;
pHandler.post(new Runnable() {
@Override
public void run() {
onRequestError(id, "网络请求失败");
}
});
}
}) {
@Override
protected Map<String, String> getParams() {
Map<String, String> theParams = new HashMap<String, String>();
for (String key : params.keySet()) {
if (params.get(key) == null) {
theParams.put(key, "");
} else {
theParams.put(key, params.get(key).toString());
}
}
return theParams;
}
};
postRequest.setRetryPolicy(new DefaultRetryPolicy(5 * 1000, 1, 1.0f));
postRequest.setTag(url);
MyApplication.getQueue().add(postRequest);
}如果各位有需要的自己的网络请求方法，只需要在这个位置进行更改就可以了
最后是网络请求方法，其实这个大家去我上一个文章看就可以了
方便大家，我这里大概写一下
首先需要建立一个ApiData的类，用于统一处理所有网络请求和结果处理，以及上传下载。
/**
* 网络请求统一处理
*
* @author zx-wt
*/
public class ApiData extends BaseRequestData<Object, Object, BaseHttpResult> {
/**
* 登录页接口 [无参数 ]
*/
public static final int HTTP_ID_getcover = 1;
/**
* 欢迎页接口 [0]用户名 [1]密码
*/
public static final int HTTP_ID_login = 2;
public static final int HTTP_ID_searchzt = 3;// 主体查询
public static final int HTTP_ID_searchzt_Jyfw = 4;// 主体经营范围查询
public static final int HTTP_ID_search_taskcount = 5;// 任务数量查询
public static final int HTTP_ID_search_task_bypage = 6;// 任务列表查询
private HttpParam params = new HttpParam();
public static String baseUrl = null
/**
* 文件上传 [0]客户id [1]文件存放路径[2]接受者id[3] 发送类型 参考 HTTP_ID_message_send 2图片 3语音,
* String type]
*/
public static final int FILE_UPLOAD = 999;
public ApiData(int id) {
super(id);
}
public static void setBaseUrl(String ip) {
baseUrl = "http://" + ip + "/*****/";
}
public void loadData(final Object... objects) {
if (getId() == HTTP_ID_message_send) {
super.queueLoadData(objects);
} else if (getId() == FILE_UPLOAD) {
final String sqlId = objects[0].toString();
HTTPEXCUTORS.execute(new Runnable() {
String errorMessage = null;
@Override
public void run() {
if (listener != null) {
try {
pHandler.post(new Runnable() {
@Override
public void run() {
listener.onLoadStart(FILE_UPLOAD);
}
});
fileUpload((String[]) objects[1]);
} catch (final CustomException e) {
e.printStackTrace();
errorMessage = e.getMessage();
} catch (IOException | URISyntaxException e) {
e.printStackTrace();
errorMessage = "网络连接失败";
} catch (JSONException e) {
e.printStackTrace();
errorMessage = "解析失败";
}
if (errorMessage != null) {
pHandler.post(new Runnable() {
@Override
public void run() {
listener.onLoadError(FILE_UPLOAD, false, sqlId);
}
});
}
}
}
});
} else {
super._loadData(objects);
}
}
@Override
protected BaseHttpParams<Object> getHttpParams(int id, Object... objects) {
try {
params.clear();
switch (id) {
case HTTP_ID_login:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "login");
params.putParams("loginname", objects[0]);
params.putParams("passwd", MD5Util.getMD5(MD5Util.getMD5(objects[1].toString())));
params.putParams("source", "chongqingzxgs_mobile");
// params.putParams("passwd", objects[1]);
break;
case HTTP_ID_searchzt:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "queryEntitiesPageByInfo");
params.putParams("pageno", objects[0]);
params.putParams("pagesize", objects[1]);
params.putParams("name", objects[2]);
// params.putParams("orgcode", objects[3]);
// params.putParams("bizlicnum", objects[4]);
// params.putParams("legalperson", objects[5]);
// params.putParams("station", objects[6]);
// params.putParams("grid", objects[7]);
break;
case HTTP_ID_searchzt_Jyfw:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "queryBaseMarketDetail");
params.putParams("guid", objects[0]);
break;
case HTTP_ID_search_taskcount:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "getTaskCounts");
params.putParams("userid", objects[0]);
break;
case HTTP_ID_search_task_bypage:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "queryTaskPage");
params.putParams("pageno", objects[0]);
params.putParams("pagesize", objects[1]);
params.putParams("timetype", objects[2]);
params.putParams("status", objects[3]);
params.putParams("userid", objects[4]);
break;
// TODO
default:
if (LogUtil.DEBUG) {
LogUtil.e(this, "ApiData 请求被遗漏 id:" + id);
}
break;
}
if (id != HTTP_ID_login) {
params.putParams("uuid", UUID);
}
} catch (ArrayIndexOutOfBoundsException e) {
if (LogUtil.DEBUG) {
LogUtil.e(this, "请求参数错误 请检查loadData()是否未带参数");
}
}
return params;
}
@SuppressLint("SimpleDateFormat")
@Override
protected BaseHttpResult parseStr(int id, String currentDownloadText, BaseHttpResult lastData) throws Exception {
JSONObject list;
JSONObject jsonObject;
BaseHttpResult result = new BaseHttpResult();
switch (id) {
/** api */
default:
try {
jsonObject = new JSONObject(currentDownloadText);
} catch (Exception e) {
result.setSuccess(false);
return result;
}
String msg;
// if (jsonObject.has("InfoMessage")) {
// Message message = new Message();
// message.what = 1;
// BaseActivity activity = new BaseActivity();
// activity.handler2.sendMessage(message);
// return null;
// }
String code = getStringValue(jsonObject, "code");
msg = getStringValue(jsonObject, "message");
result.setMessage(msg);
result.setSuccess("0".equals(code) || "20000".equals(code));
if (result.isSuccess()) {
switch (id) {
case HTTP_ID_login: {
UUID = msg;
list = getJSONObject(jsonObject, "data");
HttpLoginEntity loginEntity = new HttpLoginEntity();
loginEntity.setId(getStringValue(list, "fUserId"));
loginEntity.setRealName(getStringValue(list, "fRealName"));
loginEntity.setGender(getStringValue(list, "fGender"));
loginEntity.setAge(getStringValue(list, "fAge"));
loginEntity.setUserName(getStringValue(list, "fUserName"));
loginEntity.setDuty(getStringValue(list, "fDuty"));
loginEntity.setDepartment(getStringValue(list, "fDepartment"));
loginEntity.setDepartmentAlias(getStringValue(list, "fDepartmentAlias"));
loginEntity.setDesc(getStringValue(list, "fDesc"));
loginEntity.setTelephone(getStringValue(list, "fTelephone"));
// loginEntity.setPassword(params.getParams(id).get("password").toString());
loginEntity.setGrid(getStringValue(list, "fGrid"));
loginEntity.setPassword(getStringValue(list, "fPassword"));
loginEntity.setAuthority(getStringValue(list, "grantCode").replace("[", "").replace("]", "").replace("\"", ""));
loginEntity.setLoginCode("notfirst");
result.setEntry(loginEntity);
}
break;
case HTTP_ID_searchzt: {
list = getJSONObject(jsonObject, "data");
HttpSearchZtEntity searchZtEntity = new HttpSearchZtEntity();
searchZtEntity.setCurrPageNo(getIntValue(list, "currPageNo"));
searchZtEntity.setPageSize(getIntValue(list, "pageSize"));
searchZtEntity.setPageTotal(getIntValue(list, "pageTotal"));
searchZtEntity.setTotal(getIntValue(list, "total"));
JSONArray dataArray = getJSONArray(list, "rows");
List<HttpZtEntity> ztlist = new ArrayList<>();
for (int i = 0; i < dataArray.length(); i++) {
JSONObject jObj = (JSONObject) dataArray.get(i);
HttpZtEntity zt = new HttpZtEntity();
zt.setGuid(getStringValue(jObj, "fEntityGuid"));
zt.setEntityName(getStringValue(jObj, "fEntityName"));
zt.setCreditLevel(getStringValue(jObj, "fCreditLevel"));
zt.setContactInfo(getStringValue(jObj, "fContactInfo"));
zt.setLegalPerson(getStringValue(jObj, "fLegalPerson"));
zt.setOrgCode(getStringValue(jObj, "fOrgCode"));
zt.setBizlicNum(getStringValue(jObj, "fBizlicNum"));
zt.setLicenses(getStringValue(jObj, "fLicenses").equals("null") ? "" : getStringValue(jObj, "fLicenses"));
zt.setAddress(getStringValue(jObj, "fAddress"));
zt.fTags = getStringValue(jObj, "fTags");
JSONObject jObjsInfo = getJSONObject(jObj, "sInfo");
zt.setWkid(getIntValue(jObjsInfo, "spatialReference"));
zt.setLongitude(getDoubleValue(jObjsInfo, "x"));
zt.setLatitude(getDoubleValue(jObjsInfo, "y"));
ztlist.add(zt);
}
searchZtEntity.setZtList(ztlist);
result.setEntry(searchZtEntity);
}
break;
case HTTP_ID_searchzt_Jyfw: {
String strData = getStringValue(jsonObject, "data");
String strJyfw = "";
if (strData != null && !strData.isEmpty()) {
JSONArray dataArray = new JSONArray(strData);
if (dataArray.length() > 0) {
JSONObject jObj = (JSONObject) dataArray.get(0);
strJyfw = getStringValue(jObj, "value");
}
}
result.setEntry(strJyfw);
}
break;
default:
break;
}
}
break;
}
return result;
}
// 获取JSONObject类型
public JSONObject getJSONObject(JSONObject jsonObject, String name) {
try {
return jsonObject.getJSONObject(name);
} catch (JSONException e) {
e.printStackTrace();
return new JSONObject();
}
}
// 获取JSONArray类型
public JSONArray getJSONArray(JSONObject jsonObject, String name) {
try {
return jsonObject.getJSONArray(name);
} catch (JSONException e) {
e.printStackTrace();
return new JSONArray();
}
}
// 获取String类型参数
public String getStringValue(JSONObject jsonObject, String name) {
try {
if (jsonObject.getString(name).equals("null")) {
return "";
} else {
return jsonObject.getString(name);
}
} catch (JSONException e) {
e.printStackTrace();
return "";
}
}
// 获取Int类型参数
public int getIntValue(JSONObject jsonObject, String name) {
try {
return jsonObject.getInt(name);
} catch (JSONException e) {
e.printStackTrace();
return 0;
}
}
// 获取double类型参数
public double getDoubleValue(JSONObject jsonObject, String name) {
try {
return jsonObject.getDouble(name);
} catch (Exception e) {
return 0;
}
}
/**
* 文件上传
*
* @throws IOException
* @throws URISyntaxException
* @throws CustomException
* @throws JSONException
*/
private void fileUpload(String[] paths) throws IOException, URISyntaxException, CustomException, JSONException {
//实例化HttpUtils对象， 参数设置链接超时
HttpUtils HTTP_UTILS = new HttpUtils(60 * 1000);
//实例化RequestParams对象
RequestParams requestParams = new RequestParams();
final BaseHttpResult result = new BaseHttpResult();
for (String path : paths) {
File file = new File(path);
if (!file.exists()) {
throw new FileNotFoundException(path + " is not found!!!");
}
requestParams.addBodyParameter("filedata", file);
}
String photoUrl = baseUrl + "eventfileUpload";
//通过HTTP_UTILS来发送post请求， 并书写回调函数
LogUtil.e(this, "开始上传");
HTTP_UTILS.send(HttpMethod.POST, photoUrl, requestParams, new com.lidroid.xutils.http.callback.RequestCallBack<String>() {
@Override
public void onFailure(HttpException httpException, String arg1) {
listener.onLoadError(FILE_UPLOAD, false, "上报失败");
try {
throw new CustomException("上传失败:" + arg1);
} catch (CustomException e) {
e.printStackTrace();
}
}
@Override
public void onSuccess(ResponseInfo<String> responseInfo) {
LogUtil.e(this, "上传相应完成 HttpCode:" + responseInfo.result);
JSONObject json;
try {
json = new JSONObject(responseInfo.result);
result.setSuccess("0".equals(getStringValue(json, "code")));
result.setMessage(getStringValue(json, "message"));
result.setEntry(getStringValue(json, "data"));
} catch (JSONException e) {
e.printStackTrace();
}
pHandler.post(new Runnable() {
@Override
public void run() {
listener.onLoadComplete(FILE_UPLOAD, result);
}
});
}
});
}
private List<TaskCountInfo> parseCount(JSONObject list, String name) {
List<TaskCountInfo> taskList = new ArrayList<>();
try {
JSONArray dataList = getJSONArray(list, name);
for (int i = 0; i < dataList.length(); i++) {
TaskCountInfo taskEntity = new Gson().fromJson(dataList.getString(i), TaskCountInfo.class);
taskList.add(taskEntity);
}
} catch (Exception e) {
e.printStackTrace();
}
return taskList;
}
}
然后可以看到有两个方法
getHttpParams
parseStr这样就避免了每个网络请求都需要各自的activity中进行处理
然后是使用
实例化一个ApiData类型的参数，并指定是哪个网络请求
比如登录
private ApiData loginData = new ApiData(ApiData.HTTP_ID_login);ApiData.HTTP_ID_login这边指定了之后，loginData这个请求就对应了登录那个请求
然后在OnCreate中设置请求监听
loginData.setLoadingListener(this);BaseRequestData.OnHttpLoadingListener<BaseHttpResult>/**
* 开始加载
*
* @param id
*/
@Override
public void onLoadStart(int id) {
showProgressDialog("正在加载，请稍后。。");
}
/**
* 加载失败
*
* @param id
* @param bool
* @param errorMsg
*/
@Override
public void onLoadError(int id, boolean bool, String errorMsg) {
dismissProgressDialog();
if (errorMsg != null && errorMsg.length() > 15) {
showToast("操作失败，请检查后再试！");
} else {
showToast(errorMsg);
}
}
/**
* 加载成功
*
* @param id
* @param baseHttpResult
*/
@SuppressWarnings("unchecked")
public void onLoadComplete(int id, BaseHttpResult baseHttpResult) {
dismissProgressDialog();
}
@Override
public void onClick(View v) {
}看名字就知道了分别是加载开始，加载失败，加载成功
我们可以把这些写在BaseActivity或者BaseFragment中，把请求成功或者失败处理了，直接处理请求成功即可
加载成功返回的两个参数，一个id，一个baseHttpResult
id是用来区分请求的，比如你这个activity进行了多个请求，就可以根据id来判断，分别处理即可
baseHttpResult是返回的内容，提前经过了ApiData中的处理
比如登录，在ApiData的
parseStrcase HTTP_ID_login: {
UUID = msg;
list = getJSONObject(jsonObject, "data");
HttpLoginEntity loginEntity = new HttpLoginEntity();
loginEntity.setId(getStringValue(list, "fUserId"));
loginEntity.setRealName(getStringValue(list, "fRealName"));
loginEntity.setGender(getStringValue(list, "fGender"));
loginEntity.setAge(getStringValue(list, "fAge"));
loginEntity.setUserName(getStringValue(list, "fUserName"));
loginEntity.setDuty(getStringValue(list, "fDuty"));
loginEntity.setDepartment(getStringValue(list, "fDepartment"));
loginEntity.setDepartmentAlias(getStringValue(list, "fDepartmentAlias"));
loginEntity.setDesc(getStringValue(list, "fDesc"));
loginEntity.setTelephone(getStringValue(list, "fTelephone"));
// loginEntity.setPassword(params.getParams(id).get("password").toString());
loginEntity.setGrid(getStringValue(list, "fGrid"));
loginEntity.setPassword(getStringValue(list, "fPassword"));
loginEntity.setAuthority(getStringValue(list, "grantCode").replace("[", "").replace("]", "").replace("\"", ""));
loginEntity.setLoginCode("notfirst");
result.setEntry(loginEntity);
}
break;并通过
result.setEntry(loginEntity);这时候只需要在OnLoadComplete中
HttpLoginEntity loginInfo = (HttpLoginEntity) b.getEntry();对了还有进行网络请求
刚刚我们实例化了loginData
在我们需要进行请求的地方
loginData.loadData(name, psw);你看，我ApiData的getHttpParams方法里
case HTTP_ID_login:
params.setApiUrl(baseUrl + "GaClientService.do");
params.setRequestMothod(HTTP_MOTHOD.POST);
params.putParams("method", "login");
params.putParams("loginname", objects[0]);
params.putParams("passwd", MD5Util.getMD5(MD5Util.getMD5(objects[1].toString())));
params.putParams("source", "chongqingzxgs_mobile");
break;现在里面有name和pwd两个参数，在这里直接取的
所以传参数时，数量和位置必须和这边的对的上
然后就可以了，就可以正常的使用了，恩，记得导入一个httpmine和Volley的包
里面可能用到了我自己写的一些小工具类，比较简单，大家看名字也大概能猜出来是干嘛的，有错误就算屏蔽了也不影响使用
有什么不对，欢迎留言指正，或者留言询问
后面会考虑打成jar包的
扫一扫
3191
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
