安卓巴士Android开发者门户 关注
手机版

Rxjava、Retrofit返回json数据解析异常处理

  1. 云栖社区>
  2. 安卓巴士Android开发者门户>
  3. 博客>
  4. 正文

Rxjava、Retrofit返回json数据解析异常处理

技术小能手 2018-07-11 20:26:57 浏览355 评论0

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

每个App都避免不了要进行网络请求,从最开始的用谷歌封装的volley到再到android-async-http再到OKHttpUtils再到现在的Retrofit和RxJava,从我自己用后的体验来看,用了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 对于效率的影响其实并不大,在功能实现的基础上一点点效率的影响(而且这个影响是微乎其微的-.-)其实无伤大雅的。

原文发布时间为:2018-07-11
本文来自云栖社区合作伙伴“安卓巴士Android开发者门户”,了解相关信息可以关注“安卓巴士Android开发者门户”。

用云栖社区APP,舒服~

【云栖快讯】诚邀你用自己的技术能力来用心回答每一个问题,通过回答传承技术知识、经验、心得,问答专家期待你加入!  详情请点击

网友评论

技术小能手
文章5868篇 | 关注1344
关注
为企业和开发者提供稳定、安全、智能的把网站域名或应用资源转换为计算机用于互连的数字 IP地址... 查看详情
数据风控由阿里聚安全提供,是基于阿里大数据计算能力,通过业内领先的风险决策引擎,解决企业账号... 查看详情
自研的分布式数据库,完全兼容MySQL,性能最高提升至MySQL的6倍 查看详情
为您提供简单高效、处理能力可弹性伸缩的计算服务,帮助您快速构建更稳定、安全的应用,提升运维效... 查看详情
阿里云9.10会员日

阿里云9.10会员日