Question

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

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

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

ClassA的

data: {
  foo: ""
}

ClassB的

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字段在解析时使用例如：

返回空值

Gson.fromJson(jsonString, ClassA.class);

我认为这是因为“foo”和“bar”字段是内部引用。

Answer 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;
}

使用Gson解析具有不同字段的子类

1 个答案: