Retrofit自定义Converter数据异常处理攻略

开发中客户端时常与服务端打交道，客户端请求参数到服务端，服务端返回响应数据到客户端，开发中用的比较多的就是Json数据传递，从请求到响应的步骤一般是约定数据格式，响应数据进行关系映射，然后对错误数据进行异常处理。

数据格式

一个比较良好的的响应数据应该具备响应码、数据状态描述、具体的响应数据

{
"message": "正常",
"responsecode": 0,
"results": {
"list": [
{
"desc": "HorizontalPicker view 支持文本和icon",
"id": "58b7c6da421aa90f131785f0",
"type": "Android",
"who": "Jason"
},
{
"desc": "VirtualLayout是一个针对RecyclerView的LayoutManager扩展",
"id": "58bb931a421aa90efc4fb65b",
"type": "Android",
"who": "Jason"
}
],
"total": 2
}
}

responsecode

responsecode为服务器自定义的响应码

<table>
<tr>
<td>0</td>
<td>成功</td>
</tr>
<tr>
<td>1</td>
<td>该用户不存在</td>
</tr>
<tr>
<td>2</td>
<td>充值失败</td>
</tr>
<tr>
<td>3</td>
<td>非法请求</td>
</tr>
<tr>
<td>4</td>
<td>服务器繁忙</td>
</tr>
</table>

message

服务端返回数据的状态描述，客户端可以根据需要对操作信息进行显示，当然客户端也可以自定义状态的描述。

results

服务器返回的具体数据，客户端需要对响应数据进行实体类的映射

返回数据映射成实体类

一般来讲，客户端与服务端之间的数据通信大部分是以Json格式进行，我们根据服务端返回的数据来抽象出我们的实体类

public class HttpResult<T> {
    private int responsecode;
    private String message;
    private T results;
    public int getResponsecode() {
        return responsecode;
    }
    public void setResponsecode(int responsecode) {
        this.responsecode = responsecode;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public T getResults() {
        return results;
    }
    public void setResults(T results) {
        this.results = results;
    }
}

HttpResult类为所有数据模型的基类，使用泛型results可以保证接收不同的实体模型。

下面定义具体数据的实体模型：

public class ArticleList {
    private int total;
    private List<Article> list;
    public int getTotal() {
        return total;
    }
    public void setTotal(int total) {
        this.total = total;
    }
    public List<Article> getList() {
        return list;
    }
    public void setList(List<Article> list) {
        this.list = list;
    }
}

public class Article {
    private String id;
    private String type;
    private String who;
    private String desc;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public String getWho() {
        return who;
    }
    public void setWho(String who) {
        this.who = who;
    }
    public String getDesc() {
        return desc;
    }
    public void setDesc(String desc) {
        this.desc = desc;
    }
}

映射实体类定义完毕之后，我们使用retrofit定义数据请求接口：

@POST("android/article/list")
Call<HttpResult<ArticleList>> getArticleList(@Body ArticlePost post);

上述接口参数ArticlePost为自定义请求类，里面包含两个字段page（请求页数）和rowcount（请求行数）

要想让我们的实体类与Json之间可以自动转换，我们还需要为retrofit配置converter：

  Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(ClientFactory.getInstance().getOkHttpClient()
                .addConverterFactory(GsonConverterFactory.create());
  return builder.build().create(clazz);

添加gson转换器之后，我们的请求实体类可以转换为json数据，响应数据可以自动转换为实体类。

接下来再看一下具体的调用

ApiFactory.getArticleApi().getArticleList(articlePost).enqueue(new Callback<HttpResult<ArticleList>>() {
            @Override
            public void onResponse(Call<HttpResult<ArticleList>> call, Response<HttpResult<ArticleList>> response) {
                HttpResult<ArticleList> body = response.body();
                int code = body.getResponsecode();
                if (code == 0) {
                    //正常响应
                } else {//响应异常
                    switch (code) {
                        case 1:
                            break;
                        case 2:
                            break;
                        case 3:
                            break;
                        case 4:
                            break;
                                  }
                      }
            }
            @Override
            public void onFailure(Call<HttpResult<ArticleList>> call, Throwable t) {

            }
        });

引入RxJava的使用

retrofit框架支持对RxJava的引入，引入RxJava之后可以让我们更好的进行线程控制以及数据处理。

RxJava的引入

想要使用RxJava，在gradle文件中添加依赖即可：

compile 'io.reactivex:rxjava:1.1.0'
compile 'io.reactivex:rxandroid:1.1.0'

另外还需要引入RxJava适配器的依赖：

compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
然后在retrofit中添加适配器：

 Retrofit.Builder builder = new Retrofit.Builder()
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                return builder.build().create(clazz);

引入之后，我们就可以把之前接口的返回定义为Observable接口：如下：

@POST("android/article/list")
Observable<HttpResult<ArticleList>> getArticleList(@Body ArticlePost post);

引入RxJava之后数据接口的使用

ApiFactory.getArticleApi().getArticleList(articlePost)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<HttpResult<ArticleList>>() {
                    @Override
                    public void onNext(HttpResult<ArticleList> result) {
                        int code = body.getResponsecode();
                        if (code == 0) {
                            //正常响应
                            ArticleList list=result.getResults;
                        } else {//响应异常
                            switch (code) {
                                case 1:
                                    break;
                                case 2:
                                    break;
                                case 3:
                                    break;
                                case 4:
                                    break;
                                          }
                              }
                    }
                    @Override
                    public void onError(Throwable e) {
                       
                    }
                
                    @Override
                    public void onCompleted() {
                
                    }
                });

这样我们就初步的把异常处理完了，一般来讲我们想在onNext回调中只处理正常的业务逻辑，而现在错误的业务逻辑也包含在了onNext中，这并不是我们想要的，我们的目的是在onError中处理错误逻辑。

如果返回的数据转换为实体类的时候发现是错误的响应码直接能够抛出异常，并让onError直接去捕获异常就能够达到我们的预期，说到实体类的转换我们很自然的就想到了之前添加GsonConverter，我们来看一下GsonConverterFactory的源码实现：

public final class GsonConverterFactory extends Converter.Factory {
  public static GsonConverterFactory create() {
    return create(new Gson());
  }

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

  private final Gson gson;

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

  @Override
  public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
      Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonResponseBodyConverter<>(adapter);
  }

  @Override
  public Converter<?, RequestBody> requestBodyConverter(Type type,
      Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
    TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
    return new GsonRequestBodyConverter<>(gson, adapter);
  }
}

其中有两个方法：responseBodyConverter跟requestBodyConverter，其功能就是创建响应体跟请求体转换器。
我们再分别追踪一下GsonResponseBodyConverter跟GsonRequestBodyConverter的源码：

GsonResponseBodyConverter.java

final class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
  private final TypeAdapter<T> adapter;

  GsonResponseBodyConverter(TypeAdapter<T> adapter) {
    this.adapter = adapter;
  }

  @Override public T convert(ResponseBody value) throws IOException {
    try {
      return adapter.fromJson(value.charStream());
    } finally {
      value.close();
    }
  }
}

实现比较简单，convert方法完成了Json数据到实体类的映射。

GsonRequestBodyConverter.java

final class GsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
  private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
  private static final Charset UTF_8 = Charset.forName("UTF-8");

  private final Gson gson;
  private final TypeAdapter<T> adapter;

  GsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
    this.gson = gson;
    this.adapter = adapter;
  }

  @Override public RequestBody convert(T value) throws IOException {
    Buffer buffer = new Buffer();
    Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
    JsonWriter jsonWriter = gson.newJsonWriter(writer);
    adapter.write(jsonWriter, value);
    jsonWriter.close();
    return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
  }
}

convert方法完成了实体类到Json数据的转换

使用自定义Converter配合RxJava进行异常的统一处理

我们根据源码提供的转换器来创建自己的Converter，然后在响应转换时根据响应码去抛出异常让onError去捕获。
首先我们来创建自己的响应体转换器。

public class CheckGsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {
    private final TypeAdapter<T> adapter;
    private final Gson mGson;
    private static final Charset UTF_8 = Charset.forName("UTF-8");

    CheckGsonResponseBodyConverter(TypeAdapter<T> adapter) {
        this.mGson = new Gson();
        this.adapter = adapter;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {
        String response = value.string();
        HttpResult result = mGson.fromJson(response, HttpResult.class);
        int responseCode = result.getResponsecode();
        //如果响应码不为正常响应我们就抛出一个自定义的异常，onError方法回去捕获这个异常
        if (!responseCode == 0) {
            value.close();
            throw new ApiException(responseCode, ApiError.getErrorMessage(responseCode));
        }
        MediaType type=value.contentType();
        Charset charset=type!=null?type.charset(UTF_8):UTF_8;
        InputStream is = new ByteArrayInputStream(response.getBytes());
        InputStreamReader reader = new InputStreamReader(is,charset);
        JsonReader jsonReader = mGson.newJsonReader(reader);
        try {
            return adapter.read(jsonReader);
        } finally {
            value.close();
        }
    }
}

接着我们创建自己的请求体转换器：

public class CheckGsonRequestBodyConverter<T> implements Converter<T, RequestBody> {
    private static final MediaType MEDIA_TYPE = MediaType.parse("application/json; charset=UTF-8");
    private static final Charset UTF_8 = Charset.forName("UTF-8");

    private final Gson gson;
    private final TypeAdapter<T> adapter;

    CheckGsonRequestBodyConverter(Gson gson, TypeAdapter<T> adapter) {
        this.gson = gson;
        this.adapter = adapter;
    }

    @Override
    public RequestBody convert(T value) throws IOException {
        Buffer buffer = new Buffer();
        Writer writer = new OutputStreamWriter(buffer.outputStream(), UTF_8);
        JsonWriter jsonWriter = gson.newJsonWriter(writer);
        adapter.write(jsonWriter, value);
        jsonWriter.close();
        return RequestBody.create(MEDIA_TYPE, buffer.readByteString());
    }
}

最后我们还需要创建一个转换器工厂：

public class CheckGsonConverterFactory extends Converter.Factory {

    public static CheckGsonConverterFactory create() {
        return create(new Gson());
    }


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

    private final Gson gson;

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

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations,
                                                            Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        //返回自定义的响应体转换器
        return new CheckGsonResponseBodyConverter<>(adapter);
    }

    @Override
    public Converter<?, RequestBody> requestBodyConverter(Type type,
                                                          Annotation[] parameterAnnotations, Annotation[] methodAnnotations, Retrofit retrofit) {
        TypeAdapter<?> adapter = gson.getAdapter(TypeToken.get(type));
        //返回自定义的请求转换器
        return new CheckGsonRequestBodyConverter<>(gson, adapter);
    }
}

到现在自定义的Converter已经完成，我们在retrofit中配置一下：

Retrofit.Builder builder = new Retrofit.Builder()
                .baseUrl(baseUrl)
                .client(ClientFactory.getInstance().getOkHttpClient())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(CheckGsonConverterFactory.create());
        return builder.build().create(clazz);

这时我们调用数据接口时代码变为：

ApiFactory.getArticleApi().getArticleList(articlePost)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<HttpResult<ArticleList>>() {
                    @Override
                    public void onNext(HttpResult<ArticleList> result) {
                            //正常响应
                            ArticleList list=result.getResults;
                    }
                    @Override
                    public void onError(Throwable e) {
                        if (e instanceof HttpException || e instanceof IOException)      {
                        //异常处理
                        } else {
                        //处理api异常
                        ApiException apiException=(ApiException)e;
                        handleApiError(context, e);
                        }
                    }
                
                    @Override
                    public void onCompleted() {
                
                    }
                });

这样我们通过自定义Converter的方式将异常响应码的逻辑全部交给了onError去处理，而在onNext中我们只关注正确的逻辑，这时我们就完成了对数据异常的统一处理。

下面附上源码，Demo中暂时没有合适的数据接口可以使用，只看实现思路即可。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 161,601评论 4赞 369
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 68,367评论 1赞 305
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 111,249评论 0赞 254
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 44,539评论 0赞 217
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,967评论 3赞 295
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,929评论 1赞 224
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 32,098评论 2赞 317
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,825评论 0赞 207
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,609评论 1赞 249
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,796评论 2赞 253
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,282评论 1赞 265
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,603评论 3赞 261
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,277评论 3赞 242
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,159评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,959评论 0赞 201
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 36,079评论 2赞 285
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,874评论 2赞 277

推荐阅读更多精彩内容