Java Gson 类型适配器与自定义去盐器

Gson Type Adapter vs. Custom Deseralizer

提问by Mike Storey

The example below shows a class (Club) that contains a collection of an abstract class (Member). I'm confused as to whether I need a TypeAdapter or JsonDeserializer to make the Deserialization work correctly. Serialization works just fine without any help, but Deserialization is throwing exceptions. To illustrate I've built the following "clone" test. If anyone could show a working example I would be very grateful.

下面的示例显示了一个包含抽象类 (Member) 集合的类 (Club)。我很困惑我是否需要 TypeAdapter 或 JsonDeserializer 才能使反序列化正常工作。序列化在没有任何帮助的情况下工作得很好，但反序列化会引发异常。为了说明我已经构建了以下“克隆”测试。如果有人可以展示一个工作示例，我将不胜感激。

First Club Class

头等舱

package gson.test;
import java.util.ArrayList;

import com.google.gson.Gson;

public class Club {
    public static void main(String[] args) {
        // Setup a Club with 2 members
        Club myClub = new Club();
        myClub.addMember(new Silver());
        myClub.addMember(new Gold());

        // Serialize to JSON
        Gson gson = new Gson();
        String myJsonClub = gson.toJson(myClub); 
        System.out.println(myJsonClub);

        // De-Serialize to Club
        Club myNewClub = gson.fromJson(myJsonClub, Club.class);
        System.out.println(myClub.equals(myNewClub) ? "Cloned!" : "Failed");
    }

    private String title = "MyClub";
    private ArrayList<Member> members = new ArrayList<Member>();

    public boolean equals(Club that) {
        if (!this.title.equals(that.title)) return false;
        for (int i=0; i<this.members.size(); i++) {
            if (! this.getMember(i).equals(that.getMember(i))) return false;
        }
        return true;
    }
    public void addMember(Member newMember) { members.add(newMember); }
    public Member getMember(int i) { return members.get(i); }
}

Now the Abstract Base Class Member

现在是抽象基类成员

package gson.test;
public abstract class Member {
    private int type;
    private String name = "";

    public int getType() { return type; }
    public void setType(int type) { this.type = type; }
    public boolean equals(Member that) {return this.name.equals(that.name);}
}

And two concrete sub-classes of Member (Gold and Silver)

以及会员的两个具体子类（金和银​​）

package gson.test;
public class Gold extends Member {
    private String goldData = "SomeGoldData";
    public Gold() {
        super();
        this.setType(2);
    }
    public boolean equals(Gold that) {
        return (super.equals(that) && this.goldData.equals(that.goldData)); 
    }
}

package gson.test;
public class Silver extends Member {
    private String silverData = "SomeSilverData";
    public Silver() {
        super();
        this.setType(1);
    }
    public boolean equals(Silver that) { 
        return (super.equals(that) && this.silverData.equals(that.silverData)); 
    }
}

And finally the output

最后输出

    {"title":"MyClub","members":[{"silverData":"SomeSilverData","type":1,"name":""},{"goldData":"SomeGoldData","type":2,"name":""}]}
    Exception in thread "main" java.lang.RuntimeException: Failed to invoke public gson.test.Member() with no args
        at com.google.gson.internal.ConstructorConstructor.construct(ConstructorConstructor.java:107)
        at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:186)
...

采纳答案by Pawel Veselov

You can do both. Which one you pick depends really on potential performance impact, and how much code are willing to write.

你可以两者都做。您选择哪一个实际上取决于潜在的性能影响，以及愿意编写多少代码。

Deserializers are more expensive. That is because the input to deserializer is a json tree, and GSon will have to create a full JsonElement subtree of the property that matches your class, before it can pass it to your deserializer. If your classes have a lot of nesting, that cost increases. For plain objects, it will be negligible.

解串器更贵。这是因为反序列化器的输入是一个 json 树，并且 GSon 必须创建一个与您的类匹配的属性的完整 JsonElement 子树，然后才能将其传递给您的反序列化器。如果您的类有很多嵌套，则成本会增加。对于普通对象，可以忽略不计。

It seems that you will know which class to create based on the value of typeproperty that will be included in target object. Your deserializer will need to

似乎您将根据type将包含在目标对象中的属性值知道要创建哪个类。你的解串器需​​要

• look into the passed JsonElementobject, read the typeproperty, determine the type
• call context.deserialize()with the class and the same element that was passed to you
• throw an error if type was missing or invalid

• 查看传递的JsonElement对象，读取type属性，确定类型
• context.deserialize()使用传递给您的类和相同的元素调用
• 如果类型丢失或无效，则抛出错误

Your type adapter will have to be more complex. The input to the type adapter is stream, not an element/subtree. You can load the next value entirely from the stream, parse it, and then do exactly what deserializer did, which doesn't make sense and you can just use the deserializer interface. Alternatively, you can read the stream, see what properties there are, save them into local variables, until you get to the typeproperty (you can't predict its location), then finish reading the remainder of the properties, and create your final Gold/Silverobjects based on type, and all the properties read and saved.

您的类型适配器必须更复杂。类型适配器的输入是流，而不是元素/子树。您可以完全从流中加载下一个值，解析它，然后完全执行反序列化器所做的工作，这没有意义，您可以只使用反序列化器接口。或者，您可以读取流，查看有哪些属性，将它们保存到局部变量中，直到到达该type属性（您无法预测其位置），然后完成读取其余属性，并创建您的最终Gold/Silver基于类型的对象，以及读取和保存的所有属性。

回答by Mike Storey

Ok, real working example (I'm pretty sure this time).

好的，真正的工作示例（这次我很确定）。

The Club

该俱乐部

package gson.test;
import java.util.ArrayList;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class Club {
    public static void main(String[] args) {
        // Setup a Club with 2 members
        Club myClub = new Club();
        myClub.addMember(new Silver("Hyman"));
        myClub.addMember(new Gold("Jill"));
        myClub.addMember(new Silver("Mike"));

        // Get the GSON Object and register Type Adapter
        GsonBuilder builder = new GsonBuilder();
        builder.registerTypeAdapter(Member.class, new MemberDeserializer());
        builder.registerTypeAdapter(Member.class, new MemberSerializer());
        builder.setPrettyPrinting();
        Gson gson = builder.create();

        // Serialize Club to JSON
        String myJsonClub = gson.toJson(myClub); 

        // De-Serialize to Club
        Club myNewClub = gson.fromJson(myJsonClub, Club.class);
        System.out.println(myClub.equals(myNewClub) ? "Cloned!" : "Failed");
        System.out.println(gson.toJson(myNewClub));
    }

    private String title = "MyClub";
    private ArrayList<Member> members = new ArrayList<Member>();

    public boolean equals(Object club) {
        Club that = (Club) club;
        if (!this.title.equals(that.title)) return false;
        for (int i=0; i<this.members.size(); i++) {
            Member member1 = this.getMember(i);
            Member member2 = that.getMember(i);
            if (! member1.equals(member2)) return false;
        }
        return true;
    }
    public void addMember(Member newMember) { members.add(newMember); }
    public Member getMember(int i) { return members.get(i); }
}

The Member Abstract Class

成员抽象类

package gson.test;
public abstract class Member {
    private String clsname = this.getClass().getName() ;
    private int type;
    private String name = "unknown";

    public Member() { }
    public Member(String theName) {this.name = theName;}
    public int getType() { return type; }
    public void setType(int type) { this.type = type; }
    public boolean equals(Object member) {
        Member that = (Member) member;
        return this.name.equals(that.name);
    }
}

The Concrete Sub-Classes Silver and Gold

具体的子类银和金

package gson.test;
public class Silver extends Member {
    private String silverData = "SomeSilverData";
    public Silver() { 
        super(); 
        this.setType(1); 
    }
    public Silver(String theName) {
        super(theName); 
        this.setType(1); 
    }
    public boolean equals(Object that) {
        Silver silver = (Silver)that;
        return (super.equals(that) && this.silverData.equals(silver.silverData)); 
    }
}

package gson.test;
public class Gold extends Member {
    private String goldData = "SomeGoldData";
    private String extraData = "Extra Gold Data";
    public Gold() {
        super(); 
        this.setType(2);
    }
    public Gold(String theName) { 
        super(theName); 
        this.setType(2); 
    }
    public boolean equals(Gold that) {
        Gold gold = (Gold) that;
        return (super.equals(that) && this.goldData.equals(gold.goldData)); 
    }
}

The Custom Member Serailizer

自定义成员Serailizer

package gson.test;
import java.lang.reflect.Type;
import com.google.gson.JsonElement;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

public class MemberSerializer implements JsonSerializer<Member> {

    public JsonElement serialize(Member src, Type member, JsonSerializationContext context) {
        switch (src.getType()) {
            case 1: return context.serialize((Silver)src);
            case 2: return context.serialize((Gold)src);
            default: return null;
        }
    }
}

The custom Deserializer

自定义解串器

package gson.test;
import java.lang.reflect.Type;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;

public class MemberDeserializer implements JsonDeserializer<Member> {
    @Override
    public Member deserialize(JsonElement json, Type member, JsonDeserializationContext context) {
        int myType = json.getAsJsonObject().get("type").getAsInt();
        switch (myType) {
            case 1: return context.deserialize(json, Silver.class);
            case 2: return context.deserialize(json, Gold.class);
            default: return null;
        }
    }
}

And... the output

而且……输出

Cloned!
{
  "title": "MyClub",
  "members": [
    {
      "silverData": "SomeSilverData",
      "clsname": "gson.test.Silver",
      "type": 1,
      "name": "Hyman"
    },
    {
      "goldData": "SomeGoldData",
      "extraData": "Extra Gold Data",
      "clsname": "gson.test.Gold",
      "type": 2,
      "name": "Jill"
    },
    {
      "silverData": "SomeSilverData",
      "clsname": "gson.test.Silver",
      "type": 1,
      "name": "Mike"
    }
  ]
}

I should note that my real use-case is one where performance should not be an issue, I'm loading a cache of objects from jSon text files so the frequency with this code is executed makes performance much less important than maintainability.

我应该注意，我的实际用例是性能不应该成为问题的用例，我正在从 json 文本文件加载对象缓存，因此执行此代码的频率使得性能远不如可维护性重要。

回答by Nikola Mihajlovi?

It looks like serializing/deserializing class hierarchies is a common problem.

看起来序列化/反序列化类层次结构是一个常见问题。

There is even an "official" solution, inside extrasdirectory of the official source repo (unfortunately it is not part of the Maven package though).

extras在官方源代码库的目录中甚至有一个“官方”解决方案（不幸的是，它不是 Maven 包的一部分）。

Please check:

请检查：

• The explanation: https://blog.novatec-gmbh.de/gson-object-hierarchies/
• The solution: https://github.com/google/gson/blob/master/extras/src/main/java/com/google/gson/typeadapters/RuntimeTypeAdapterFactory.java. It is suggested to just copy/paste the source.

• 解释：https: //blog.novatec-gmbh.de/gson-object-hierarchies/
• 解决方案：https://github.com/google/gson/blob/master/extras/src/main/java/com/google/gson/typeadapters/RuntimeTypeAdapterFactory.java。建议只复制/粘贴源。