使用Gson解析不同字段的子类答案

【问题标题】：Using Gson to parse subclasses with different fields使用Gson解析不同字段的子类
【发布时间】：2013-03-12 18:25:48
【问题描述】：

我正在解析具有类似于以下响应模板的数据：

{
  response: {
    data: {}
  }
  meta: {
    errors: []
    success: 1
  }
}

对于每个特定响应，“数据”字段都填充有动态字段，但所有其他键（元等）保持不变。例如：

A类

data: {
  foo: ""
}

B类

data: {
  bar: 3
}

如何为我的类建模并使用 Gson 来表示这些数据？目前我有：

public class BaseResponse {
  @SerializedName("meta") public Meta meta;

  public class Meta {
    @SerializedName("errors") public ArrayList<Error> errors;
    @SerializedName("success") public int success;
  }
}

public class ClassA extends BaseResponse {
  @SerializedName("foo") public String foo;
}

public class ClassB extends BaseResponse {
  @SerializedName("bar") public int bar;
}

不幸的是，foo 和 bar 字段在解析时返回 null 值，使用例如：

Gson.fromJson(jsonString, ClassA.class);

我相信这是由于“foo”和“bar”字段是内部引用。

【问题讨论】：

我对gson不太了解，但是当你说解析返回null时，你调用Gson.fromJson(jsonString, ClassA.class);时jsonString的值是多少？
对于 ClassA 响应，它看起来像 { response: { data: {foo: "Foo!"} } meta: { errors: [] success: 1 } }
对于 B 类响应，它看起来像 { response: { data: {bar: 350} } meta: { errors: [] success: 1 } }
这些 json 是您自己创建的还是由 gson.toJson(a,ClassA.class) 或类似的东西创建的？
因为我认为您的 json 注释并不代表您提供的 json。所以你需要修改你的类。我认为你可能需要在你的BaseResponse 一个private ClassA a 或类似的东西。今晚我会试着给你一个更好的答案。

标签： java android json gson

【解决方案1】：

据我了解，自定义处理对于提供所需的多态反序列化是必要的，其中使用哪种类型的决定取决于特定 JSON 元素名称的存在。（由于 JSON 不包含类型信息，切换到另一个序列化 API，如 Jackson，不会提供更简单的解决方案。）

以下演示了我可能会采用的方法。

package com.stackoverflow.q15578106;

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;

public class Foo
{
  public static void main(String[] args)
  {
    /*
      {
        "response": {"data": {"foo": "FOO"}},
        "meta": {"errors": [], "success": 1}
      }
     */
    String input1 = "{\"response\": {\"data\": {\"foo\": \"FOO\"}},\"meta\": {\"errors\": [], \"success\": 1}}"; 

    /*
      {
        "response": {"data": {"bar": 42}},
        "meta": {"errors": [], "success": 1}
      }
     */
    String input2 = "{\"response\": {\"data\": {\"bar\": 42}},\"meta\": {\"errors\": [], \"success\": 1}}";

    processInput(input1);
    // {"response":{"data":{"foo":"FOO"}},"meta":{"errors":[],"success":1}}

    processInput(input2);
    // {"response":{"data":{"bar":42}},"meta":{"errors":[],"success":1}}
  }

  static void processInput(String jsonInput)
  {
    DataDeserializer dataDeserializer = new DataDeserializer();
    dataDeserializer.registerDataType("foo", A.class);
    dataDeserializer.registerDataType("bar", B.class);

    Gson gson = new GsonBuilder().registerTypeAdapter(Data.class, dataDeserializer).create();

    BaseResponse response = gson.fromJson(jsonInput, BaseResponse.class);
    System.out.println(new Gson().toJson(response)); 
  }
}

class DataDeserializer implements JsonDeserializer<Data>
{
  Map<String, Class<? extends Data>> dataTypeRegistry = new HashMap<String, Class<? extends Data>>();

  void registerDataType(String jsonElementName, Class<? extends Data> javaType)
  {
    dataTypeRegistry.put(jsonElementName, javaType);
  }

  @Override
  public Data deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException
  {
    JsonObject jsonObject = json.getAsJsonObject();
    for (String elementName : dataTypeRegistry.keySet())
    {
      if (jsonObject.has(elementName))
      {
        Class<? extends Data> dataType = dataTypeRegistry.get(elementName);
        return context.deserialize(jsonObject, dataType);
      }
    }
    throw new RuntimeException("Oops");
  }
}

class BaseResponse
{
  Response response;
  Meta meta;
}

class Meta
{
  List<String> errors;
  int success;
}

class Response
{
  Data data;
}

class Data
{

}

class A extends Data
{
  String foo;
}

class B extends Data
{
  int bar;
}

【讨论】：