RxjavaRetrofit返回json数据解析异常处理

Posted 2020-12-04 Finnz

每个App都避免不了要进行网络请求，从最开始的用谷歌封装的volley到再到android-async-http再到OKHttpUtils再到现在的Retrofit和RxJava,从我自己用后的体验来看，下面开始正文。

1、Rxjava和Retrofit依赖导入：

compile \'io.reactivex:rxandroid:1.2.0\'                       //Rxjava专门针对anroid封装的RxAndroid
compile \'io.reactivex:rxjava:1.1.5\'                          
compile \'com.squareup.retrofit2:retrofit:2.0.2\'              //retrofit
compile \'com.squareup.retrofit2:converter-gson:2.0.2\'        //gson converter
compile \'com.squareup.retrofit2:adapter-rxjava:2.0.2\'        //Retrofit专门为Rxjava封装的适配器
compile \'com.google.code.gson:gson:2.6.2\'                    //Gson
compile \'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> S createService(Class<S> 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<T> 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 下面就定义我们的网络请求订阅subscriber

public abstract class HttpResultSubscriber<T> extends Subscriber<HttpResult<T>> {
    @Override
    public void onNext(HttpResult<T> 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<HttpResult<UserInfoEntity>> 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.<HttpResult<UserInfoEntity>>defaultSchedulers())
            .subscribe(new HttpResultSubscriber<UserInfoEntity>() {
                @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<T> implements Converter<ResponseBody,T>{
    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.Factory

public 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<ResponseBody, ?> 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> S createService(Class<S> 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。

@Override
public 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 对于效率的影响其实并不大，在功能实现的基础上一点点效率的影响（而且这个影响是微乎其微的-.-）其实无伤大雅的。