为什么Gson fromJson抛出一个JsonSyntaxException：预期BEGIN_OBJECT但是BEGIN_ARRAY？ [英] Why does Gson fromJson throw a JsonSyntaxException: Expected BEGIN_OBJECT but was BEGIN_ARRAY?

问题描述

（这篇文章的意思是规范问题，下面提供了一个示例答案。）

(This post is meant to be a canonical question with a sample answer provided below.)

我正在尝试反序列化一些使用 Gson＃fromJson（String，Class） 。

I'm trying to deserialize some JSON content into a custom POJO type with Gson#fromJson(String, Class).

这段代码

import com.google.gson.Gson;

public class Sample {
    public static void main(String[] args) {
        String json = "{\"nestedPojo\":[{\"name\":null, \"value\":42}]}";
        Gson gson = new Gson();
        gson.fromJson(json, Pojo.class);
    }
}

class Pojo {
    NestedPojo nestedPojo;
}

class NestedPojo {
    String name;
    int value;
}

抛出跟随异常

Exception in thread "main" com.google.gson.JsonSyntaxException: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was BEGIN_ARRAY at line 1 column 16 path $.nestedPojo
    at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:200)
    at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$1.read(ReflectiveTypeAdapterFactory.java:103)
    at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:196)
    at com.google.gson.Gson.fromJson(Gson.java:810)
    at com.google.gson.Gson.fromJson(Gson.java:775)
    at com.google.gson.Gson.fromJson(Gson.java:724)
    at com.google.gson.Gson.fromJson(Gson.java:696)
    at com.example.Sample.main(Sample.java:23)
Caused by: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was BEGIN_ARRAY at line 1 column 16 path $.nestedPojo
    at com.google.gson.stream.JsonReader.beginObject(JsonReader.java:387)
    at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:189)
    ... 7 more

为什么可以'Gson是否正确地将我的JSON文本转换为我的POJO类型？

Why can't Gson properly convert my JSON text to my POJO type?

推荐答案

正如异常消息所述

Caused by: java.lang.IllegalStateException: Expected BEGIN_OBJECT but was BEGIN_ARRAY at line 1 column 16 path $.nestedPojo

在反序列化时，Gson期待一个JSON对象，但找到了一个JSON数组。由于它无法从一个转换为另一个，因此抛出了此异常。

while deserializing, Gson was expecting a JSON object, but found a JSON array. Since it couldn't convert from one to the other, it threw this exception.

描述了JSON格式此处。简而言之，它定义了以下类型：对象，数组，字符串，数字， null ，以及布尔值 true 和 false 。

The JSON format is described here. In short, it defines the following types: objects, arrays, strings, numbers, null, and the boolean values true and false.

在Gson（和大多数JSON解析器）中，存在以下映射：JSON字符串映射到Java String ; JSON编号映射到Java Number 类型; JSON数组映射到 Collection 类型或数组类型; JSON对象映射到Java Map 类型，或者通常是自定义的 POJO 类型（之前未提及）; null 映射到Java的 null ，并且布尔值映射到Java的 true 和 false 。

In Gson (and most JSON parsers), the following mappings exist: a JSON string maps to a Java String; a JSON number maps to a Java Number type; a JSON array maps to a Collection type or an array type; a JSON object maps to a Java Map type or, typically, a custom POJO type (not mentioned previously); null maps to Java's null, and the boolean values map to Java's true and false.

Gson迭代您提供的JSON内容并尝试将其反序列化为您要求的相应类型。如果内容不匹配或无法转换为预期类型，则会抛出相应的异常。

Gson iterates through the JSON content that you provide and tries to deserialize it to the corresponding type you've requested. If the content doesn't match or can't be converted to the expected type, it'll throw a corresponding exception.

在您的情况下，您提供了以下JSON

In your case, you provided the following JSON

{
    "nestedPojo": [
        {
            "name": null,
            "value": 42
        }
    ]
}

在根目录下，这是一个JSON对象，其中包含一个名为 nestedPojo 的成员，它是一个JSON数组。该JSON数组包含单个元素，另一个JSON对象包含两个成员。考虑到前面定义的映射，您希望此JSON映射到Java对象，该对象具有名为 nestedcojo 的字段，其中包含 Collection 或数组类型，其中该类型分别定义了两个名为 name 和 value 的字段。

At the root, this is a JSON object which contains a member named nestedPojo which is a JSON array. That JSON array contains a single element, another JSON object with two members. Considering the mappings defined earlier, you'd expect this JSON to map to a Java object which has a field named nestedPojo of some Collection or array type, where that types defines two fields named name and value, respectively.

但是，您已将 Pojo 类型定义为具有字段

However, you've defined your Pojo type as having a field

NestedPojo nestedPojo;

既不是数组类型，也不是 Collection 类型。 Gson无法反序列化此字段的相应JSON。

that is neither an array type, nor a Collection type. Gson can't deserialize the corresponding JSON for this field.

相反，您有3个选项：

• 更改您的JSON以匹配预期类型

• Change your JSON to match the expected type

{
    "nestedPojo": {
        "name": null,
        "value": 42
    }
}

更改 Pojo 类型以期望集合或数组类型

Change your Pojo type to expect a Collection or array type

List<NestedPojo> nestedPojo; // consider changing the name and using @SerializedName
NestedPojo[] nestedPojo;

为 NestedPojo 使用您自己的解析规则。例如

Write and register a custom deserializer for NestedPojo with your own parsing rules. For example

class Custom implements JsonDeserializer<NestedPojo> {
    @Override
    public NestedPojo deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        NestedPojo nestedPojo = new NestedPojo();
        JsonArray jsonArray = json.getAsJsonArray();
        if (jsonArray.size() != 1) {
            throw new IllegalStateException("unexpected json");
        }
        JsonObject jsonObject = jsonArray.get(0).getAsJsonObject(); // get only element
        JsonElement jsonElement = jsonObject.get("name");
        if (!jsonElement.isJsonNull()) {
            nestedPojo.name = jsonElement.getAsString();
        }
        nestedPojo.value = jsonObject.get("value").getAsInt();
        return nestedPojo;
    }
}

Gson gson = new GsonBuilder().registerTypeAdapter(NestedPojo.class, new Custom()).create();

这篇关于为什么Gson fromJson抛出一个JsonSyntaxException：预期BEGIN_OBJECT但是BEGIN_ARRAY？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！