在 Gson 中反序列化抽象类

Question

我有一个 JSON 格式的树对象，我正在尝试使用 Gson 反序列化。每个节点都包含其子节点作为对象类型 Node 的字段。 Node 是一个接口，它有几个具体的类实现。在反序列化过程中，如果我事先不知道节点属于哪种类型，如何与 Gson 通信在反序列化节点时要实现哪个具体类？每个节点都有一个指定类型的成员字段。当对象处于序列化形式时，有没有办法访问该字段，并以某种方式将类型传递给 Gson？

谢谢！

Answer 1

我建议添加自定义 JsonDeserializer for Node：

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Node.class, new NodeDeserializer())
    .create();

您将能够在反序列化器的方法中访问表示节点的 JsonElement，将其转换为 JsonObject< /code>，并检索指定类型的字段。然后，您可以基于此创建正确类型的 Node 实例。

Answer 2

您需要注册 JSONSerializer 和 JSONDeserializer。您还可以通过以下方式为所有接口实现通用适配器：

• 在序列化期间：添加实际 impl 类类型的 META-info。
• 在反序列化期间：检索该元信息并调用该类的 JSONDeserailize

这是我自己使用的实现并且工作正常。

public class PropertyBasedInterfaceMarshal implements
        JsonSerializer<Object>, JsonDeserializer<Object> {

    private static final String CLASS_META_KEY = "CLASS_META_KEY";

    @Override
    public Object deserialize(JsonElement jsonElement, Type type,
            JsonDeserializationContext jsonDeserializationContext)
            throws JsonParseException {
        JsonObject jsonObj = jsonElement.getAsJsonObject();
        String className = jsonObj.get(CLASS_META_KEY).getAsString();
        try {
            Class<?> clz = Class.forName(className);
            return jsonDeserializationContext.deserialize(jsonElement, clz);
        } catch (ClassNotFoundException e) {
            throw new JsonParseException(e);
        }
    }

    @Override
    public JsonElement serialize(Object object, Type type,
            JsonSerializationContext jsonSerializationContext) {
        JsonElement jsonEle = jsonSerializationContext.serialize(object, object.getClass());
        jsonEle.getAsJsonObject().addProperty(CLASS_META_KEY,
                object.getClass().getCanonicalName());
        return jsonEle;
    }

}

然后您可以为所有接口注册此适配器，如下所示

Gson gson = new GsonBuilder()
        .registerTypeAdapter(IInterfaceOne.class,
                new PropertyBasedInterfaceMarshal())
        .registerTypeAdapter(IInterfaceTwo.class,
                new PropertyBasedInterfaceMarshal()).create();

Answer 3

我想稍微纠正一下上面的内容

public class PropertyMarshallerAbstractTask implements JsonSerializer<Object>, JsonDeserializer<Object> {

    private static final String CLASS_TYPE = "CLASS_TYPE";

    @Override
    public Object deserialize(JsonElement jsonElement, Type type, JsonDeserializationContext jsonDeserializationContext) throws JsonParseException {

        JsonObject jsonObj = jsonElement.getAsJsonObject();
       String className = jsonObj.get(CLASS_TYPE).getAsString();

        try {
            Class<?> clz = Class.forName(className);
            return jsonDeserializationContext.deserialize(jsonElement, clz);
        } catch (ClassNotFoundException e) {
            throw new JsonParseException(e);
        }
    }

    @Override
    public JsonElement serialize(Object object, Type type, JsonSerializationContext jsonSerializationContext) {
    
        Gson gson = new Gson(); //without this line it will not work
        gson.toJson(object, object.getClass()); //and this one
        JsonElement jsonElement = gson.toJsonTree(object); //it needs to replace to another method...toJsonTree
        jsonElement.getAsJsonObject().addProperty(CLASS_TYPE, object.getClass().getCanonicalName());
        return jsonElement;
    }
}

然后我使用它：

Gson gson = new GsonBuilder()
                .registerTypeAdapter(AbstractTask.class, new PropertyMarshallerOfAbstractTask())
                .create();

然后我可以将List（我在其中保留一些从Abstract Task继承的非抽象类）解析为Json；

它的作用方向相反

List<AbstractTask> abstractTasks = gson.fromJson(json, new TypeToken<List<AbstractTask>>(){}.getType());

Answer 4

据我所知，这不适用于非集合类型，或者更具体地说，不适用于使用具体类型进行序列化而使用接口类型进行反序列化的情况。也就是说，如果您有一个实现接口的简单类，并且序列化具体类，然后指定要反序列化的接口，那么您最终将陷入不可恢复的情况。

在上面的示例中，类型适配器是针对接口注册的，但是当您使用具体类进行序列化时，它将不会被使用，这意味着 CLASS_META_KEY 数据将永远不会被设置。

如果您将适配器指定为分层适配器（从而告诉 gson 将其用于层次结构中的所有类型），您将最终陷入无限循环，因为序列化程序将继续调用自身。

任何人都知道如何从接口的具体实现进行序列化，然后仅使用接口和 InstanceCreator 进行反序列化？

默认情况下，gson 似乎会创建具体实例，但不会设置它的字段。

问题记录在此处：

http://code. google.com/p/google-gson/issues/detail?id=411&q=interface

Answer 5

您必须使用 Google Gson 中的 TypeToken 类。
当然，您需要一个通用类 T 才能使其正常工作

Type fooType = new TypeToken<Foo<Bar>>() {}.getType();

gson.toJson(foo, fooType);

gson.fromJson(json, fooType);

Answer 6

我无法使用上面的 TypeAdapter 解决方案，并且几乎放弃了序列化。最后我在类对象和Gson之间的中间步骤找到了解决方案。我将对象本身序列化为字节数组，然后 Gson 以类似的方式序列化字节数组+反序列化回来。

public class GenericSerializer {
  public static byte[] serializeForClass(final Object obj) {
    try {
      final var byteArrayOutputStream = new ByteArrayOutputStream();
      final var objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
      objectOutputStream.writeObject(obj);
      objectOutputStream.flush();
      objectOutputStream.close();
      return byteArrayOutputStream.toByteArray();
    } catch (IOException e) {
      LOG.warn("Unable to serialize for class '%s'".formatted(obj.getClass().getName()), e);
      return null;
    }
  }

  public static <T> T deserializeForClass(final byte[] serializedObj, final Class<T> cls) {
    if (serializedObj == null) {
      return null;
    }
    try {
      final var inputStream = new ByteArrayInputStream(serializedObj);
      final var objectInputStream = new ObjectInputStream(inputStream);
      return cls.cast(objectInputStream.readObject());
    } catch (ClassNotFoundException | IOException | NullPointerException e) {
      LOG.warn("Unable to deserialize for class '%s'".formatted(cls), e);
      return null;
    }
  }

像这样使用

final var yourObject = new YourClass();
final var serialized = GenericSerializer.serializeForClass(yourObject);
final var gson = new Gson();
final var gsonSerialized = gson.toJson(serialized);
final var gsonDeserialized = gson.fromJson(gsonSerialized, byte[].class)
final var deserialized =  GenericSerializer.deserializeForClass(gsonDeserialized, YourClass.class);
assert(yourObject == deserialized);

我希望这可以像帮助我一样帮助别人。