Gson不會序列化子類中定義的字段

Question

出於某種未知原因，如果我有：

class A{
int stars;
public int getStars(){
return stars;
}

public void setStarts(int stars){
this.stars = stars;
}
}

class B extends A{
 int sunshines;

[getter and setter for sunshines]
}

class C{
 List<A> classes;
[get and set for classes]
}

如果我序列化類型CI的對象在字段類中的序列化對象中只有A的字段（如果對象是B，我希望有B的字段）。

怎么做？

Answer 1

Gson 2.1支持開箱即用：

import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class GsonInheritanceTest
{
  public static void main(String[] args)
  {
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    C c = new C();
    c.classes = new ArrayList<A>();
    c.classes.add(new A(1));
    c.classes.add(new B(2, 3));
    System.out.println(gson.toJson(c));
  }

  static class A
  {
    int stars;

    A(int stars)
    {
      this.stars = stars;
    }
  }

  static class B extends A
  {
    int sunshines;

    B(int stars, int sunshines)
    {
      super(stars);
      this.sunshines = sunshines;
    }
  }

  static class C
  {
    List<A> classes;
  }
}

輸出是

{
  "classes": [
    {
      "stars": 1
    },
    {
      "sunshines": 3,
      "stars": 2
    }
  ]
}

Answer 2

我用伊萬的答案給我提供了一個稍微優雅的解決方案 - 它並不完美，但它對我來說效果很好。 我創建了一個新的JsonSerializer，它通過將A類型轉換為Object來拋棄它。 看來，當給定一個普通的Object Gson時，它會查看對象的實際類型，而不是引用傳入的變量的類型。

public static class ASerializer implements JsonSerializer<A> {

    @Override
    public JsonElement serialize( A in, Type type, JsonSerializationContext ctx ) {
        return ctx.serialize( (Object) in );
    }
}

然后，通過ASerializer到GsonBuilder讓自己的GSON實例使用方法：

GsonBuilder gb = new GsonBuilder();
gb.registerTypeAdapter( A.class, new ASerializer() ); 
Gson gson = gb.create();

Answer 3

我已經嘗試過你的例子，在C類中用List<Object>替換List<A>解決了這個問題。

import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;

public class GsonInheritanceTest {
public static void main(String[] args) {
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    C c = new C();
    c.classes = new ArrayList<Object>();
    c.classes.add(new A());
    c.classes.add(new B());
    System.out.println(gson.toJson(c));
}

public static class A {
    int stars;
}

public static class B extends A {
    int sunshines;
}

public static class C {
    List<Object> classes;
}
}

生產：

{
  "classes": [
    {
      "stars": 0
    },
    {
      "sunshines": 0,
      "stars": 0
    }
  ]
}

但是，這會阻止您使用默認的json反序列化...考慮重構您的OOD和繼承關系。

Answer 4

Gson對多態類型處理的支持是不完整的。

如果可能的話，我強烈建議切換到Jackson ，它可以完美地處理原始問題中的序列化問題。

如果必須使用Gson，則需要自定義序列化處理來處理這樣的數據結構。 幸運的是，自定義序列化器的實現可以非常簡單。 例如：

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;

public class GsonFoo
{
  public static void main(String[] args)
  {
    C c = new C();
    c.classes = new ArrayList<A>();
    c.classes.add(new A(42));
    c.classes.add(new B(8));

    System.out.println(new Gson().toJson(c));
    // output:
    // {"classes":[{"stars":42},{"stars":-1}]}

    GsonBuilder gsonBuilder = new GsonBuilder();
    gsonBuilder.registerTypeAdapter(A.class, new ASerializer());
    Gson gson = gsonBuilder.create();
    System.out.println(gson.toJson(c));
    // output:
    // {"classes":[{"stars":42},{"sunshines":8,"stars":-1}]}
  }
}

class ASerializer implements JsonSerializer<A>
{
  @Override
  public JsonElement serialize(A src, Type typeOfSrc, JsonSerializationContext context)
  {
    Gson gson = new Gson();
    return gson.toJsonTree(src);
  }
}

class A
{
  public int stars;

  A(int s)
  {
    stars = s;
  }
}

class B extends A
{
  public int sunshines;

  B(int s)
  {
    super(-1);
    sunshines = s;
  }
}

class C
{
  public List<A> classes;
}