Gson解析泛型T的数据

Gson解析泛型T的数据

Gson解析泛型的数据有两种情况，一个是解析泛型对象，一个是解析泛型的List。

1.解析泛型对象

先要自定义一个类实现ParameterizedType这个接口中的方法

public class GsonTypeTokenObjectUtils implements ParameterizedType {


    private final Class raw;
    private final Type[] args;

    public GsonTypeTokenObjectUtils(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类中的一些方法

    /**
     * {
     * code:0
     * data:{}
     * }
     * 返回的json格式是这种的时候，调用此方法
     */
    public LiveData<BaseModel<T>> jsonObjectToModel(Class clazz) {
        return Transformations.switchMap(liveData, json -> {
            MutableLiveData<BaseModel<T>> mutableLiveData = new MutableLiveData<>();

            Type type = getClass().getGenericSuperclass();
            Type[] types = ((ParameterizedType) type).getActualTypeArguments();
            Type ty = new GsonTypeTokenObjectUtils(BaseModel.class, new Type[]{types[0]});
            BaseModel<T> response = new Gson().fromJson(json,
                    ty);

            mutableLiveData.postValue(response);
            return mutableLiveData;
        });
    }

1.解析泛型List

首先也是要自定义一个类去实现ParameterizedType接口

public class GsonTypeTokenListUtils implements ParameterizedType {


    private Class aClass;

    public GsonTypeTokenListUtils(Class aClass){
        this.aClass = aClass;
    }


    @NonNull
    @Override
    public Type[] getActualTypeArguments() {
        return new Type[]{aClass};
    }

    @NonNull
    @Override
    public Type getRawType() {
        return List.class;
    }

    @Nullable
    @Override
    public Type getOwnerType() {
        return null;
    }
}

然后再调用Gson解析的方法

    /**
     * {
     * code:0
     * data:[]
     * 必须取出data数组字符串，单独的解析，不能整体解析
     * }
     * 返回的json格式是这种的时候，调用此方法
     */
    public LiveData<List<T>> jsonArrayToModel(Class clazz) {
        // 解决 java.lang.AssertionError: illegal type variable reference
        // 方法：自定义一个ParameterizedType类，还有注意json只有你要解析的数组字符串，不能有其他
        return Transformations.switchMap(liveData, json -> {
            MutableLiveData<List<T>> mutableLiveData = new MutableLiveData<>();
            try {
                JSONObject jsonObject = new JSONObject(json);
                JSONArray jsonArray = jsonObject.getJSONArray("data");
                List<T> response = parseString2List(jsonArray.toString(), clazz);
                mutableLiveData.postValue(response);

            } catch (JSONException e) {
                e.printStackTrace();
            }

            return mutableLiveData;
        });
    }


    private <T> List<T> parseString2List(String json, Class clazz) {
        Type type = new GsonTypeTokenListUtils(clazz);
        List<T> list = new Gson().fromJson(json, type);
        return list;
    }