首页 文章

Google Gson - 反序列化列表<class>对象? (通用型)

提问于
浏览
357

我想通过Google Gson传输列表对象,但我不知道如何反序列化泛型类型 .

看完_735069后我试过了什么(BalusC的回答):

MyClass mc = new Gson().fromJson(result, new List<MyClass>(){}.getClass());

但是我在eclipse中得到一个错误,说“类型新List(){}必须实现继承的抽象方法......”如果我使用快速修复,我会得到一个超过20个方法存根的怪物 .

我很确定有一个更简单的解决方案,但我似乎无法找到它!

编辑:

我现在有

Type listType = new TypeToken<List<MyClass>>()
                {
                }.getType();

MyClass mc = new Gson().fromJson(result, listType);

但是,我在“fromJson”行中得到以下异常:

java.lang.NullPointerException
at org.apache.harmony.luni.lang.reflect.ListOfTypes.length(ListOfTypes.java:47)
at org.apache.harmony.luni.lang.reflect.ImplForType.toString(ImplForType.java:83)
at java.lang.StringBuilder.append(StringBuilder.java:203)
at com.google.gson.JsonDeserializerExceptionWrapper.deserialize(JsonDeserializerExceptionWrapper.java:56)
at com.google.gson.JsonDeserializationVisitor.invokeCustomDeserializer(JsonDeserializationVisitor.java:88)
at com.google.gson.JsonDeserializationVisitor.visitUsingCustomHandler(JsonDeserializationVisitor.java:76)
at com.google.gson.ObjectNavigator.accept(ObjectNavigator.java:106)
at com.google.gson.JsonDeserializationContextDefault.fromJsonArray(JsonDeserializationContextDefault.java:64)
at com.google.gson.JsonDeserializationContextDefault.deserialize(JsonDeserializationContextDefault.java:49)
at com.google.gson.Gson.fromJson(Gson.java:568)
at com.google.gson.Gson.fromJson(Gson.java:515)
at com.google.gson.Gson.fromJson(Gson.java:484)
at com.google.gson.Gson.fromJson(Gson.java:434)

我捕获JsonParseExceptions并且"result"不为null .

我用调试器检查了listType,得到了以下内容:

  • list类型

  • args = ListOfTypes

  • list = null

  • resolvedTypess =类型[1]

  • loader = PathClassLoader

  • ownerType0 = null

  • ownerTypeRes = null

  • rawType = Class(java.util.ArrayList)

  • rawTypeName = "java.util.ArrayList"

所以似乎“getClass”调用无法正常工作 . 有什么建议...?

编辑2:我查了Gson User Guide . 它提到了在将泛型类型解析为Json时应该发生的运行时异常 . 我做了"wrong"(上面没有显示),就像在例子中一样,但是没有帮助 .

编辑3:解决了,请参阅下面的答案 .

13 回答

  • 805

    请参阅这篇文章 . Java Type Generic as Argument for GSON

    我有更好的解决方案 . 这是列表的包装类,因此包装器可以存储精确类型的列表 .

    public class ListOfJson<T> implements ParameterizedType
    {
      private Class<?> wrapped;
    
      public ListOfJson(Class<T> wrapper)
      {
        this.wrapped = wrapper;
      }
    
      @Override
      public Type[] getActualTypeArguments()
      {
          return new Type[] { wrapped };
      }
    
      @Override
      public Type getRawType()
      {
        return List.class;
      }
    
      @Override
      public Type getOwnerType()
      {
        return null;
      }
    }
    

    然后,代码可以很简单:

    public static <T> List<T> toList(String json, Class<T> typeClass)
    {
        return sGson.fromJson(json, new ListOfJson<T>(typeClass));
    }
    
  • 26

    反序列化泛型集合的方法:

    import java.lang.reflect.Type;
    import com.google.gson.reflect.TypeToken;
    
    ...
    
    Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
    List<YourClass> yourClassList = new Gson().fromJson(jsonArray, listType);
    

    由于评论中有几个人提到过,这里是对 TypeToken 类如何使用的解释 . 构造 new TypeToken<...>() {}.getType() 将编译时类型(在 < 和_735082之间)捕获到运行时 java.lang.reflect.Type 对象中 . 与 Class 对象不同,它只能表示原始(擦除)类型, Type 对象可以表示Java语言中的任何类型,包括泛型类型的参数化实例化 .

    TypeToken 类本身没有公共构造函数,因为您不应该直接构造它 . 相反,您始终构造一个匿名子类(因此 {} ,这是此表达式的必要部分) .

    由于类型擦除, TypeToken 类只能捕获在编译时完全已知的类型 . (也就是说,你不能为类型参数 Tnew TypeToken<List<T>>() {}.getType() . )

    有关更多信息,请参阅documentation for the TypeToken class .

  • 7

    另一种方法是使用数组作为类型,例如:

    MyClass[] mcArray = gson.fromJson(jsonString, MyClass[].class);
    

    这样你可以避免使用Type对象的所有麻烦,如果你真的需要一个列表,你总是可以通过以下方式将数组转换为列表:

    List<MyClass> mcList = Arrays.asList(mcArray);
    

    恕我直言,这更具可读性 .

    并使其成为一个实际列表(可以修改,请参阅 Arrays.asList() 的限制),然后执行以下操作:

    List<MyClass> mcList = new ArrayList<>(Arrays.asList(mcArray));
    
  • 3

    Wep,另一种实现相同结果的方法 . 我们使用它是为了它的可读性 .

    而不是做这个难以阅读的句子:

    Type listType = new TypeToken<ArrayList<YourClass>>(){}.getType();
    List<YourClass> list = new Gson().fromJson(jsonArray, listType);
    

    创建一个扩展对象List的空类:

    public class YourClassList extends ArrayList<YourClass> {}
    

    并在解析JSON时使用它:

    List<YourClass> list = new Gson().fromJson(jsonArray, YourClassList.class);
    
  • 0
    public static final <T> List<T> getList(final Class<T[]> clazz, final String json)
    {
        final T[] jsonToObject = new Gson().fromJson(json, clazz);
    
        return Arrays.asList(jsonToObject);
    }
    

    例:

    getList(MyClass[].class, "[{...}]");
    
  • 19

    当它回答我原来的问题时,我接受了doc_180的答案,但如果有人再遇到这个问题,我也会回答我问题的下半部分:

    我描述的NullPointerError与List本身无关,但与其内容有关!

    “MyClass”类没有“no args”构造函数,也没有超类1 . 一旦我向MyClass及其超类添加了一个简单的“MyClass()”构造函数,一切正常,包括doc_180建议的List序列化和反序列化 .

  • 235

    Gson 2.8 开始,我们可以创建像util这样的函数

    public <T> List<T> getList(String jsonArray, Class<T> clazz) {
        Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
        return new Gson().fromJson(jsonArray, typeOfT);
    }
    

    使用示例

    String jsonArray = ...
    List<User> user = getList(jsonArray, User.class);
    
  • 0

    这是一个适用于动态定义类型的解决方案 . 诀窍是使用Array.newInstance()创建正确类型的数组 .

    public static <T> List<T> fromJsonList(String json, Class<T> clazz) {
        Object [] array = (Object[])java.lang.reflect.Array.newInstance(clazz, 0);
        array = gson.fromJson(json, array.getClass());
        List<T> list = new ArrayList<T>();
        for (int i=0 ; i<array.length ; i++)
            list.add(clazz.cast(array[i]));
        return list; 
    }
    
  • 2

    对于Kotlin来说:

    import java.lang.reflect.Type
    import com.google.gson.reflect.TypeToken
    ...
    val type = object : TypeToken<ArrayList<T>>() {}.type
    

    或者,这是一个有用的功能:

    fun <T> buildType(): Type {
        return object : TypeToken<ArrayList<T>>() {}.type
    }
    

    然后,使用:

    val type = buildType<YourMagicObject>()
    
  • 1

    我想补充一点可能性 . 如果您不想使用TypeToken并希望将json objects数组转换为ArrayList,那么您可以这样继续:

    如果您的json结构如下:

    {
    
    "results": [
        {
            "a": 100,
            "b": "value1",
            "c": true
        },
        {
            "a": 200,
            "b": "value2",
            "c": false
        },
        {
            "a": 300,
            "b": "value3",
            "c": true
        }
    ]
    

    }

    你的 class 结构如下:

    public class ClassName implements Parcelable {
    
        public ArrayList<InnerClassName> results = new ArrayList<InnerClassName>();
        public static class InnerClassName {
            int a;
            String b;
            boolean c;      
        }
    }
    

    然后你可以解析它:

    Gson gson = new Gson();
    final ClassName className = gson.fromJson(data, ClassName.class);
    int currentTotal = className.results.size();
    

    现在您可以访问className对象的每个元素 .

  • 5

    有关Gson的“类型”类理解,请参阅示例2 .

    示例1:在此deserilizeResturant中,我们使用Employee []数组并获取详细信息

    public static void deserializeResturant(){
    
           String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
           Gson gson = new Gson();
           Employee[] emp = gson.fromJson(empList, Employee[].class);
           int numberOfElementInJson = emp.length();
           System.out.println("Total JSON Elements" + numberOfElementInJson);
           for(Employee e: emp){
               System.out.println(e.getName());
               System.out.println(e.getEmpId());
           }
       }
    

    例2:

    //Above deserilizeResturant used Employee[] array but what if we need to use List<Employee>
    public static void deserializeResturantUsingList(){
    
        String empList ="[{\"name\":\"Ram\",\"empId\":1},{\"name\":\"Surya\",\"empId\":2},{\"name\":\"Prasants\",\"empId\":3}]";
        Gson gson = new Gson();
    
        // Additionally we need to se the Type then only it accepts List<Employee> which we sent here empTypeList
        Type empTypeList = new TypeToken<ArrayList<Employee>>(){}.getType();
    
    
        List<Employee> emp = gson.fromJson(empList, empTypeList);
        int numberOfElementInJson = emp.size();
        System.out.println("Total JSON Elements" + numberOfElementInJson);
        for(Employee e: emp){
            System.out.println(e.getName());
            System.out.println(e.getEmpId());
        }
    }
    
  • 6

    我喜欢kays1的答案,但我无法实现它 . 所以我使用他的概念构建了自己的版本 .

    public class JsonListHelper{
        public static final <T> List<T> getList(String json) throws Exception {
            Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
            Type typeOfList = new TypeToken<List<T>>(){}.getType();
            return gson.fromJson(json, typeOfList);
        }
    }
    

    用法:

    List<MyClass> MyList= JsonListHelper.getList(jsonArrayString);
    
  • 4

    在我的情况下@uncaught_exceptions 's answer didn'工作,我不得不使用 List.class 而不是 java.lang.reflect.Type

    String jsonDuplicatedItems = request.getSession().getAttribute("jsonDuplicatedItems").toString();
    List<Map.Entry<Product, Integer>> entries = gson.fromJson(jsonDuplicatedItems, List.class);
    

相关问题