Android通用网络请求解析框架.8（同步请求，分支部分）

笔者将通过11篇博客对个人开源框架进行讲解，本篇为第8篇，讲解支持同步请求，分支部分。

开源库github地址 https://github.com/qq296216078/Android-Universial-NetFrame

如果有兴趣一起讨论本框架的内容，请加QQ群：271335749

上一篇中我们已经完成了同步请求公共部分的代码实现，核心监听器的代码是这样的

abstract public class SyncNetHandleListener implements SyncNetListener {
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);
}

abstract protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException;
}

使用上SyncNetHandleListener，会是这样的

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();
}

还是存在代码执行顺序模糊的问题。还有内层数据的解析，需要开发者自己来完成。
如果在onReceivedRet回调的解析方法中直接返回null，那么在返回的NetRetBean的内层数据还是为null。

为了不让使用者来实现内层数据的解析，所以就应该在框架内部实现内层数据的解析。
那应该怎样在框架内部进行解析呢？学异步请求就好了，继承SyncNetHandleListener，来看看子类中是怎样解析数据的

package com.chenjian.net.listener.sync;

import com.chenjian.net.bean.NetRetBean;

import org.json.JSONException;

/**
* 返回字String的网络请求Listener
* <p>
* 作者： ChenJian
* 时间： 2016.12.15 14:54
*/

public class SyncNetStringListener extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
netRetBean.setServerObject(netRetBean.getServerData());
return handleResult(netRetBean);
}
}

这里的handleResult是父类的方法，根据之前的代码，父类这个方法只是将NetRetBean原封不动的返回。
因为父类中定义抽象方法onReceivedRet时需要返回值，所以这里需要将内层数据进行解析，然后再返回。
还有一个变化，因为本类不存在抽象方法，所以本类也不是抽象类了，不要在类的前面加上abstract。

对比一下异步请求的代码实现

abstract public class NetStringListener extends NetHandleListener {

@Override
protected void onReceivedRet(NetRetBean netRetBean) throws JSONException {
netRetBean.setServerObject(netRetBean.getServerData());
handleResult(netRetBean);
}

@SuppressWarnings("unchecked")
@Override
protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean) {
onSuccess((String) netRetBean.getServerObject());
}

/**
* 运行在ui线程，返回单个实体
*
* @param string 当前string
*/
abstract protected void onSuccess(String string);
}

可以看到，同步请求的时候，因为父类没有onSuccess方法，也不需要回调，所以同步请求代码实现起来更简单，只是将解析后的结果进行返回就可以了。
正如上面所说，同步请求的Listener不是抽象类，不要加abstract修饰类，

其它监听器也需要做类似的修改，继承SyncNetHandleListener，我们实现了SyncNetSingleBeanListener

package com.chenjian.net.listener.sync;

import com.chenjian.net.bean.NetBaseBean;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.util.NetBaseBeanUtil;

import org.json.JSONException;
import org.json.JSONObject;

/**
* 返回是单个Bean的网络请求Listener
* <p>
* 作者： ChenJian
* 时间： 2016.12.15 14:54
*/

public class SyncNetSingleBeanListener<T extends NetBaseBean> extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
JSONObject object = new JSONObject(netRetBean.getServerData());
T t = NetBaseBeanUtil.parseItem(getClass(), 0, object);
netRetBean.setServerObject(t);
return handleResult(netRetBean);
}
}

再实现SyncNetListBeanListener

package com.chenjian.net.listener.sync;

import com.chenjian.net.bean.NetBaseBean;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.util.NetBaseBeanUtil;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;

/**
* 返回是List<Bean>的网络请求Listener
* <p>
* 作者： ChenJian
* 时间： 2016.12.15 14:54
*/

public class SyncNetListBeanListener<T extends NetBaseBean> extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
JSONArray array = new JSONArray(netRetBean.getServerData());
List<T> list = new ArrayList<>();
for (int i = 0; i < array.length(); i++) {
JSONObject object = array.getJSONObject(i);
T t = NetBaseBeanUtil.parseItem(getClass(), 0, object);
list.add(t);
}
netRetBean.setServerObject(list);
return handleResult(netRetBean);
}
}

可以看到，同步请求分支部分的代码和异步请求时差不多，只是父类不一样，还有最后需要将结果进行返回，而不是回调。

到此，框架中同步请求的代码都已经添加完成，可以开始使用了

private void syncGetString() {
new Thread() {
@Override
public void run() {
String originalString = NetHelper.getStringSync("url");
System.out.println(originalString);

NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetStringListener());
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();
}

getStringSync返回的是最原始的数据，没有经过解析的，他不需要传入监听器参数。
getSync返回的是NetRetBean，传入的监听器类型的不同，NetRetBean中serverObject类型也会不同。当然这里需要开发者自己取出来进行强转。

笔者一开始想把serverObject对象的类型变成泛型，后来发现如果是自定义监听器进行同步请求时，一个泛型对象不够通用，还是得用到serverObjectMap属性才行。

回顾上一篇中的需求，根据url1请求的结果判断是否请求url2，我们可以这样实现

private void syncGetString() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url1", new SyncNetStringListener());
if (netRetBean.isSuccess()) {
NetHelper.getSync("url2", new SyncNetStringListener());
}

try {
Thread.sleep(60 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}

这样的话，代码的执行顺序就很清晰了，返回值的方式也非常符合同步请求的需求，代码看起来简单明了。

我们接着再来使用其它的Listener来完成同步请求。

假设服务端返回的数据是这样的：

{
"code":"00001",
"message":"login success",
"time":"1479807260",
"data":{
"id":"123",
"name":"chenjian"
}
}

NetUserBean的代码与之前的一样，没有改变

public class NetUserBean extends NetBaseBean {
private String id;
private String name;

@Override
public void initByJson(JSONObject jsonObject) throws JSONException {
this.id = jsonObject.optString("id");
this.name = jsonObject.optString("name");
}
}

开始使用

private void syncGetBean() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetSingleBeanListener<NetUserBean>());
CallbackCode callbackCode = netRetBean.getCallbackCode();
switch (callbackCode) {
case CODE_SUCCESS_REQUEST:
NetUserBean userBean = (NetUserBean) netRetBean.getServerObject();
System.out.println(userBean.toString());
break;
default:
System.out.println(netRetBean.toString());
break;
}
}
}.start();
}

居然报错了

NetRetBean{
mCallbackCode=CODE_ERROR_UNKNOWN,
mException=java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType,
mServerCode='null', mServerMsg='null', mServerTime='null', mServerData='null', mServerObject=null, mServerObjectMap=null}

再细看异常信息

01-11 13:35:45.470 2432-3428/com.chenjian.net W/System.err: java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.util.NetBaseBeanUtil.getBean(NetBaseBeanUtil.java:41)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.util.NetBaseBeanUtil.parseItem(NetBaseBeanUtil.java:28)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.listener.sync.SyncNetSingleBeanListener.onReceivedRet(SyncNetSingleBeanListener.java:30)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.listener.sync.SyncNetHandleListener.sendSuccess(SyncNetHandleListener.java:46)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.core.sync.SyncNetExcutor.startRequest(SyncNetExcutor.java:83)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.core.sync.SyncNetExcutor.get(SyncNetExcutor.java:64)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.helper.NetHelper.getSync(NetHelper.java:96)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.helper.NetHelper.getSync(NetHelper.java:80)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.demo.activity.GetActivity$5.run(GetActivity.java:189)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err: java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.util.NetBaseBeanUtil.getBean(NetBaseBeanUtil.java:41)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.util.NetBaseBeanUtil.parseItem(NetBaseBeanUtil.java:28)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.listener.sync.SyncNetSingleBeanListener.onReceivedRet(SyncNetSingleBeanListener.java:30)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.listener.sync.SyncNetHandleListener.sendSuccess(SyncNetHandleListener.java:46)
01-11 13:35:45.471 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.core.sync.SyncNetExcutor.startRequest(SyncNetExcutor.java:83)
01-11 13:35:45.472 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.core.sync.SyncNetExcutor.get(SyncNetExcutor.java:64)
01-11 13:35:45.472 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.helper.NetHelper.getSync(NetHelper.java:96)
01-11 13:35:45.472 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.helper.NetHelper.getSync(NetHelper.java:80)
01-11 13:35:45.472 2432-3428/com.chenjian.net W/System.err:     at com.chenjian.net.demo.activity.GetActivity$5.run(GetActivity.java:189)

重点在于这两行

java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
at com.chenjian.net.util.NetBaseBeanUtil.getBean(NetBaseBeanUtil.java:41)

我们再看看NetBaseBeanUtil的41行代码

Class<T> entityClass = (Class<T>) ((ParameterizedType) aClass.getGenericSuperclass()).getActualTypeArguments()[tIndex];

很明显的看出来了，aClass.getGenericSuperclass后，是一个Object类型，不能强转为ParameterizedType。
可是之前的SyncNetStringListener为什么没有报错呢？因为SyncNetStringListener并没有用到NetBaseBeanUtil，只是将数据解析为String类型，而不需要使用到NetBaseBeanUtil方法来获取Bean。

那又为什么异步请求时都没问题，而在这个地方就有问题呢？

回忆一下第4篇中提到的java泛型去参数化的概念，我们再来看看NetBaseBeanUtil的代码

public class NetBaseBeanUtil {

/**
* @param aClass     带泛型 T 的类，应该传入xxBeanListener监听器或其的子类。他的父类必须是带泛型T的
* @param tIndex     泛型 T 所在下标
* @param jsonObject 用来解析的 json
* @param <T>        泛型 T
* @return 返回泛型T的实例
* @throws JSONException
*/
public static <T extends NetBaseBean> T parseItem(Class aClass, int tIndex, JSONObject jsonObject) throws JSONException {
T t = getBean(aClass, tIndex);
t.initByJson(jsonObject);
return t;
}

/**
* @param aClass 带泛型 T 的类，应该传入xxBeanListener监听器或其的子类。他的父类必须是带泛型T的
* @param tIndex 泛型 T 所在下标
* @param <T>    泛型 T
* @return 返回泛型T的实例
*/
@SuppressWarnings("unchecked")
private static <T extends NetBaseBean> T getBean(Class aClass, int tIndex) {
Class<T> entityClass = (Class<T>) ((ParameterizedType) aClass.getGenericSuperclass()).getActualTypeArguments()[tIndex];
T entity = null;
try {
// 使用newInstance创建实例的类，必须有无参构造方法
entity = entityClass.newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return entity;
}
}

正如注释所说，这里的aClass的父类必须是带泛型的，而在使用异步请求的时候，因为需要回调，通常的做法是new一个Listener为内部类。而内部类实际上编译器会先定义一个类继承于他，然后再将那个类传入当参数。而同步请求，而直接new一个对象出来，并没有使用他的子类。一起来通过代码对比一下

异步请求我们使用内部类，其实get方法的第二个参数的类型，是NetSingleBeanListener的子类

NetHelper.get("url", new NetSingleBeanListener<NetUserBean>() {
@Override
protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {

}

@Override
protected void onSuccess(NetUserBean userBean) {

}
});

同步请求时，我们直接生成一个SyncNetStringListener的对象

NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetSingleBeanListener<NetUserBean>());

在两个Listener中，我们在使用NetBaseBeanUtil时，都调用了下面这一行代码

T t = NetBaseBeanUtil.parseItem(getClass(), 0, object);

getClass()非常重要，
在NetSingleBeanListener中，如果是他的子类调用了这个方法，那么返回的是他的子类
在SyncNetSingleBeanListener中，只是本类调用了这个方法，所以返回的是这个类本身


而这个时候，在NetBaseBeanUtil的getBean方法中，需要用到aClass.getGenericSuperclass，对传入的class对象进行操作，
如果传入的aClass是NetSingleBeanListener的子类，那么得到的父类是NetSingleBeanListener，他是带泛型的，可以通过代码取出泛型的类型，再反射
如果传入的aClass是SyncNetSingleBeanListener类，那么得到的父类是SyncNetHandleListener，他是不带泛型的，通过代码取出泛型时就会出错

那既然出现了问题，有办法能解决吗？总不能让同步请求实现不了吧。

一开始，我想到的是，不用getGenericSuperclass的方式取出泛型，而直接在aClass类中取出泛型，但是查阅相关资料后，发现这不可能的。

因为Java泛型去参数化（擦拭法）的原因，只有在 
超类（调用 getGenericSuperclass 方法）

或者成员变量（调用 getGenericType 方法）

或者方法（调用 getGenericParameterTypes 方法）

像这些有方法返回 ParameterizedType 类型的时候才能反射成功

所以使用的时候，必须使用他的子类，而不能直接使用本类。

可以说这非常蛋疼，但你又不得不遵守这样的规则。

那还有其它办法可以解决这个问题吗？显然是有的，只要学习异步请求，用子类就行了。

笔者一开始是直接继承SyncNetSingleBeanListener来实现一个类，假设为MyListener吧，类里面是空的。然后传参的时候，new MyListener()，发现不行的，单步调试时发现aClass.getGenericSuperclass时，居然还是SyncNetHandleListener，没有深入去研究，笔者猜想是编译器直接把这个空的MyListener类给删除掉了。

于是为了让开发者使用框架的时候不混乱，知道要使用哪个Listener，我想到了另一种办法。

还是学异步请求，直接把SyncNetSingleBeanListener定义为抽象类

package com.chenjian.net.listener.sync;

import com.chenjian.net.bean.NetBaseBean;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.util.NetBaseBeanUtil;

import org.json.JSONException;
import org.json.JSONObject;

/**
* 返回是单个Bean的网络请求Listener
* <p>
* 由于去参数化(擦拭法)，也只有在
* 超类（调用 getGenericSuperclass 方法）
* 或者成员变量（调用 getGenericType 方法）
* 或者方法（调用 getGenericParameterTypes 方法）
* 像这些有方法返回 ParameterizedType 类型的时候才能反射成功
* <p>
* 所以使用的时候，必须使用他的子类，而不能直接使用本类
* <p>
* 作者： ChenJian
* 时间： 2016.12.15 14:54
*/

abstract public class SyncNetSingleBeanListener<T extends NetBaseBean> extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
JSONObject object = new JSONObject(netRetBean.getServerData());
T t = NetBaseBeanUtil.parseItem(getClass(), 0, object);
netRetBean.setServerObject(t);
return handleResult(netRetBean);
}
}

这样一来，在使用他的时候，不能直接new，因为抽象类不能生成对象，必须使用他的子类才可以，不然不能编译通过。
一般开发者可以用内部类的方式，其实也是用到了他的子类

private void syncGetBean() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetSingleBeanListener<NetUserBean>() {
});
CallbackCode callbackCode = netRetBean.getCallbackCode();
switch (callbackCode) {
case CODE_SUCCESS_REQUEST:
NetUserBean userBean = (NetUserBean) netRetBean.getServerObject();
System.out.println(userBean.toString());
break;
default:
System.out.println(netRetBean.toString());
break;
}
}
}.start();
}

使用内部类时，只要加一对花括号{}就可以了，因为里面没有未实现的抽象方法，所以花括号里面是空的。

同样，对于SyncNetListBeanListener，我们也定义为抽象类

package com.chenjian.net.listener.sync;

import com.chenjian.net.bean.NetBaseBean;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.util.NetBaseBeanUtil;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.List;

/**
* 返回是List<Bean>的网络请求Listener
* <p>
* 由于去参数化(擦拭法)，也只有在
* 超类（调用 getGenericSuperclass 方法）
* 或者成员变量（调用 getGenericType 方法）
* 或者方法（调用 getGenericParameterTypes 方法）
* 像这些有方法返回 ParameterizedType 类型的时候才能反射成功
* <p>
* 所以使用的时候，必须使用他的子类，而不能直接使用本类
* <p>
* 作者： ChenJian
* 时间： 2016.12.15 14:54
*/

abstract public class SyncNetListBeanListener<T extends NetBaseBean> extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
JSONArray array = new JSONArray(netRetBean.getServerData());
List<T> list = new ArrayList<>();
for (int i = 0; i < array.length(); i++) {
JSONObject object = array.getJSONObject(i);
T t = NetBaseBeanUtil.parseItem(getClass(), 0, object);
list.add(t);
}
netRetBean.setServerObject(list);
return handleResult(netRetBean);
}
}

在使用时也很简单

private void syncGetListBean() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.getSync("url", new SyncNetListBeanListener<NetUserBean>() {
});
CallbackCode callbackCode = netRetBean.getCallbackCode();
switch (callbackCode) {
case CODE_SUCCESS_REQUEST:
List<NetUserBean> userBeen = (List<NetUserBean>) netRetBean.getServerObject();
for (int i = 0; i < userBeen.size(); i++) {
System.out.println(userBeen.get(i).toString());
}
break;
default:
System.out.println(netRetBean.toString());
break;
}
}
}.start();
}

到这里，框架内的同步请求代码已经全部完成。

最后再来回忆一下第6篇的内容，讲的是自定义解析器，其实现方案也只能适合异步请求，那么在同步请求时，我们只要学着SyncNetSingleBeanListener的实现思路，进行一些修改就行

package com.chenjian.net.demo.listener.sync;

import com.chenjian.net.bean.NetBaseBean;
import com.chenjian.net.bean.NetRetBean;
import com.chenjian.net.listener.sync.SyncNetHandleListener;
import com.chenjian.net.util.NetBaseBeanUtil;

import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
* 作者： ChenJian
* 时间： 2016.12.16 13:51
*/

abstract public class SyncNetCustomBeanListener<Page extends NetBaseBean, T extends NetBaseBean> extends SyncNetHandleListener {

@Override
protected NetRetBean onReceivedRet(NetRetBean netRetBean) throws JSONException {
JSONObject jsonObject = new JSONObject(netRetBean.getServerData());

Page page = NetBaseBeanUtil.parseItem(getClass(), 0, jsonObject);

List<T> list = new ArrayList<>();
JSONArray jsonArray = jsonObject.getJSONArray("list");
for (int i = 0; i < jsonArray.length(); i++) {
JSONObject object = jsonArray.getJSONObject(i);
T t = NetBaseBeanUtil.parseItem(getClass(), 1, object);
list.add(t);
}

Map<String, Object> map = new HashMap<>();
map.put("page", page);
map.put("list", list);

netRetBean.setServerObjectMap(map);
return handleResult(netRetBean);
}
}

使用起来是这样的

private void syncCustom() {
new Thread() {
@Override
public void run() {
NetRetBean netRetBean = NetHelper.postSync("url", "param", new SyncNetCustomBeanListener<NetPageBean, NetInfoBean>() {
});
CallbackCode callbackCode = netRetBean.getCallbackCode();
switch (callbackCode) {
case CODE_SUCCESS_REQUEST:
Map<String, Object> map = netRetBean.getServerObjectMap();
NetPageBean pageBean = (NetPageBean) map.get("page");
List<NetInfoBean> infoBeen = (List<NetInfoBean>) map.get("list");
System.out.println(pageBean.toString());
for (int i = 0; i < infoBeen.size(); i++) {
System.out.println(infoBeen.get(i).toString());
}
break;
default:
System.out.println(netRetBean.toString());
break;
}
}
}.start();
}

使用的时候，因为监听器内部的实现，要使到具体数据的话，要从NetRetBean的serverObjectMap里面取，map的key的值根据SyncNetCustomBeanListener中定义的一样。

总结一下，
当所使用的Listener需要调用NetBaseBeanUtil时，就要实现成抽象类，在使用这类监听器时，要使用他的子类。此处的例子有SyncNetSingleBeanListener，SyncNetListBeanListener，SyncNetCustomBeanListener。
当所使用的Listener不需要调用NetBaseBeanUtil时，就不要实现成抽象类了，在使用这类监听器时，直接创建他的对象。此处的唯一例子就是SyncNetStringListener。

可以说在开发者的角度，使用本框架进行异步请求或者同步请求差别并不大，只是入口从get变成getSync，post变成postSync，监听器也换成了相应的就行了。还要注意的是在自定义监听器时，如果开发者有需要使用到同步请求，也要实现一个同步请求的自定义解析器。如果不需要，就不要实现了。

至此，同步请求的所有内容都已讲解完成。

下一篇将讲解对第三方解析框架的支持
Android通用网络请求解析框架.9（支持第三方解析框架）