Java Gson不'；t序列化子类中定义的字段

出于未知原因，如果我有：

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]
}

A类{
int星；
公共int getStars（）{
回归之星；
}
公共无效设置开始（整数星）{
这个。星星=星星；
}
}
B类扩展了A类{
太阳光；
[太阳之光的接球手和接球手]
}
C类{
列出课程；
[获取并设置课程]
}

如果序列化类型为C的对象，则字段类中的序列化对象中只有A的字段（而如果对象是A B，则希望有B的字段）

---

怎么做

我试过你的例子，在C班用

List

替换

List

解决了这个问题

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

---

但是，这会阻止您使用默认的json反序列化。。。考虑重构您的OOD和继承关系。

GSON支持多态性处理不完整。

如果可能的话，我强烈建议切换到，这样可以完美地处理原始问题中的序列化问题

如果必须使用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;
}

import java.lang.reflect.Type；
导入java.util.ArrayList；
导入java.util.List；
导入com.google.gson.gson；
导入com.google.gson.GsonBuilder；
导入com.google.gson.JsonElement；
导入com.google.gson.JsonSerializationContext；
导入com.google.gson.JsonSerializer；
公共类GsonFoo
{
公共静态void main（字符串[]args）
{
C=新的C（）；
c、 classes=新的ArrayList（）；
c、 增加（新的A（42））；
c、 增加（新的B（8））；
System.out.println（新的Gson（）.toJson（c））；
//输出：
//{“类”：[{“星”：42}，{“星”：-1}]}
GsonBuilder GsonBuilder=新的GsonBuilder（）；
registerTypeAdapter（A.class，新的ASerializer（））；
Gson-Gson=gsonBuilder.create（）；
System.out.println（gson.toJson（c））；
//输出：
//{“类”：[{“星”：42}，{“太阳光”：8，“星”：-1}]}
}
}
类ASerializer实现JsonSerializer
{
@凌驾
公共JsonElement序列化（src，类型typeOfSrc，JsonSerializationContext）
{
Gson Gson=新的Gson（）；
返回gson.toJsonTree（src）；
}
}
甲级
{
公众娱乐明星；
A（整数s）
{
星星=s；
}
}
B类扩展了A类
{
阳光普照；
B（int s）
{
超级（-1）；
阳光=s；
}
}
C类
{
公开名单课程；
}

我用Ivan的答案给我提供了一个稍微优雅一点的解决方案——它并不完美，但对我来说已经足够好了。我创建了一个新的JsonSerializer，通过将a的类型强制转换到对象来丢弃它。似乎当给定一个普通对象时，Gson会查看对象的实际类型，而不是引用传入的变量类型

public static class ASerializer implements JsonSerializer<A> {

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

---

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

---

陛下无论如何，这种方法是可行的，我的java代码不会这样工作。谢谢，但这不是一个好的解决方案1）使用

List

2）使用JSON序列化之类的小东西影响设计，你不应该改变你认为最适合你的应用程序的设计，这只是因为一些序列化库期望一个不同的。可能的重复：在这里您可以找到一个工作示例：不确定是否是同一个问题，我使用的是GSON v 2.8，在类似的情况下失败

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

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
    }
  ]
}