Android通用网络请求解析框架.7（同步请求，公共部分）

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

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

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

在第一篇中，需求讲解的时候，我们希望得到数据时，已经回到主线程

NetHelper.get("url", new NetSingleBeanListener<NetUserBean>() {    @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();}

开发者需要一些在后台定时跑的任务，固定一分钟进行几个接口的请求，这些请求在返回时不需要在主线程中有操作，或者开发者想自己用Handler来返回到主线程。

这个时候，也就是通常所说的同步请求，如果继续使用异步请求的代码，是可能出现问题的。

因为异步请求的代码中有些部分是不需要的

1.不需要创建AsyncTask

2.不需要创建Handler

第1点，开发者发起同步请求的时候，必须是自己已经处在子线程中，大家都知道ui线程中进行网络请求是会出错的。

第2点，在第1点的前提下创建的Handler，原先实现的代码是会报错的，通常会是这个错

Can't create handler inside thread that has not called Looper.prepare()

因为在非ui线程中创建的Handler，并不能将消息传送到ui线程，需要加入一些Looper相关的代码才可以。而同步请求不需要将结果返回到ui线程，所以这里的代码也是不需要的。

因为第2点的问题，所以在子线程中进行同步请求时，直接使用异步请求代码，会出现异常。那该怎么办呢？

这里有两个解决方案：

1.在之前的代码的许多地方加上一些参数，在调用的时候逐层传递进去，框架内层根据参数判断要进行哪些操作

2.重新模仿之前的代码，实现一套同步请求的代码

笔者采用了第2种办法。原因也有两点：

1.如果采用第1种办法，框架中的代码将会变得更复杂，提供给开发者使用的入口也会变得复杂。这导致了在编程和使用上都变麻烦了。

2.如果采用第2种办法，并不是所有代码都要重写，只要关键部分进行修改就可以了，与线程操作无关的代码，可以不要修改，所以实现起来也不麻烦。

在这里，我们先不急着实现同步请求的内步代码，我们先假设已经实现了相应代码，直接开始使用。

那么之前的需求，实现起来会是这样的

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的局部变量。明明是按顺序执行的代码，但这代码结构却让人感到非常蛋疼。对于按顺序同步执行的代码，笔者不能忍受用这种回调的方式来实现。

有没有好的办法解决呢？显然是有的，就像上面的代码一样，request1()的请求是有返回值的，而不是通过回调来返回。

那么，如果NetHelper.get方法具有返回值，就好办了，我们就可以这样完成需求

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方法，而且内部逻辑又麻烦了许多。需求都是不断变化的，返回值要根据需求做不同的变化。之前我们做异步请求，将不同的返回结果进行归类，成功和失败时的返回值有不同的回调。而现在一个方法只有一个返回值，我们要怎样在不改代码的情况下，让这个返回值适合各种情况呢？

可能有些人想到了用Map，对，Map是可以，但是Map里面的key值是哪些，取出来后每个value都要强转，确实够麻烦。

有现成的东西为什么不用呢？对了，就是NetRetBean，我们让同步请求时，就返回NetRetBean。

返回NetRetBean的好处我想大家能够明白的，因为这个类中封装了请求成功和失败时所有情况的数据，包括解析后的，还有自定义解析的数据。

拿到NetRetBean返回值后，根据CallbackCode判断请求是否成功，

如果成功，NetRetBean中的外层数据也都不为null

如果成功，NetRetBean的内层数据也不为null

如果失败，可以根据CallbackCode进行判断是哪种原因导致的

在使用上，应该是这样的

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

这里，我们为NetHelper添加了getSync方法，表明使用同步请求。

做的是同步请求，所以强转操作必须开发者自己来进行，因为serverObject是Object类型的。

之前笔者也想过将NetRetBean中serverObject的类型写成泛型，根据传入不同的监听器和泛型，自动转成相应的类型。但是后来因为自定义解析器时返回的数据可能不只有一个，可能是非常多个的，最后还是得用到NetRetBean中的serverObjectMap，所以放弃了将serverObject类型写成泛型的写法。

那么现在，之前的需求，根据url1请求的结果来判断是否进行url2请求，也就变成这样了

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好在可以通用，基本上所有返回结果的需求都包含了。

内部代码要如何实现呢？既然要返回值，那就应该逐层进行返回。看看代码，或许就更清楚了。

先从NetHelper入手，异步请求的代码利用NetExcutor进行get或者post操作，然后在返回时回调NetListener。

在这里，我们希望有数据返回，那么，直接在get或者post方法处进行返回，显然是非常合理的

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方法具有返回值而已。

接下来我们实现内部代码。根据之前的分析，在涉及线程相关的代码的地方，不再使用之前的类，而是重新写一套代码。

而NetExcutor类，里面就有AsyncTask，那就把原来的AsyncTask给去掉，换上另一个名字SyncNetExcutor

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;/** * 网络请求处理核心类 * <p> * 作者： 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的代码相比，有以下几处修改：

1.最大的变化就是去掉了AsyncTask，而在get和post两个入口不创建线程直接进行request请求。

2.NetListener换成了SyncNetListener。

3.get和post方法变成有返回值的了，返回值是NetRetBean，其返回值是从SyncNetListener处得来的。

4.增加了getString和postString方法，他返回的是String类型，是网络请求的直接返回结果。

先来看看SyncNetListener

package com.chenjian.net.core.sync;import com.chenjian.net.bean.NetRetBean;/** * 网络请求回调核心类 * <p> * 作者： 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，因为需要返回值嘛

因为内部代码的修改，外部调用也要做修改才行，我们接着来看看NetHelper入口吧

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;/** * 网络请求工具类 * <p> * 作者： 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，然后再把返回值给开发者。

getSync和postSync返回类型是NetRetBean，是网络请求解析后的结果。

getStringSync和postStringSync返回的是String类型，是网络请求的直接返回结果。

如果你直接使用getStringSync或者postStringSync，是非常简单的

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的。

如果我们直接调用NetHelper.getSync，会是这样的

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返回给上层。

所以最后执行的地方是getSync方法的返回，然后再往下执行，只是请求的过程当中调用了这两个回调中的一个。

从代码结构上，还是不能容忍的，而且，还他还没真正的去解析，还要开发者自己去完成解析和错误处理。

如果在回调的解析方法中直接返回null，那么返回的NetRetBean中的众多属性还是为null。

所以仅仅做到这里，同步请求的代码实现还没完成。解析和错误处理的代码，要在框架内部进行处理才合理。

回忆一下，异步请求时外层解析和错误处理是在NetHandleListener类里面，

而且，同步请求除了AsyncTask外，还有另一个与线程相关的代码，就是Handler，也在NetHandleListener中，

那么NetHandleListener也需要改写。

NetHandleListener继承自NetListener，所以我们实现一个SyncNetHandleListener，继承自SyncNetListener

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;/** * 公用网络逻辑，核心监听器。自定义监听器一般继承这个类 * <p> * 作者： 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;}

与NetHandleListener相比，SyncNetHandleListener显得更加简洁，这里的代码有以下几处改变：

1.最大的变化就是去掉了Handler，因为无需将解析后的结果返回到ui线程

2.由于1的变化，handleResult方法将直接返回NetRetBean，而不是通过Handler把数据传递给ui线程

3.onReceivedRet是具有返回值的，因为sendSuccess里面需要返回结果

4.去掉了onSuccess和onError方法，因为这里不需要再回调，而是直接返回结果

第2点中的handleResult方法，虽然只有一行，但是笔者为了让代码与异步请求的保持相似的风格，还是保留了这个方法。

公共部分的代码，还包括RequestUtil，HttpUtil，还有一些相关的类，这些类的代码都没有做修改。

这个时候，如果我们再调用NetHelper.getSync，使用上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();}

和使用SyncNetListener一样，还是存在代码执行顺序模糊的问题。还有内层数据的解析，需要开发者自己来完成。

如果在onReceivedRet回调的解析方法中直接返回null，那么在返回的NetRetBean的内层数据还是为null。

不过我们把外层的数据在SyncNetHandleListener类里面进行解析了，公共部分的代码实现完成了。

分支部分，即内层解析部分的代码还需要一定的篇幅，所以将其放到下一篇中去讲解。

至此，同步请求公共部分讲解完成。

下一篇，将讲解同步请求分支部分

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