Android通用网络请求解析框架.2（构造框架）

笔者将通过11篇博客对个人开源框架进行讲解，本篇为第2篇，讲解构造框架。

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

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

本篇可能会有部分源码，但依然不是讲解具体源码实现。

上一篇中已经总结出了我们想要的网络请求框架，类似于下面这样

Util<T>.getBean("url") {    onSuccess(T t) {    }    onError(int errorCode, ErrorBean ErrorBean) {    }};

这显然，是在使用者层面的，一般是在Activity里面调用。

对于使用者，我们一般采用单例，或者静态方法。笔者感觉，静态方法在此处更方便，看起来更简洁。

因此，我们的第一个模块，也就是入口模块，应该是一个类里面拥有get和post等静态方法

public class NetHelper {    public static void get(String url) {    }    public static void post(String url, String param) {            }}

在静态方法里面，我们要进行网络请求，解析，回调。

因为内容太多，所以还是不能直接在get和post方法里面直接执行，还得交给另一个类，把他命名为NetExcutor，他将会是一个核心的枢纽。

也因为要回调，所以我们的入口，将会改成下面这样

public class NetHelper {    public static void get(String url, NetListener netListener) {        NetExcutor netExcutor = new NetExcutor();        netExcutor.setUrl(url);        netExcutor.setExcutorListener(listener);        netExcutor.get();    }    public static void post(String url, String params, NetListener netListener) {        NetExcutor netExcutor = new NetExcutor();        netExcutor.setUrl(url);        netExcutor.setParams(params);        netExcutor.setExcutorListener(listener);        netExcutor.post();    }}

NetHelper的工作非常明确，创建一个NetExcutor实例，把参数交给他，让他发起请求，往后需要回调，也是他来做。到这里，入口模块基本完成。

接着，我们开始第二个模块，深入NetExcutor。

在其中，必须有几个属性，url，params，netListener，并且至少要有这些属性的set方法。

更重要的，是要有两个公有方法，get和post，这两个方法中，开启线程，进行请求，并将结果通过listener回调。看看代码

public class NetExcutor {    /**     * 请求url     */    private String mUrl;    /**     * 请求类型     */    private RequestType mRequestType;    /**     * post请求时的参数     */    private String mParams;    /**     * 请求后的回调     */    private NetListener mExcutorListener;    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 setExcutorListener(NetListener listener) {        this.mExcutorListener = listener;    }    public void get() {        setRequestType(RequestType.REQUEST_TYPE_GET);        new NetTask().execute();    }    public void post() {        setRequestType(RequestType.REQUEST_TYPE_POST);        new NetTask().execute();    }    /**     * 网络请求异步任务，android 8 以上系统会自己对异步任务做线程池处理     * <p>     * 此处也可以改成自己去写线程池，让调用者可以配置线程池的相关参数     */    private class NetTask extends AsyncTask<String, Integer, Boolean> {        @Override        protected Boolean doInBackground(String... params) {            try {                String result = request();                mExcutorListener.sendSuccess(result);                return true;            } catch (Exception e) {                e.printStackTrace();                mExcutorListener.sendError(e);                return false;            }        }    }    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;    }}

结构上挺清楚的，保存好set进来的参数，在get和post时去做相应的请求。此处加了一个请求类型，来判断是get还是post。

关键的，此处用了AsyncTask，而不是Thread。可以说我偷懒了，但是正如上面注释所说，android 8 或者以上，系统已经对异步任务做线程池处理，我们打开源码看看

public abstract class AsyncTask<Params, Progress, Result> {    private static final String LOG_TAG = "AsyncTask";    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();    // We want at least 2 threads and at most 4 threads in the core pool,    // preferring to have 1 less than the CPU count to avoid saturating    // the CPU with background work    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;    private static final int KEEP_ALIVE_SECONDS = 30;    private static final ThreadFactory sThreadFactory = new ThreadFactory() {        private final AtomicInteger mCount = new AtomicInteger(1);        public Thread newThread(Runnable r) {            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());        }    };    private static final BlockingQueue<Runnable> sPoolWorkQueue =            new LinkedBlockingQueue<Runnable>(128);

此处只放上部分api24的源码，通过查看源码和注释以及文档，可以发现系统已经做了线程池处理，且一些参数是跟cpu核数相关的，可以说做法非常合理。

笔者并没有重写onPostExecute方法，而采用了AsyncTask和Handler结合使用，Handler下面会讲到。这是为了方便开发者修改成Thread和Handler的方式，那样的话，必须有自己的默认线程池配置，外部必须提供改变线程池配置方法，因为笔者的偷懒，线程池这块，暂时用AsyncTask代替了。其实系统内部AsyncTask也是使用线程和事件的方式，这种做法平常也有用到过，而且笔者在项目中已经使用本框架，并没有发现有什么问题。如果开发者需要，可以自行修改成线程池方式。

监听器的实现非常简单

public interface NetListener {    /**     * http请求，数据解密部分，成功     *     * @param result result     */    void sendSuccess(String result);    /**     * http请求，数据解密部分，失败     *     * @param e e     */    void sendError(Exception e);}

这里提到了数据解密，结合NetExcutor的代码，我们发现实际上http请求是调用RequestUtil类里面的方法，可以推断，数据的加解密是在其中完成。枢纽模块，完成。

来看看下一个模块，RequestUtil，直接上代码

public class RequestUtil {    /**     * get请求     *     * @param url url     * @return 返回请求的结果     * @throws Exception     */    public static String getRequest(String url) throws Exception {        String ret;        String tmp = HttpUtil.get(url);        ret = AesUtil.decryptToString(tmp);        return ret;    }    /**     * post请求     *     * @param url   url     * @param param post请求的参数     * @return 返回请求的结果     * @throws Exception     */    public static String postRequest(String url, String param) throws Exception {        String ret;        String data = AesUtil.encryptToString(param);        String tmp = HttpUtil.post(url, data);        ret = AesUtil.decryptToString(tmp);        return ret;    }}

这里还是没有直接进行http请求，因为在请求前和请求后，通常有其它的业务要处理，比如此处的加解密，由AesUtil完成。

本框架不涉及具体加解密的操作，AesUtil里面的方法也仅仅是将传入的参数原样返回。

由于篇幅，HttpUtil模块此处不做详细介绍，其内部就是通过HttpUrlConnection发起请求并返回数据，过程中有异常随时抛出，具体代码之后的章节会讲到。

到这里，请求的部分基本完成了，请求成功了，就会回调sendSuccess，失败了，就回调sendError。

但如果仅仅做到这个程度，开发者在外层调用的时候，会变成这样

NetHelper.get("url", new NetListener() {    @Override    public void sendSuccess(String result) {                    }    @Override    public void sendError(Exception e) {    } });

这里的result只是最原始的数据，还差了解析。那么，解析应该在哪里完成呢？如果让调用者直接实现，那么在使用的时候还是显得非常麻烦。

而且上一篇中所讲的外层内层数据解析分离的思想，还是没用上。先来回忆一下上一篇所讲的解析分层思想

abstract public class ParseJson {    private void parseJson(String jsonString) throws JSONException {        JSONObject jsonObject = new JSONObject(jsonString);        String code = jsonObject.getString("code");        String message = jsonObject.getString("message");        Object data = parseData(jsonObject.getString("data"));    }    abstract Object parseData(String jsonString) throws JSONException;}

因此，我们需要一个模块，来完成外层解析，很明显，他要继承NetListener

abstract public class NetParseListener implements NetListener {    @Override    public void 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);            onReceivedRet(netRetBean);            onSuccess();        } catch (JSONException e) {            onError();        }    }    @Override    public void sendError(Exception exp) {        exp.printStackTrace();        onError();    }    /**     * 子类根据业务区分，将netRetBean解析成list或者单个实体，或者解析成其它结果     *     * @param netRetBean server返回的数据实体，data字段将在子类中解析     * @throws JSONException 解析json异常     */    abstract protected void onReceivedRet(NetRetBean netRetBean) throws JSONException;    /**     * ui线程中实现这个方法来得到网络请求返回的数据     *     * @param successCode 成功的code     * @param netRetBean  成功的实体bean，data字段已经在子类中解析完成     */    abstract protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean);    /**     * ui线程来处理错误码和错误信息     *     * @param errorCode  错误的code     * @param netRetBean 错误的实体bean，字段可能不完整（完整的话还是error吗？呵呵）     */    abstract protected void onError(CallbackCode errorCode, NetRetBean netRetBean);}

可以很清楚的看出来，在sendSuccess的时候，进行外层解析，然后把内层解析交给onReceivedRet，这个方法由子类根据具体业务来实现。

还有，这里使用到了一个NetRetBean，顾名思义，是返回数据的包装，可以说是一个大杂烩

public class NetRetBean {    /**     * 返回码，具体说明请看{@link com.chenjian.net.listener.common.CallbackCode}     */    private CallbackCode mCallbackCode;    /**     * 请求过程中发生异常，包括请求时，解析时。可能为null     */    private Exception mException;    /**     * 服务端的返回码，是服务端返回的数据中解析“code”字段得到的。可能为null     */    private String mServerCode;    /**     * 服务端返回的消息，是服务端返回的数据中解析“message”字段得到的。可能为null     */    private String mServerMsg;    /**     * 服务端返回的时间，是服务端返回的数据中解析“time”字段得到的。可能为null     */    private String mServerTime;    /**     * 服务端返回的数据，是服务端返回的数据中解析“data”字段得到的。可能为null     */    private String mServerData;    /**     * 服务端返回的数据解析成的bean，是用mServerData字段进行json解析得到的。可能为null     */    private Object mServerObject;}

属性的注释已经说明得很清楚。这里还有个CallbackCode，是一个枚举类型，里面定义了返回码。

这个时候，因为这个类中已经实现了sendSuccess和sendError方法，而且他增加了三个抽象方法，

所以如果直接使用NetParseListener，你就要实现三个抽象方法

NetHelper.get("url", new NetParseListener() {    @Override    protected void onReceivedRet(NetRetBean netRetBean) throws JSONException {                    }    @Override    protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean) {    }    @Override    protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {    }});

首先，解析还是没有，onReceivedRet方法里面的netRetBean，只是外层解析了，内层的mServerData字段还没解析，也就是说mServerObject字段还是null。

不急，先来解决一下另一个问题，那就是这三个方法，还是在子线程，他们还没返回到ui线程，要怎么办呢？其实在NetParseListener里面写一个Handler就行了

abstract public class NetHandleListener implements NetListener {    @SuppressLint("HandlerLeak")    private Handler mHandler = new Handler() {        public void handleMessage(Message msg) {            switch (msg.what) {                case 1:                    callbackResult((NetRetBean) msg.obj);                    break;            }        }    };    private void callbackResult(NetRetBean netRetBean) {        switch (netRetBean.getCallbackCode()) {            case CODE_ERROR_SERVER_DATA_ERROR:            case CODE_ERROR_JSON_EXP:            case CODE_ERROR_UNKNOWN:                onError(netRetBean.getCallbackCode(), netRetBean);                break;            case CODE_SUCCESS_REQUEST:            case CODE_SUCCESS_LOCAL:                onSuccess(netRetBean.getCallbackCode(), netRetBean);                break;            default:                break;        }    }    /**     * 将非ui线程处理结果传到ui线程去。是一个中转站。本类和其子类都可以调用这个方法     *     * @param netRetBean 要返回给ui线程的实体     */    protected void handleResult(NetRetBean netRetBean) {        Message msg = Message.obtain();        msg.what = 1;        msg.obj = netRetBean;        mHandler.sendMessage(msg);    }    @Override    public void 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);                onReceivedRet(netRetBean);                return;            } else {                netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_SERVER_DATA_ERROR);            }        } catch (JSONException e) {            e.printStackTrace();            netRetBean.setCallbackCode(CODE_ERROR_JSON_EXP);        }        handleResult(netRetBean);    }    @Override    public void sendError(Exception exp) {        exp.printStackTrace();        NetRetBean netRetBean = new NetRetBean();        netRetBean.setException(exp);        try {            throw exp;        } catch (JSONException e) {            netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_JSON_EXP);        } catch (Exception e) {            netRetBean.setCallbackCode(CallbackCode.CODE_ERROR_UNKNOWN);        }        handleResult(netRetBean);    }        abstract protected void onReceivedRet(NetRetBean netRetBean) throws JSONException;        abstract protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean);        abstract protected void onError(CallbackCode errorCode, NetRetBean netRetBean);}

此时不是直接调用onError和onSuccess，而是通过中转站，handleResult方法，来转给ui线程。这样，开发者进行使用的时候，回调已经是在ui线程了。

此处也看出了，Handler的代码，只写了一次。这个类，名字也改成了NetHandleListener。

接下来，去完成分层解析的内层，内层解析还是不能直接让开发者来实现，应该进行包装。用同样的思想，我们再继承NetHandleListener

abstract public class NetSingleBeanListener extends NetHandleListener {    @Override    protected void onReceivedRet(NetRetBean netRetBean) throws JSONException {        JSONObject object = new JSONObject(netRetBean.getServerData());        Bean bean = BeanUtil.parseItem(object);        netRetBean.setServerObject(bean);        handleResult(netRetBean);    }    @SuppressWarnings("unchecked")    @Override    protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean) {        onSuccess((Bean) netRetBean.getServerObject());    }    abstract protected void onSuccess(Bean bean);}

NetSingleBeanListener，顾名思义，是解析单个Bean，在其中，使用了BeanUtil去解析，BeanUtil里面，可以使用gson，fastjson，也可以自己解析。

onReceivedRet里面调用handleResult是父类里面的方法，其将通过中转站，回调到本类的onSuccess(CallbackCode, NetRetBean)方法。
这里我们实现了两个抽象方法，onReceivedRet和onSuccess，同时增加了一个抽象方法。

这样，开发者在使用的时候，只要重写onError和onSuccess(Bean bean)方法就行了

NetHelper.get("url", new NetSingleBeanListener() {    @Override    protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {    }    @Override    protected void onSuccess(Bean bean) {                    }});

可是大问题出现了，NetSingleBeanListener怎么知道你要解析哪个Bean呢？

你应该想起来了，就是上一篇所说的：泛型

泛型要怎么传入呢？我想方法不只有一种，可以将其当成方法的参数，也可以直接写在类上。笔者采用了后面一种做法

经过修改后，NetSingleBeanListener，就会是这样

abstract public class NetSingleBeanListener<T> extends NetHandleListener {    @Override    protected void onReceivedRet(NetRetBean netRetBean) throws JSONException {        JSONObject object = new JSONObject(netRetBean.getServerData());        T t = NetBeanUtil.parseItem(object);        netRetBean.setServerObject(t);        handleResult(netRetBean);    }    @SuppressWarnings("unchecked")    @Override    protected void onSuccess(CallbackCode successCode, NetRetBean netRetBean) {        onSuccess((T) netRetBean.getServerObject());    }    /**     * 运行在ui线程，返回单个实体     *     * @param t 当前bean     */    abstract protected void onSuccess(T t);}

开发者在调用的时候，传入具体类型，onSuccess里面，就会回调具体类型

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

可以说到这里，已经实现得相当完美了，你传入什么类型的Bean，回调的时候，参数就是什么类型的。

但是在NetSingleBeanListener里，那个NetBeanUtil，是怎么解析Bean的？传入的Bean仅仅是一个泛型T，要怎么把JsonObject解析成T实体？

想当然的，我实现了以下的代码

public class NetBeanUtil {    public static <T> T parseItem(JSONObject jsonObject) throws JSONException {        T t = new T();        t.initByJson(jsonObject);        return t;    }}

此段代码有两个错，

1.  T t = new T(); 这行代码并不能编译通过，java不允许编译时期对泛型用new来创建实例。

2.  T 是未知类型，他哪里来的initByJson方法？

解决第1个问题，只能通过反射的方式来解决了。像第三方解析框架，gson，fastjson，也用到了同样的方法

private static <T> T getBean(Class aClass) {    Class<T> entityClass = (Class<T>) ((ParameterizedType) aClass.getGenericSuperclass()).getActualTypeArguments()[0];    T entity = null;    try {        // 使用newInstance创建实例的类，必须有无参构造方法        entity = entityClass.newInstance();    } catch (InstantiationException e) {        e.printStackTrace();    } catch (IllegalAccessException e) {        e.printStackTrace();    }    return entity;}

这段代码还是得解释一下，把aClass父类取出来，准确的说是返回Type类型，强转成ParameterizedType类型，再取出泛型参数数组的第0个，也就是泛型的Class对象。

试想一下，如果aClass传入的是NetSingleBeanListener的子类，那么entityClass不就是泛型T了吗。

Class类拿到了，就可以使用反射了，可以获取他的方法，也可以创建实例，此处用了newInstance来创建实体

注意：使用newInstance创建实例的类，必须有相应的构造方法，此处用的是无参构造方法。

这样，第一个问题，就解决了。

第2个问题，为了让某些类都拥有一个方法，在Java中，你肯定也用过，而且一直在用，那就是继承。

在Java的泛型中，也可以用继承，再次感谢这个伟大的创举。

就像你自定义了BaseAdapter，你要实现多个方法，比如getView方法。

那我们，也要定义一个带有initByJson的类

abstract public class NetBaseBean {    /**     * 子类实现这个方法，在其中解析json     *     * @param jsonObject 将要解析的JsonObject     * @throws JSONException     */    abstract public void initByJson(JSONObject jsonObject) throws JSONException;}

定义成抽象类，子类继承时必须实现这个方法。因此我们的NetBeanUtil就可以修改为下面这样

public class NetBaseBeanUtil {    public static <T extends NetBaseBean> T parseItem(Class aClass, JSONObject jsonObject) throws JSONException {        T t = getBean(aClass, tIndex);        t.initByJson(jsonObject);        return t;    }        @SuppressWarnings("unchecked")    private static <T extends NetBaseBean> T getBean(Class aClass) {        Class<T> entityClass = (Class<T>) ((ParameterizedType) aClass.getGenericSuperclass()).getActualTypeArguments()[0];        T entity = null;        try {            // 使用newInstance创建实例的类，必须有无参构造方法            entity = entityClass.newInstance();        } catch (InstantiationException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }        return entity;    }}

这样，在外部调用的时候，你传入的泛型Bean，是继承NetBaseBean的就行了。

只是你的Bean要实现initByJson方法，在此方法里面，你可以选择android自带的api来解析，也可以使用gson，或者fastjson来解析。

最后一起来看一下，使用本框架，完成一个网络请求，你将要做哪些内容。

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

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

data里面放着是用户数据，你需要定义一个Bean，他继承NetBaseBean

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

initByJson方法中，我们用的是api里面的类来解析，而没用gson和fastjson等框架，当然你也可以使用。

再来看看使用

NetHelper.get("url", new NetSingleBeanListener<NetUserBean>() {    @Override    protected void onError(CallbackCode errorCode, NetRetBean netRetBean) {        // 这里是ui线程    }    @Override    protected void onSuccess(NetUserBean userBean) {        // 这里是ui线程    }});

可以看到，完成一个网络请求解析，代码省了很多，而且结构性也比较好。

但最为关键的是，如果你有其它的请求，返回的也是单个Bean的，你只需要完成以下两个操作：

1.定义一个Bean继承NetBaseBean

2.在重写的initByJson方法里面对Bean进行解析

你就可以使用NetHelper和NetSingleBeanListener配合着进行网络请求了。

当然，你可能也需要NetListBeanListener，NetCustomBeanListener，NetStringListener。由于篇幅，这些内容将放到后面的章节讲解。

讲到这里，已经把整个框架的流程梳理了一遍，因为不是完整代码实现，所以读者可能会有不明确的地方。但读者可以继续阅读后面的3、4两篇代码实现，第5篇使用框架之后，再回来看看本篇，可能理解起来就更轻松了。

下一篇将讲解公共部分代码实现

Android通用网络请求解析框架.3（代码实现，公共部分）