在 gson 中解析动态 Json 对象

Question

我有这样的 json 结构，我如何在 Gson 的帮助下解析 json。我需要将键值存储在 json 对象中，我尝试了许多与动态数组相关的示例，但没有方括号的动态 json 数组我无法解析使用Gson.Any 解决方案或需要手动 Json Parse？如果有人觉得重复，请在下面评论答案。

{ "Result":[[
      "Title",
      {
        "0": 1323,
        "1": 3358,
        "2": 2123,
        "3": 8536,
        "4": 1399,
        "5": 9303,
        "7": 9732,
        "8": 3433,
        "9": 1383
      }
    ],[
      "Title",
      {
        "0": 1323,
        "1": 3358,
        "2": 2123,
        "3": 8536,
      }
    ]]}

Answer 1

首先，您的 JSON 会导致抛出异常，因为它无效 - 在第二个示例中，您在最后一个值的末尾有一个额外的逗号。 "3": 8536, 应该是 "3": 8536。

修复该问题后，只要您正确定义对象，这应该是一项简单的任务。这是我想出的：

public class Results {
    @SerializedName("Result")
    List<Result> results;
}

public class Result {
    String title;
    Map<String, Integer> results;
}

从那里，Result 类需要以特殊方式反序列化，因为Result 类中的字段不直接映射到 JSON 中的条目。相反，我们需要提取每个Result 中包含的JsonArray 的第一个和第二个元素，并相应地对其进行解析。看起来像这样：

public class ResultDeserializer implements JsonDeserializer<Result> {

    @Override
    public Result deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonArray array = json.getAsJsonArray();

        Result result = new Result();
        result.title = array.get(0).getAsString();

        result.results = new LinkedHashMap<String, Integer>();
        for(Entry<String, JsonElement> entry : array.get(1).getAsJsonObject().entrySet()) {
            result.results.put(entry.getKey(), entry.getValue().getAsInt());
        }

        return result;
    }   
}

请注意，我的示例省略了错误检查。最后，注册这个反序列化器，一切准备就绪：

Gson gson = new GsonBuilder().registerTypeAdapter(Result.class, new ResultDeserializer()).create();

Results results = gson.fromJson(json, Results.class);

for(Result r : results.results) {
    System.out.println("Title = " + r.title);
    for(Entry<String, Integer> entry : r.results.entrySet()) {
        System.out.println("\t " + entry.getKey() + " -> " + entry.getValue());
    }
}

打印出来：

Title = Title
     0 -> 1323
     1 -> 3358
     2 -> 2123
     3 -> 8536
     4 -> 1399
     5 -> 9303
     7 -> 9732
     8 -> 3433
     9 -> 1383
Title = Title
     0 -> 1323
     1 -> 3358
     2 -> 2123
     3 -> 8536

我将把它留给 OP 来实现反向，即Result 的序列化程序以产生相同的结果。

Answer 2

找到了在 Gson

中使用 Nested Map 解析上述 json 的简单方法

Result.java

public class Result {
    @SerializedName("formatted_facet_fields")
    Map<String,Map<String,String>> formatted_facet_fields;
}

响应接收方

 Gson  gson=new Gson();
 Result result = gson.fromJson(json_response, Result.class);

Answer 3

是的，您可以解析嵌套的 json 对象。

if (!exists) {
        keys = json.keys();
        while (keys.hasNext()) {
            nextKeys = (String) keys.next();
            try {

                if (json.get(nextKeys) instanceof JSONObject) {

                    if (exists == false) {
                        getKey(json.getJSONObject(nextKeys), key);
                    }

                } else if (json.get(nextKeys) instanceof JSONArray) {
                    JSONArray jsonarray = json.getJSONArray(nextKeys);
                    for (int i = 0; i < jsonarray.length(); i++) {
                        String jsonarrayString = jsonarray.get(i).toString();
                        JSONObject innerJSOn = new JSONObject(jsonarrayString);

                        if (exists == false) {
                            getKey(innerJSOn, key);
                        }

                    }

                }

            } catch (Exception e) {
                // TODO: handle exception
            }

        }

如需全面了解，请查看以下代码：代码说明：https://www.youtube.com/watch?v=ZjZqLUGCWxo