反序列化列表反对Gson?

我想通过谷歌Gson传输一个列表对象，但我不知道如何反序列化泛型类型。

我在看了这 (BalusC的答案)后尝试了什么:

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

但随后我在Eclipse中得到一个错误，说“新类型List<MyClass>() {}必须实现继承的抽象方法……”;如果我使用一个快速修复，我就会得到一个超过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)

我做 catch JsonParseExceptions并且result不是空的。

我用调试器检查了listType，得到了以下结果:

    <李> list Type
      <李> args = ListOfTypes
      • list = null
      • resolvedTypes = Type[ 1 ]
    • loader = PathClassLoader
    • ownerType0 = null
    • ownerTypeRes = null
    • rawType = Class (java.util.ArrayList)
    • rawTypeName = "java.util.ArrayList"

因此，getClass调用似乎没有正常工作。有什么建议吗?

我已经检查了Gson用户指南。它提到了在将泛型类型解析为Json时应该发生的运行时异常。我做错了。(上面没有显示)，就像在示例中一样，但根本没有得到异常。所以我按照用户指南的建议改变了序列化。不过，这也无济于事。

编辑:

解决了，请看下面我的答案。

401732 次浏览
小开
最佳答案

方法反序列化泛型集合:

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()将编译时类型(在<和>之间)捕获到运行时java.lang.reflect.Type对象中。Class对象只能表示原始(擦除)类型，而Type对象可以表示Java语言中的任何类型，包括泛型类型的参数化实例化。

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

由于类型擦除，TypeToken类只能捕获在编译时完全已知的类型。(也就是说，不能对类型参数T执行new TypeToken<List<T>>() {}.getType()。)

有关更多信息，请参见TypeToken类的文档. xml

小开

因为它回答了我最初的问题，我已经接受了doc_180的答案，但如果有人再次遇到这个问题，我也会回答我问题的后半部分:

我所描述的NullPointerError与列表本身无关，而是与它的内容有关!

“MyClass”类没有“no args”构造函数，它的超类也没有。一旦我向MyClass及其超类添加了一个简单的“MyClass()”构造函数，一切都工作得很好，包括doc_180建议的List序列化和反序列化。

小开

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

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

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

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

恕我直言，这样可读性更强。

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

List<MyClass> mcList = new ArrayList<>(Arrays.asList(mcArray));
小开

参考这篇文章。 Java类型泛型作为GSON的参数 < / p >

我有更好的解决方案。这是list的包装器类，因此包装器可以存储列表的确切类型。

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));
}
小开 
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, "[{...}]");
小开

我想再补充一种可能性。如果你不想使用TypeToken，并想将json对象数组转换为数组列表，那么你可以这样做:

如果你的json结构像这样:

{


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

｝

你的类结构是这样的:

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对象的每个元素了。

小开

我喜欢kay1的答案，但我无法实现它。所以我用他的概念做了我自己的版本。

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);
小开

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);
小开

下面是一个使用动态定义类型的解决方案。诀窍是使用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;
}
小开

在我的情况下，@uncaught_exceptions的答案不起作用，我不得不使用List.class而不是java.lang.reflect.Type:

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

关于Gson的“Type”类理解，请参考示例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());
}
}
小开

对于Kotlin来说很简单:

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

或者，这里有一个有用的函数:

fun <T> typeOfList(): Type {
return object : TypeToken<List<T>>() {}.type
}

然后，使用:

val type = typeOfList<YourMagicObject>()
小开

从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);
小开

我已经为这个例子创建了GsonUtils lib。我将其添加到maven中央存储库中。

Map<String, SimpleStructure> expected = new HashMap<>();
expected.put("foo", new SimpleStructure("peperoni"));


String json = GsonUtils.writeValue(expected);


Map<String, SimpleStructure> actual = GsonUtils.readMap(json, String.class, SimpleStructure.class);
小开

使用Kotlin，你可以为所有定制的可序列化类型获得通用的MutableList类型

private fun <T : Serializable> getGenericList(
sharedPreferences: SharedPreferences,
key: String,
clazz: KClass<T>
): List<T> {
return sharedPreferences.let { prefs ->
val data = prefs.getString(key, null)
val type: Type = TypeToken.getParameterized(MutableList::class.java, clazz.java).type
gson.fromJson(data, type) as MutableList<T>
}
}

你可以调用这个函数

getGenericList.(sharedPrefObj, sharedpref_key, GenericClass::class)

提交答案