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

最新推荐文章于 2020-06-18 16:29:12 发布

发发恭子

最新推荐文章于 2020-06-18 16:29:12 发布

阅读量2.6k

点赞数

分类专栏： Android Java 移动开发文章标签： android 网络框架 json 解析

本文链接：https://blog.csdn.net/qq_296216078/article/details/54141180

版权

移动开发同时被 3 个专栏收录

20 篇文章 0 订阅

订阅专栏

Android

19 篇文章 0 订阅

订阅专栏

Java

14 篇文章 0 订阅

订阅专栏

笔者将通过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（同部请求，分支部分）

发发恭子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android通用网络请求解析框架.7（同步请求，公共部分）

笔者将通过10篇博客对个人开源框架进行讲解，本篇为第7篇，讲解同步请求。开源库github地址 https://github.com/qq296216078/Android-Universial-NetFrame如果有兴趣一起讨论本框架的内容，请加QQ群：271335749
复制链接

扫一扫

专栏目录