Gson解析泛型

  1. 云栖社区>
  2. 博客>
  3. 正文

Gson解析泛型

kylinarm 2018-07-27 19:00:00 浏览441
展开阅读全文

做网络请求的时候肯定要封装回调,我这里就传了泛型,但是出了个问题是Gson没办法直接解析泛型,如果直接解析的话,不会得到一个javabean而是得到一个LinkedTreeMap。
然后我去网上找了很就,都没有直接能把LinkedTreeMap转成javabean的方法,但是我们不可能给每个请求的结果都单独去写一个解析,这时候我们就不得不去正面一个问题:如何使用Gson来解析泛型
而我这篇文章都会去围绕这个问题去讲,表面上讲gson,实际上是讲java的type

因为是分2天写的,前面有点乱,可以直接看总结

一.使用Gson来解析JSON

我们先看看平时如何使用Gson来解析json,就假设有个Test类吧。

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

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

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

肯定不能这样玩,这不符合泛型的思想,而且也没有T.class,所以需要换种方法来做


img_253ec41b3c0a049f3560982d4ade8675.png

这个方法的第二个参数是传一个Type,我们可以来看看什么是Type


img_d5bb6edf0682f5f3978f17e927e5444d.png

都知道能理解成是一个类型的接口,但是从include这句话可以更加清楚的知道他是一个什么意思。

二.获取Type

一般你可以很容易的找到这样做

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

然后你觉得如果解析泛型的话可以这样

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

这个我没试过,但是我知道如果传的不是泛型,而是一个包含泛型的类,最后解析出来的还是LinkedTreeMap,比如这样

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

因为一般网络请求的数据结构我们都会这样做Result<T>,而这样是没法正常解析出我们想要的对象的。

这个时候网上就有一篇文章写得特别好
https://www.jianshu.com/p/d62c2be60617
可以看到需要重写一个类继承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;}
}

然后按照他的写法

Type type = new ParameterizedTypeImpl(Result.class, new Class[]{clazz});

那么假如我写一个解析类,我要怎么去获取到type,我就假如我自己写的okhttp的回调

public abstract class HttpCallback<T> implements Callback {
        ........
}

我要怎么在内部根据泛型来获取到Type对象,然后再根据type解析出javabean,还是假如我们的泛型从外面传进来的是Test

其实网上有很多代码,我可以一步一步调试分析出对象是什么

Type type = getClass().getGenericSuperclass();

这个方法也可以获取到Type对象,getClass()是Object类的方法,得到当前类的Class对象,这个很容易懂吧,getGenericSuperclass()是Class类的方法,得到这个Class类对象的Type对象,我们可以调试发现这里的getClass().getGenericSuperclass()为HttpCallback<Test>

拿到这个对象之后发现发现别人都是这样写的

 Type[] types = ((ParameterizedType)type).getActualTypeArguments();

这里用到了一个ParameterizedType去强转对象,ParameterizedType中其实一共有是三个方法
(1)getActualTypeArguments()
(2)getOwnerType()
(3)getRawType()
我们来分别看看他们得到的结果
可以看到getActualTypeArguments得到的一个数组当前只有一个元素types[0] = Test。
getOwnerType()得到null。
getRawType()得到HttpCallback

从这里我们就可以知道,我们需要使用的是getActualTypeArguments()方法来获取我们要的Type
现在再来想想,我们需要的Type是用泛型转成的Result<Test>
getActualTypeArguments获得Test,getRawType()获得外层的类型,那把他们拼起来

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;}
}

就能获取到raw<args[0]>的type,那我们要获取Result<Test>,raw就是Result.class,<Test>可以根据((ParameterizedType)type).getActualTypeArguments()来获取。那我们可以这样写

Class<T> tClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0]; // 根据当前类获取泛型的Type
Type ty = new ParameterizedTypeImpl(BaseResponse.class, new Class[]{tClass}); // 传泛型的Type和我们想要的外层类的Type来组装我们想要的类型
JsonBean jsonBean = gson.fromJson(json, ty);

这样就能正常的解析到我们想要的javabean,注意,这个过程中最主要的是一个组装的思想,用到ParameterizedType 。那有的人问,为什么不可以直接用ParameterizedType 来操作,我们可以看看ParameterizedType 。

img_0e2178c7f18fd0a6eccdad8c468f4c14.png

可以看到它是一个接口,继承Type


img_c5fb06371d7f2923045b411e76f0085b.png

为什么要说这个,因为我感觉这个和他Type的一个思想有些关系,要理解别人是怎么去定义这个东西是什么,我们应该怎么去把这个东西说出来。先看getActualTypeArguments的注释
Returns an array of {@code Type} objects representing the actual type arguments to this type.
这里有个actual表示真实的,我们获取到的type[]数组内部的元素就是actual,那有必要看看什么是actual,现在我只定义了一个泛型,type[]数组也就只有一个actual,这个actual会得到传进来的泛型的类型,那假如我没有定义泛型和定义两个泛型呢?
(1)没有定义泛型的情况
如果没有泛型的话,getClass().getGenericSuperclass()会得到HttpCallBack,((ParameterizedType)type).getActualTypeArguments()会报类型转换错误: java.lang.ClassCastException: java.lang.Class cannot be cast to java.lang.reflect.ParameterizedType
(2)两个泛型的情况
getClass().getGenericSuperclass()会得到HttpCallBack<String,String>,我外面传的是两个String。
((ParameterizedType)type).getActualTypeArguments()得到的数组有两个元素


img_3fb158b5faa921352ba69d05a05e0f07.png

(3)当类不是抽象类的时候
上面的方法都是我在定义的类是抽象类的时候才能起作用,比如我两个参数的类
img_5391a6d6cdfc8d53054928abd3d5bc67.png

那么不是抽象类的时候,getClass().getGenericSuperclass()不管你传多少个参数都会得到Object
((ParameterizedType)type).getActualTypeArguments()自然也会报参数错误

那么如果是List数组的话呢?我们传入的泛型如果是List<T>的话

 Type type = getClass().getGenericSuperclass();

得到HttpCallback<List<Test>>

Type[] types = ((ParameterizedType)type).getActualTypeArguments();

types[0]得到的是List<Test>
这样就能把types[0]和我们想要的对象Result传到自定义的ParameterizedType中组装。
可以看出我们就不需要像之前一样获取Class<T>对象,因为这个对象没法装List,直接获取到Type[] types就行。

三.总结

1.gson解析泛型的方法
Type type = getClass().getGenericSuperclass();
Type[] types = ((ParameterizedType)type).getActualTypeArguments();
Type ty = new ParameterizedTypeImpl(Result.class, new Type[]{types[0]});
Result<T> data = gson.fromJson(josndata, ty);
2.解析时的限制

(1)type不能转成ParameterizedType的情况
上面说了没定义泛型的时候type转成ParameterizedType会报类型转换错误,所以要加个判断

Type type = getClass().getGenericSuperclass();
if(type instanceof ParameterizedType){
    Type[] types = ((ParameterizedType)type).getActualTypeArguments();
    Type ty = new ParameterizedTypeImpl(Result.class, new Type[]{types[0]});
    Result<T> data = gson.fromJson(josndata, ty);
}

(2)当前类不为抽象类的话type会得到Object,虽然我们用上面的判断能防止报错,但是这样也无法正常解析出数据,所以我们这个解析泛型的类必须是抽象类。至于为什么只有抽象类才能正常解析出而一般的类的type都拿到是Object,这点我就不是很清楚了。

3.Type[]数组

Type[]数组types中的数量是泛型的数量,比如传的泛型是<String,Test>,那这个数组就有两个值
types[0] = String
types[1] = Test

4.传的泛型是一个数组
public abstract class HttpCallBack<T> {

    public HttpCallBack(){
        init();
    }

    private void init(){
        Type type = getClass().getGenericSuperclass();
        Type[] types = ((ParameterizedType)type).getActualTypeArguments();
    }

}
 new HttpCallBack<List<String>>(){

        };

直接贴结果


img_568a6ec3f2d9184ce38b41b351729ea9.png
5.自定义一个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;}
}

Type ty = new ParameterizedTypeImpl(Result.class, new Type[]{types[0]});

拿到type之后调gson就行了

网友评论

登录后评论
0/500
评论
kylinarm
+ 关注