使用Gson结合泛型解析数据

使用Gson结合泛型解析数据时，用到了这么一个方法 parameterizedType.getActualTypeArguments()[0]
那么它是什么意思呢？

                            T model = null;
                            try {
                                Gson gson = new Gson();
         //ParameterizedType代表的是一个泛型的实例
       ParameterizedType parameterizedType = (ParameterizedType) requestCallBack.getClass().getGenericInterfaces();//得到范型化参数
                                Type type = parameterizedType.getActualTypeArguments()[0];//获得超类的泛型参数的实际类型
                                model = gson.fromJson(result, type);
                                requestCallBack.onSuccess(result, model);
                            } catch (JsonSyntaxException e) {
                                requestCallBack.OnFailure(e);
                            }

getClass().getGenericSuperclass()返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type，然后将其转ParameterizedType。
getActualTypeArguments()返回表示此类型实际类型参数的 Type 对象的数组。
[0]就是这个数组中第一个了，简而言之就是获得超类的泛型参数的实际类型。
本例中即为获得T的type。

public class Test {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();

        Person person = new Person();
        person.setId(1);
        person.setName("1");

        Person person1 = new Person();
        person.setId(3);
        person.setName("w");

        Person person2 = new Person();
        person.setId(4);
        person.setName("4");

        list.add(person);
        list.add(person1);
        list.add(person2);

        String s = new Gson().toJson(list);
        System.out.println(s);
        doPost(new IBaseCallBack<List<Person>>() {
            @Override
            public void onSuccess(List<Person> data) {

            }

            @Override
            public void onFail(String error) {

            }
        }, s);
    }


    public static <T> void doPost(IBaseCallBack<T> callBack, String json) {
        //IBaseCallBack<List<Person>>
        Type[] types = callBack.getClass().getGenericInterfaces();//得到范型化参数
        ParameterizedType parameterizedType = (ParameterizedType) types[0]; // 得到范型化参数的实体
//       String callType = parameterizedType.getRawType().toString();
        ParameterizedType callBackParamterize = (ParameterizedType) parameterizedType.getActualTypeArguments()[0];//得到具体bean类
    }

    /**
     * @param json json字符串
     * @param type
     * @param <T>
     * @return
     * @throws Exception
     */
    public static <T> T convert(String json, Type type) throws Exception {

/**
 * 1. 将type强转为ParameterizedType范型参数的实体
 * 2.  getRawType()返回<>之外 判断是否为list
 * 3. 得到该实体的具体对象
 * 4.对象实例化
 * 5.通过创建空的JSONObject将得到的JSONArray的数据依次遍历
 * 6.通过json的key值得到value
 * 7。
 */
        //List<T>
        if (type instanceof ParameterizedType) {

            Class aClass = (Class) ((ParameterizedType) type).getRawType();


            if (aClass == List.class) {
                ArrayList list = new ArrayList();

                Class personClass = (Class) ((ParameterizedType) type).getActualTypeArguments()[0];

                JSONArray jsonArray = new JSONArray(json);
                JSONObject object;
                for (int i = 0; i < jsonArray.length(); i++) {

                    Object person = personClass.newInstance();

                    object = jsonArray.getJSONObject(i);

                    Iterator<String> keys = object.keys();


                    String key;
                    while (keys.hasNext()) {
                        key = keys.next(); //id
//得到对象
                        Field field = personClass.getDeclaredField(key);
//可以访问到该类中的私有（private）成员变量
                        field.setAccessible(true);
//        给该对象赋值
                        field.set(person, object.get(key));
//完成一个对象的取值
                    }
//                    将赋值后的对象存入集合
                    list.add(person);
                }
//返回该集合
                return (T) list;

            }

        }

        return null;
    }

}