Android通用网络请求解析框架.7（同步请求，公共部分）
NetHelper.get("url", new NetSingleBeanListener() {
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
// 这里是ui线程
}
@Override
protected void onSuccess(NetUserBean userBean) {
// 这里是ui线程
}
}); 这种情况，也是最常见的情况，就是我们通常所说的异步请求。
private void startRequest() {
new Thread() {
@Override
public void run() {
request1();
request2();
try {
Thread.sleep(60 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}Can't create handler inside thread that has not called Looper.prepare()因为在非ui线程中创建的Handler，并不能将消息传送到ui线程，需要加入一些Looper相关的代码才可以。而同步请求不需要将结果返回到ui线程，所以这里的代码也是不需要的。
private void startRequest() {
new Thread() {
@Override
public void run() {
NetHelper.get("url1", new NetStringListener() {
@Override
protected void onSuccess(String string) {
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
}
NetHelper.get("url2", new NetStringListener() {
@Override
protected void onSuccess(String string) {
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
}
}.start();
}url1和url2的请求是按顺序下来的，也就是说url1必须是请求结束了，要么回调了onSuccess，要么回调了onError，才会开始url2请求。这看起来非常的奇怪，同步执行的代码，看不出来他们的顺序性。再看看这样的需求
private void startRequest() {
new Thread() {
@Override
public void run() {
if (request1()) {
request2();
}
}
}.start();
}url2的请求需要依赖url1请求的结果。如果用NetHelper实现，代码看起来就非常的奇怪了
private void startRequest() {
new Thread() {
@Override
public void run() {
NetHelper.get("url1", new NetStringListener() {
@Override
protected void onSuccess(String string) {
NetHelper.get("url2", new NetStringListener() {
@Override
protected void onSuccess(String string) {
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
});
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
});
}
}.start();
}需要嵌套多层，同步执行的代码，因为回调的原因，让开发者看不明白执行顺序。而且回调方法里面的参数，并不能直接给下面的代码使用，必须要用到全局变量才行，回调方法中如果要使用外部的变量，也需要全局变量，或者定义为final的局部变量。明明是按顺序执行的代码，但这代码结构却让人感到非常蛋疼。对于按顺序同步执行的代码，笔者不能忍受用这种回调的方式来实现。
private void startRequest() {
new Thread() {
@Override
public void run() {
boolean ret = NetHelper.get("url1", new NetStringListener() {
@Override
protected void onSuccess(String string) {
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
});
if (ret) {
NetHelper.get("url2", new NetStringListener() {
@Override
protected void onSuccess(String string) {
}
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {
}
});
}
}
}.start();
}看起来好像是可以，我们甚至可以用NetTempListener，不需要实现回调，让代码更简洁
private void startRequest() {
new Thread() {
@Override
public void run() {
boolean ret = NetHelper.get("url1", new new NetTempListener());
if (ret) {
NetHelper.get("url2", new NetTempListener());
}
}
}.start();
}可是问题又来了，这里的get方法只能返回boolean类型，如果需求是根据url1请求的结果解析后的Bean的某一个属性来判断是否要进行url2请求，那么又要写一个不同返回值的get方法，而且内部逻辑又麻烦了许多。需求都是不断变化的，返回值要根据需求做不同的变化。之前我们做异步请求，将不同的返回结果进行归类，成功和失败时的返回值有不同的回调。而现在一个方法只有一个返回值，我们要怎样在不改代码的情况下，让这个返回值适合各种情况呢？
private void startRequest() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new NetTempListener());
CallbackCode callbackCode = netRetBean.getCallbackCode();
switch (callbackCode) {
case CODE_SUCCESS_REQUEST:
String string = (String) netRetBean.getServerObject();
System.out.println(string);
break;
case CODE_ERROR_HTTP_NOT_200:
case CODE_ERROR_REQUEST_EXP:
case CODE_ERROR_SERVER_DATA_ERROR:
case CODE_ERROR_JSON_EXP:
case CODE_ERROR_UNKNOWN:
default:
System.out.println(netRetBean.toString());
break;
}
}
}.start();
}private void startRequest() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url1", new NetTempListener());
if (netRetBean.isSuccess()) {
NetHelper.getSync("url2", new NetTempListener());
}
}
}.start();
}使用上代码好像没有比返回boolean简洁多少，但是NetRetBean好在可以通用，基本上所有返回结果的需求都包含了。
public class NetHelper {
public static NetRetBean getSync(String url, boolean isWaitForToken, NetListener netListener) {
NetExcutor netExcutor = new NetExcutor();
netExcutor.setUrl(url);
netExcutor.setWaitForToken(isWaitForToken);
netExcutor.setNetListener(netListener);
return netExcutor.get();
}
}对比之前的代码，仅仅是让get方法具有返回值而已。
package com.chenjian.net.core.sync;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.core.common.RequestType;
import com.chenjian.net.request.RequestUtil;
import com.chenjian.net.token.TokenUtil;
/**
* 网络请求处理核心类
*
* 作者： ChenJian
* 时间： 2016.12.13 17:42
*/
public class SyncNetExcutor {
/**
* 请求url
*/
private String mUrl;
/**
* 请求类型
*/
private RequestType mRequestType;
/**
* post请求时的参数
*/
private String mParams;
/**
* 是否先等待token请求成功
*/
private boolean isWaitForToken;
/**
* 请求后的回调
*/
private SyncNetListener mSyncNetListener;
public void setUrl(String url) {
this.mUrl = url;
}
private void setRequestType(RequestType requestType) {
this.mRequestType = requestType;
}
public void setParams(String params) {
this.mParams = params;
}
public void setWaitForToken(boolean waitForToken) {
isWaitForToken = waitForToken;
}
public void setSyncNetListener(SyncNetListener syncNetListener) {
this.mSyncNetListener = syncNetListener;
}
public NetRetBean get() {
setRequestType(RequestType.REQUEST_TYPE_GET);
return startRequest();
}
public NetRetBean post() {
setRequestType(RequestType.REQUEST_TYPE_POST);
return startRequest();
}
/**
* 同步请求，直接返回
*
* @return 返回 NetRetBean
*/
private NetRetBean startRequest() {
if (isWaitForToken) {
TokenUtil.waitToken();
}
try {
String result = request();
return mSyncNetListener.sendSuccess(result);
} catch (Exception e) {
e.printStackTrace();
return mSyncNetListener.sendError(e);
}
}
public String getString() {
setRequestType(RequestType.REQUEST_TYPE_GET);
return startRequestString();
}
public String postString() {
setRequestType(RequestType.REQUEST_TYPE_POST);
return startRequestString();
}
/**
* 同步请求，直接返回
*
* @return 返回 String
*/
private String startRequestString() {
if (isWaitForToken) {
TokenUtil.waitToken();
}
try {
return request();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private String request() throws Exception {
String result = null;
switch (mRequestType) {
case REQUEST_TYPE_GET:
result = RequestUtil.getRequest(mUrl);
break;
case REQUEST_TYPE_POST:
result = RequestUtil.postRequest(mUrl, mParams);
break;
default:
break;
}
return result;
}
}
与NetExcutor的代码相比，有以下几处修改：
package com.chenjian.net.core.sync;
import com.chenjian.net.bean.NetRetBean;
/**
* 网络请求回调核心类
*
* 作者： ChenJian
* 时间： 2016.12.13 17:42
*/
public interface SyncNetListener {
/**
* http请求，数据解密部分，成功
*
* @param result result
* @return NetRetBean
*/
NetRetBean sendSuccess(String result);
/**
* http请求，数据解密部分，失败
*
* @param e e
* @return NetRetBean
*/
NetRetBean sendError(Exception e);
}
只是把之前的返回类型void改成NetRetBean，因为需要返回值嘛
package com.chenjian.net.helper;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.core.async.NetExcutor;
import com.chenjian.net.core.async.NetListener;
import com.chenjian.net.core.sync.SyncNetExcutor;
import com.chenjian.net.core.sync.SyncNetListener;
import com.chenjian.net.data.NetConstants;
/**
* 网络请求工具类
*
* 作者： ChenJian
* 时间： 2016.12.14 11:24
*/
public class NetHelper {
/**
* get同步请求
*
* @param url url
* @param syncNetListener 监听器
* @return NetRetBean
*/
public static NetRetBean getSync(String url, SyncNetListener syncNetListener) {
return getSync(url, NetConstants.defaultWaitForToken, syncNetListener);
}
/**
* get同步请求
*
* @param url url
* @param isWaitForToken 是否等待token请求成功
* @param syncNetListener 监听器
* @return NetRetBean
*/
public static NetRetBean getSync(String url, boolean isWaitForToken, SyncNetListener syncNetListener) {
SyncNetExcutor syncNetExcutor = new SyncNetExcutor();
syncNetExcutor.setUrl(url);
syncNetExcutor.setWaitForToken(isWaitForToken);
syncNetExcutor.setSyncNetListener(syncNetListener);
return syncNetExcutor.get();
}
/**
* post同步请求
*
* @param url url
* @param params 参数
* @param syncNetListener 监听器
* @return NetRetBean
*/
public static NetRetBean postSync(String url, String params, SyncNetListener syncNetListener) {
return postSync(url, params, NetConstants.defaultWaitForToken, syncNetListener);
}
/**
* post同步请求
*
* @param url url
* @param params 参数
* @param isWaitForToken 是否等待token请求成功
* @param syncNetListener 监听器
* @return NetRetBean
*/
public static NetRetBean postSync(String url, String params, boolean isWaitForToken, SyncNetListener syncNetListener) {
SyncNetExcutor syncNetExcutor = new SyncNetExcutor();
syncNetExcutor.setUrl(url);
syncNetExcutor.setParams(params);
syncNetExcutor.setWaitForToken(isWaitForToken);
syncNetExcutor.setSyncNetListener(syncNetListener);
return syncNetExcutor.post();
}
/**
* get同步请求，不设置监听器，直接返回数据给调用者
*
* @param url url
* @return String
*/
public static String getStringSync(String url) {
return getStringSync(url, NetConstants.defaultWaitForToken);
}
/**
* get同步请求，不设置监听器，直接返回数据给调用者
*
* @param url url
* @param isWaitForToken 是否等待token请求成功
* @return String
*/
public static String getStringSync(String url, boolean isWaitForToken) {
SyncNetExcutor syncNetExcutor = new SyncNetExcutor();
syncNetExcutor.setUrl(url);
syncNetExcutor.setWaitForToken(isWaitForToken);
return syncNetExcutor.getString();
}
/**
* post同步请求，不设置监听器，直接返回数据给调用者
*
* @param url url
* @param params 参数
* @return String
*/
public static String postStringSync(String url, String params) {
return postStringSync(url, params, NetConstants.defaultWaitForToken);
}
/**
* post同步请求，不设置监听器，直接返回数据给调用者
*
* @param url url
* @param params 参数
* @param isWaitForToken 是否等待token请求成功
* @return String
*/
public static String postStringSync(String url, String params, boolean isWaitForToken) {
SyncNetExcutor syncNetExcutor = new SyncNetExcutor();
syncNetExcutor.setUrl(url);
syncNetExcutor.setParams(params);
syncNetExcutor.setWaitForToken(isWaitForToken);
return syncNetExcutor.postString();
}
}
使用起来也就是调用SyncNetExcutor，然后再把返回值给开发者。
private void syncGetString() {
new Thread() {
@Override
public void run() {
String getString = NetHelper.getStringSync("url");
System.out.println(getString);
String postString = NetHelper.getStringSync("url");
System.out.println(postString);
}
}.start();
}这两个方法只是简单的返回网络请求的数据，并没有对数据进行任何解析，而且返回的string是可能为null的。
private void startRequest() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetListener() {
@Override
public NetRetBean sendSuccess(String result) {
return null;
}
@Override
public NetRetBean sendError(Exception e) {
return null;
}
});
}
}.start();
}这里的回调并不是最后执行的地方。我们看看SyncNetExcutor中的部分代码
public NetRetBean get() {
setRequestType(RequestType.REQUEST_TYPE_GET);
return startRequest();
}
public NetRetBean post() {
setRequestType(RequestType.REQUEST_TYPE_POST);
return startRequest();
}
/**
* 同步请求，直接返回
*
* @return 返回 NetRetBean
*/
private NetRetBean startRequest() {
if (isWaitForToken) {
TokenUtil.waitToken();
}
try {
String result = request();
return mSyncNetListener.sendSuccess(result);
} catch (Exception e) {
e.printStackTrace();
return mSyncNetListener.sendError(e);
}
}调用监听器来实现成功和失败时候的处理，而且都要返回一个NetRetBean，然后再把这个NetRetBean返回给上层。
package com.chenjian.net.listener.sync;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.core.sync.SyncNetListener;
import com.chenjian.net.exp.RequestErrorException;
import com.chenjian.net.exp.RespondErrorException;
import com.chenjian.net.listener.common.CallbackCode;
import org.json.JSONException;
import org.json.JSONObject;
/**
* 公用网络逻辑，核心监听器。自定义监听器一般继承这个类
*
* 作者： ChenJian
* 时间： 2016.12.15 11:12
*/
abstract public class SyncNetHandleListener implements SyncNetListener {
/**
* 处理NetRetBean并返回。是一个中转站。本类和其子类都可以调用这个方法
*
* @param netRetBean netRetBean
* @return netRetBean
*/
protected NetRetBean handleResult(NetRetBean netRetBean) {
return netRetBean;
}
@Override
public NetRetBean sendSuccess(String result) {
NetRetBean netRetBean = new NetRetBean();
try {
JSONObject jsonObject = new JSONObject(result);
String code = jsonObject.getString("code");
String message = jsonObject.getString("message");
String time = jsonObject.getString("time");
String data = jsonObject.getString("data");
netRetBean.setServerCode(code);
netRetBean.setServerMsg(message);
netRetBean.setServerTime(time);
netRetBean.setServerData(data);
if (code.equals("00001")) {
netRetBean.setCallbackCode(CallbackCode.CODE_SUCCESS_REQUEST);
netRetBean = onReceivedRet(netRetBean);
} else {
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_SERVER_DATA_ERROR);
}
} catch (JSONException e) {
e.printStackTrace();
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_JSON_EXP);
}
return handleResult(netRetBean);
}
@Override
public NetRetBean sendError(Exception exp) {
exp.printStackTrace();
NetRetBean netRetBean = new NetRetBean();
netRetBean.setException(exp);
try {
throw exp;
} catch (RespondErrorException e) {
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_HTTP_NOT_200);
} catch (RequestErrorException e) {
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_REQUEST_EXP);
} catch (JSONException e) {
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_JSON_EXP);
} catch (Exception e) {
netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_UNKNOWN);
}
return handleResult(netRetBean);
}
/**
* 子类根据业务区分，将netRetBean解析成list或者单个实体，或者解析成其它结果
*
* @param netRetBean server返回的数据实体，data字段将在子类中解析
* @return 解析后的netRetBean
* @throws JSONException 解析json异常
*/
abstract protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException;
}
private void syncGetString() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetHandleListener() {
@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
return null;
}
});
}
}.start();
}和使用SyncNetListener一样，还是存在代码执行顺序模糊的问题。还有内层数据的解析，需要开发者自己来完成。