android retrifit2 返回体封装，Gson泛型解析的封装

本文参考：

https://www.jianshu.com/p/4f797b1f8011
https://www.jianshu.com/p/d62c2be60617

需求：

调试接口的时候，接口返回的result字段对应的可能是bean 也可能是list， 而项目里用的是单ApiServer，所以返回Observable， 通过ResponseBody.string()获取返回的内容，不过是String类型的，但是总不能在每个返回的onNext里面都去根据当前返回的参数去解析成对应的bean吧？需要解析成我们想要的bean或list，而一般我们的Observer都会自定义一个传入一个泛型，如下：

public abstract class ResponseObserver<T> implements Observer<ResponseBody> {

    @Override
    public void onNext(ResponseBody responseBody) {
        String str = responseBody.string();
        //这里需要把 str解析为我们想要的T，并通过调用onSuccess(T t)把结果传出去
    }

    public abstract void onSuccess(T t);
}

平时使用Gson来解析json使用如下：

Test  test  = gson.fromJson(json, Test.class);

一般在明确对象类型之后我们确实可以这样做，但是如果是泛型呢

T test  = gson.fromJson(json, T.class);

当然，这样写肯定是不行的，这不符合泛型的思想，而且也没有T.class，所以需要换个方法去写，先看看gson的fromJson方法：

既然第一个方法行不通，则试试后面的方法，emmm…也就第二个了，传Type？Type是何物？，ctrl点击进去看看:

Type的用法，我们在使用Gson解析List的时候会用到，写法：

Type type = new TypeToken<List<Test>>() {}.getType();
List<Test> jsonBean = gson.fromJson(json, type);

当然，封装的时候这么写也不会报错：

Type type = new TypeToken<T>() {}.getType();
JsonBean  jsonBean = gson.fromJson(json, type);

这样如果传的不是泛型，而是一个包含泛型的类（比如公共的返回bean），最后解析出来的T是LinkedTreeMap，比如这样:

Type type = new TypeToken<BaseResponse<T>>() {}.getType();
BaseResponse jsonBean = gson.fromJson(json, type);

BaseResponse代码如下：

public class BaseResponse<E> {
    @SerializedName("code")
    public String code;
    @SerializedName("msg")
    public String message;
    @SerializedName("result")
    public E result;
}

因为一般网络请求的数据结构我们都会这样做BaseResponse，而这样是没法正常解析出我们想要的对象的。所以看顶部参考的两个文章里发现了都是用的是ParameterizedType 来解析（这里就不对ParameterizedType 过多说明，大家可以参考上面的文章）：

新建一个继承ParameterizedType的类：

public class ParameterizedTypeImpl implements ParameterizedType {
    private final Class raw;
    private final Type[] args;
    public ParameterizedTypeImpl(Class raw, Type[] args) {
        this.raw = raw;
        this.args = args != null ? args : new Type[0];
    }
    @Override
    public Type[] getActualTypeArguments() {
        return args;
    }
    @Override
    public Type getRawType() {
        return raw;
    }
    @Override
    public Type getOwnerType() {return null;}
}

然后解析的时候使用

public abstract class ResponseObserver<T> implements Observer<ResponseBody> {

    @Override
    public void onNext(ResponseBody responseBody) {
        String str = responseBody.string();
        Type type = getClass().getGenericSuperclass();
        if(type instanceof ParameterizedType){
                Type[] types = ((ParameterizedType)type).getActualTypeArguments();
                Type ty = new ParameterizedTypeImpl(BaseResponse.class, new Type[]{types[0]});
                BaseResponse<T> data = getGson().fromJson(str, ty);
                onSuccess(data.result);
        }
    }

    public abstract void onSuccess(T t);
}

ok，运行~ 结束！