java 网络请求无返回_Rxjava、Retrofit返回json数据解析异常处理

每个App都避免不了要进行网络请求，从最开始的用谷歌封装的volley到再到android-async-http再到OKHttpUtils再到现在的Retrofit和RxJava,从我自己用后的体验来看，用了retrofit和RxJava真的回不去了，回不去了，不去了，去了，了...(哈哈，本来还想分析下这四个的区别，网上这样的文章很多，我就没必要多添乱了-.-)。不多逼逼，下面开始正文。

1、Rxjava和Retrofit依赖导入：compile 'io.reactivex:rxandroid:1.2.0'                       //Rxjava专门针对anroid封装的RxAndroidcompile 'io.reactivex:rxjava:1.1.5'                          compile 'com.squareup.retrofit2:retrofit:2.0.2'              //retrofitcompile 'com.squareup.retrofit2:converter-gson:2.0.2'        //gson convertercompile 'com.squareup.retrofit2:adapter-rxjava:2.0.2'        //Retrofit专门为Rxjava封装的适配器compile 'com.google.code.gson:gson:2.6.2'                    //Gsoncompile 'com.squareup.okhttp3:logging-interceptor:3.1.2'     //打印网络请求的log日志

2、网络请求基类的配置

建立一个工厂类public class ServiceFactory {    private final Gson mGsonDateFormat;    public ServiceFactory(){

mGsonDateFormat = new GsonBuilder()

.setDateFormat("yyyy-MM-dd hh:mm:ss")

.create();

}    private static class SingletonHolder{        private static final ServiceFactory INSTANCE = new ServiceFactory();

}    public static ServiceFactory getInstance(){        return SingletonHolder.INSTANCE;

}    public  S createService(Class serviceClass){

Retrofit retrofit = new Retrofit.Builder()

.baseUrl(Constant.BASE_URL) //Retrofit2 base url  必须是这种格式的：http://xxx.xxx/

.client(getOkHttpClient())

--------------------------添加Gson工厂变换器也就是不用管数据解析-----------------------------------

.addConverterFactory(GsonConverterFactory.create())

.addCallAdapterFactory(RxJavaCallAdapterFactory.create())

.build();        return retrofit.create(serviceClass);

}

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {        @Override

public void log(String message) {            //打印retrofit日志

Log.i("RetrofitLog","retrofitBack ======================= "+message);

}

});    private static final long DEFAULT_TIMEOUT = 10;    private OkHttpClient getOkHttpClient(){

loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);        //定制OkHttp

OkHttpClient.Builder builder = new OkHttpClient.Builder();

builder.connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

builder.writeTimeout(DEFAULT_TIMEOUT,TimeUnit.SECONDS);

builder.addInterceptor(loggingInterceptor);        //设置缓存

File httpCacheDirectory = new File(SDCardUtils.getRootDirectoryPath(),"这里是你的网络缓存存放的地址");

builder.cache(new Cache(httpCacheDirectory,10*1024*1024));        return builder.build();

}

}

好了 下一步 我们要建一个网络请求的基类，一般网络请求返回的数据最外层的根式就是 code msg result，可变的就是result，所以我们把result的类型定义为一个泛型的public class HttpResult extends BaseEntity {    public int code;    private boolean isSuccess;    private T result;    private String msg;    public void setMsg(String msg) {        this.msg = msg;

}    public T getResult() {        return result;

}    public void setResult(T result) {        this.result = result;

}    public boolean isSuccess() {        return code == 200;

}    public int getCode() {        return code;

}

}

既然我们的网络请求是rxjava配合retrofit 下面就定义我们的网络请求订阅subscriberpublic abstract class HttpResultSubscriber extends Subscriber> {    @Override

public void onNext(HttpResult t) {        if (t.isSuccess()) {

onSuccess(t.getResult());

} else {

_onError(t.getMsg().getCode());

}

}    @Override

public void onCompleted() {

}    @Override

public void onError(Throwable e) {

e.printStackTrace();        //在这里做全局的错误处理

if (e instanceof ConnectException ||

e instanceof SocketTimeoutException ||

e instanceof TimeoutException) {            //网络错误

_onError(-9999);

}

}    public abstract void onSuccess(T t);    public abstract void _onError(int status);

}

OK我们的网络请求基类已经完成啦！下面开始我们的网络请求

首先我们定义一个接口(以登录为例)：public interface LoginService {    //这个例子是post为例，如果想要了解其他的网络请求，请点击文章开始出的retrofit链接

@FormUrlEncoded

@POST(Constant.LOGIN_URL)   这里是你的登录url    //可以看到我们的登录返回的是一个Observable，它里面包含的使我们的网络请求返回的实体基类，

//而我们实体基类的result现在就是UserInfoEntity

Observable> login(@Field("mobile") String phone,                                 @Field("password") String pwd);

}

现在开始我们的网络请求啦public void login(String phone, String pwd) {

ServiceFactory.getInstance()

.createService(LoginService.class)

.login(phone,pwd)

.compose(TransformUtils.>defaultSchedulers())

.subscribe(new HttpResultSubscriber() {                @Override

public void onSuccess(UserInfoEntity userInfoEntity) {                     //这是网络请求陈宫的回调

}                @Override

public void _onError(int status) {                    //这是失败的回调 根据status做具体的操作

}

});

}

你以为这样就行了 ，  这样子确实没毛病，确实已经妥妥的了。可是，可是，事与愿违啊！！！

3、具体解决办法

一般情况这是我们的返回json格式：{    "code":200,        "msg":"成功",        "result":{}

}

我们刚才定义登录接口的时候 返回的实体基类例传入的是UserInfoEntity  这确实是没问题的 可是你们加入登录失败的时候返回的json数据格式是这样的怎么办？

{    "code":300,    "msg":"成功",    "result":[]

}

失败的时候返回的实体又是一个数组，这样子就会抱一个json解析异常拿不多失败的状态码和提示信息

OK其实我们的网络请求已经完成90%了，剩下的就是不重要的失败的时候回调了。

方法一：(这是在后台兄弟好说话，而且不打人的情况下...当然这种好人，还是有的，不过这不是我们今天要讲的重点)

我们可以让后台返回的json数据中的result永远是个数组。{    "code":300,    "msg":"成功",    "result":[]

}

方法二：

首先给大家看一个图片

这就是我们要下手的地方

上面我们添加的工厂变换器是导入的依赖 compile 'com.squareup.retrofit2:converter-gson:2.0.2' 这个提供的，

那可能有人要问了，那我们不用这个用哪个啊，不着急，不着急。还好retrofit是支持自定义的ConverterFactory的

下面我们就开始我们的自定义征程吧。

---------------------------------------------------------华丽丽的分割线-----------------------------------------------

1、自定义Gson响应体变换器public class GsonResponseBodyConverter implements Converter{    private final Gson gson;    private final Type type;    public GsonResponseBodyConverter(Gson gson,Type type){        this.gson = gson;        this.type = type;

}    @Override

public T convert(ResponseBody value) throws IOException {

String response = value.string();        //先将返回的json数据解析到Response中，如果code==200，则解析到我们的实体基类中，否则抛异常

Response httpResult = gson.fromJson(response, Response.class);        if (httpResult.getCode()==200){            //200的时候就直接解析，不可能出现解析异常。因为我们实体基类中传入的泛型，就是数据成功时候的格式

return gson.fromJson(response,type);

}else {

ErrorResponse errorResponse = gson.fromJson(response,ErrorResponse.class);            //抛一个自定义ResultException 传入失败时候的状态码，和信息

throw new ResultException(errorResponse.getCode(),errorResponse.getMsg());

}

}

}

2、自定义一个响应变换工厂 继承自 retrofit的 converter.Factorypublic class ResponseConverterFactory extends Converter.Factory {    public static ResponseConverterFactory create() {        return create(new Gson());

}    public static ResponseConverterFactory create(Gson gson) {        return new ResponseConverterFactory(gson);

}    private final Gson gson;    private ResponseConverterFactory(Gson gson) {        if (gson == null) throw new NullPointerException("gson == null");        this.gson = gson;

}    @Override

public Converter responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {        //返回我们自定义的Gson响应体变换器

return new GsonResponseBodyConverter<>(gson, type);

}    @Override

public Converter, RequestBody> requestBodyConverter(Type type,

Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {        //返回我们自定义的Gson响应体变换器

return new GsonResponseBodyConverter<>(gson,type);

}

}

然后将上面的GsonConverterFactory.create() 替换成我们自定义的ResponseConverterFactory.create()。public  S createService(Class serviceClass){

Retrofit retrofit = new Retrofit.Builder()

.baseUrl(Constant.BASE_URL)

.client(getOkHttpClient())            //.addConverterFactory(GsonConverterFactory.create())

//然后将上面的GsonConverterFactory.create()替换成我们自定义的ResponseConverterFactory.create()

.addConverterFactory(ResponseConverterFactory.create())

.addCallAdapterFactory(RxJavaCallAdapterFactory.create())

.build();    return retrofit.create(serviceClass);

}

再然后，最后一个然后啦(-.-)

在我们的自定义的Rxjava订阅者 subscriber中的onError()中加入我们刚才定义的ResultException。@Overridepublic void onError(Throwable e) {

e.printStackTrace();    //在这里做全局的错误处理

if (e instanceof ConnectException ||

e instanceof SocketTimeoutException ||

e instanceof TimeoutException) {        //网络错误

_onError(-9999);

} else if (e instanceof ResultException) {        //自定义的ResultException

//由于返回200,300返回格式不统一的问题，自定义GsonResponseBodyConverter凡是300的直接抛异常

_onError(((ResultException) e).getErrCode());

System.out.println("---------errorCode------->"+((ResultException) e).getErrCode());

}

}

这次是真的完成了我们的json数据解析异常的处理，其实我们的解决办法是解析了两次，第一次解析的时候我们的Response中只有只是解析了最外层的 code 和 msg  ，result中的是没有解析的。response中的code==200，直接将数据解析到我们的实体基类中。如果code！=200时，直接抛自定义的异常，直接会回调到subscriber中的onError()中。虽然进行了两次解析，但是第一次只是解析了code，和msg 对于效率的影响其实并不大，在功能实现的基础上一点点效率的影响(而且这个影响是微乎其微的-.-)其实无伤大雅的。