31

我有一个像这样的课程：

public class Barn {
    String type;
    Animal animal;
}

public class Horse extends Animal {
}

public class Cow extends Animal {
}

我想序列化它们的列表：

List<Barn> barns = new ArrayList<Barn>();

Barn barn1 = new Barn();
barn1.setType("horse");
barn1.setAnimal(new Horse());
barns.add(barn1);

Barn barn2 = new Barn();
barn2.setType("cow");
barn2.setAnimal(new Cow());
barns.add(barn2);

...

Group<Barn> barns = gson.fromJson(serialized);

当我序列化时，Animal 属性的类型信息将丢失。有没有办法以某种方式安装解析器侦听器，以便在遇到列表中的每个元素时提供正确的类来反序列化？这就是手动提供描述类类型的字符串背后的想法。

谢谢

4

4 回答 4

20

在 Gson 项目代码库中是RuntimeTypeAdapter，据报道它适用于多态序列化和反序列化。我想我还没有尝试过使用它。有关详细信息，请参阅http://code.google.com/p/google-gson/issues/detail?id=231。请注意，它尚未包含在任何 Gson 版本中。

如果使用它不符合您的需求，则需要自定义反序列化处理。以下是一种这样的方法，假设您要使用演示的 JSON 结构。（如果 JSON 结构可能不同，我会采取一些不同的方法。）

import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;

public class App
{
  public static void main(String[] args)
  {
    Barn[] barns = {new Barn(), new Barn()};
    barns[0].type = "horse";
    barns[0].animal = new Horse();
    barns[1].type = "cow";
    barns[1].animal = new Cow();

    String json = new Gson().toJson(barns);
    // [{"type":"horse","animal":{}},{"type":"cow","animal":{}}]

    BarnDeserializer deserializer = new BarnDeserializer("type");
    deserializer.registerBarnType("horse", Horse.class);
    deserializer.registerBarnType("cow", Cow.class);
    Gson gson = new GsonBuilder().registerTypeAdapter(Barn.class, deserializer).create();

    List<Barn> barns2= gson.fromJson(json, new TypeToken<List<Barn>>(){}.getType());
    for (Barn barn : barns2)
    {
      System.out.println(barn.animal.getClass());
    }
  }
}

class BarnDeserializer implements JsonDeserializer<Barn>
{
  String barnTypeElementName;
  Gson gson;
  Map<String, Class<? extends Animal>> barnTypeRegistry;

  BarnDeserializer(String barnTypeElementName)
  {
    this.barnTypeElementName = barnTypeElementName;
    gson = new Gson();
    barnTypeRegistry = new HashMap<>(); // Java 7 required for this syntax.
  }

  void registerBarnType(String barnTypeName, Class<? extends Animal> animalType)
  {
    barnTypeRegistry.put(barnTypeName, animalType);
  }

  @Override
  public Barn deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) 
      throws JsonParseException
  {
    JsonObject barnObject = json.getAsJsonObject();
    JsonElement animalTypeElement = barnObject.get(barnTypeElementName);
    Barn barn = new Barn();
    barn.type = animalTypeElement.getAsString(); 
    Class<? extends Animal> animalType = barnTypeRegistry.get(barn.type);
    barn.animal = gson.fromJson(barnObject.get("animal"), animalType);
    return barn;
  }
}

class Barn {String type; Animal animal;}
class Animal {}
class Horse extends Animal {}
class Cow extends Animal {}
于 2013-04-01T04:39:31.133 回答
13

您可以为此使用Gson Fire。代码看起来像这样：

GsonFireBuilder builder = new GsonFireBuilder()
    .registerTypeSelector(Barn.class, new TypeSelector<Barn>() {
        @Override
        public Class<? extends Barn> getClassForElement(JsonElement readElement) {
            String type = readElement.getAsJsonObject().get("type").getAsString();
            if(type.equals("horse")){
                return Horse.class; 
            } else if(type.equals("cow")) {
                return Cow.class;
            } else {
                return null; //returning null will trigger Gson's default behavior
            }
        }
    });
Gson gson = builder.createGson();
于 2014-12-30T18:49:29.197 回答
8

您不需要编写自己的适配器。

最后，gson 有自己的RuntimeTypeAdapterFactory来处理 java 多态性，但不幸的是它不是 gson 核心库的一部分（为了使用它，您必须将类复制并粘贴到您的项目中）。

假设你有这个Animal.class：

public class Animal {
    protected String name;
    protected String type;

    public Animal(String name, String type) {
        this.name = name;
        this.type = type;
    }
}

并且Horse.class：

public class Horse extends Animal {
    public Horse(String name) {
        super(name, "horse");
    }
}

RuntimeTypeAdapterFactory您可以使用以下代码初始化：

RuntimeTypeAdapterFactory<Animal> runtimeTypeAdapterFactory = RuntimeTypeAdapterFactory
.of(Animal.class, "type")
.registerSubtype(Horse.class, "horse")
.registerSubtype(Cow.class, "cow");

Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(runtimeTypeAdapterFactory)
    .create();

在这里您可以找到一个完整的工作示例。

于 2018-09-04T09:10:30.523 回答
0

我也对该功能感兴趣，并已向 GSon 添加了功能请求

https://github.com/google/gson/issues/869

于 2016-06-03T15:20:30.913 回答