Gson类型适配器与自定义脱盐器

Question

下面的示例显示了一个类（Club），其中包含抽象类（成员）的集合。我对于是否需要TypeAdapter或JsonDeserializer才能使反序列化正常工作感到困惑。序列化在没有任何帮助的情况下就可以正常工作，但是反序列化会引发异常。为了说明这一点，我构建了以下“克隆”测试。如果有人能展示一个有效的例子，我将不胜感激。

头等舱

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

现在是抽象基类成员

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

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

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

最后是输出

    {"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$3.construct(ConstructorConstructor.java:107)
        at com.google.gson.internal.bind.ReflectiveTypeAdapterFactory$Adapter.read(ReflectiveTypeAdapterFactory.java:186)
...

Answer 1

你们两个都可以。您选择哪一个真正取决于对性能的潜在影响，以及愿意编写多少代码。

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

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

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

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