У меня проблема с десериализацией строки json с помощью Gson. Я получаю массив команд. Команда может быть запуском, остановкой или другим типом команды. Естественно у меня есть полиморфизм, и команда запуска / остановки наследуется от команды.
Как я могу сериализовать его обратно в правильный командный объект с помощью gson?
Кажется, я получаю только базовый тип, то есть объявленный тип, а не тип времени выполнения.
Ответы:
Это немного поздно, но сегодня мне пришлось сделать то же самое. Итак, на основе моих исследований и при использовании gson-2.0 вы действительно не хотите использовать метод registerTypeHierarchyAdapter , а скорее более приземленный метод registerTypeAdapter . И вам, конечно, не нужно создавать instanceofs или писать адаптеры для производных классов: только один адаптер для базового класса или интерфейса, если, конечно, вас устраивает сериализация по умолчанию для производных классов. Во всяком случае, вот код (пакет и импорт удалены) (также доступен в github ):
Базовый класс (в моем случае интерфейс):
public interface IAnimal { public String sound(); }Два производных класса Cat:
public class Cat implements IAnimal {
public String name;
public Cat(String name) {
super();
this.name = name;
}
@Override
public String sound() {
return name + " : \"meaow\"";
};
}И собака:
public class Dog implements IAnimal {
public String name;
public int ferocity;
public Dog(String name, int ferocity) {
super();
this.name = name;
this.ferocity = ferocity;
}
@Override
public String sound() {
return name + " : \"bark\" (ferocity level:" + ferocity + ")";
}
}IAnimalAdapter:
public class IAnimalAdapter implements JsonSerializer<IAnimal>, JsonDeserializer<IAnimal>{
private static final String CLASSNAME = "CLASSNAME";
private static final String INSTANCE = "INSTANCE";
@Override
public JsonElement serialize(IAnimal src, Type typeOfSrc,
JsonSerializationContext context) {
JsonObject retValue = new JsonObject();
String className = src.getClass().getName();
retValue.addProperty(CLASSNAME, className);
JsonElement elem = context.serialize(src);
retValue.add(INSTANCE, elem);
return retValue;
}
@Override
public IAnimal deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
JsonObject jsonObject = json.getAsJsonObject();
JsonPrimitive prim = (JsonPrimitive) jsonObject.get(CLASSNAME);
String className = prim.getAsString();
Class<?> klass = null;
try {
klass = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new JsonParseException(e.getMessage());
}
return context.deserialize(jsonObject.get(INSTANCE), klass);
}
}И класс Test:
public class Test {
public static void main(String[] args) {
IAnimal animals[] = new IAnimal[]{new Cat("Kitty"), new Dog("Brutus", 5)};
Gson gsonExt = null;
{
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(IAnimal.class, new IAnimalAdapter());
gsonExt = builder.create();
}
for (IAnimal animal : animals) {
String animalJson = gsonExt.toJson(animal, IAnimal.class);
System.out.println("serialized with the custom serializer:" + animalJson);
IAnimal animal2 = gsonExt.fromJson(animalJson, IAnimal.class);
System.out.println(animal2.sound());
}
}
}Когда вы запустите Test :: main, вы получите следующий результат:
serialized with the custom serializer:
{"CLASSNAME":"com.synelixis.caches.viz.json.playground.plainAdapter.Cat","INSTANCE":{"name":"Kitty"}}
Kitty : "meaow"
serialized with the custom serializer:
{"CLASSNAME":"com.synelixis.caches.viz.json.playground.plainAdapter.Dog","INSTANCE":{"name":"Brutus","ferocity":5}}
Brutus : "bark" (ferocity level:5)Я действительно сделал это, используя метод registerTypeHierarchyAdapter , но для этого, похоже, потребовалось реализовать собственные классы сериализатора / десериализатора DogAdapter и CatAdapter, которые сложно поддерживать в любое время, когда вы хотите добавить другое поле в Dog или в Cat.
В настоящее время Gson имеет механизм регистрации адаптера иерархии типов. который, как сообщается, может быть настроен для простой полиморфной десериализации, но я не понимаю, как это происходит, поскольку адаптер иерархии типов выглядит просто как комбинированный сериализатор / десериализатор / создатель экземпляра, оставляя детали создания экземпляра на усмотрение кодировщика, без предоставления фактической регистрации полиморфного типа.
Похоже, что у Gson скоро появится RuntimeTypeAdapterболее простая полиморфная десериализация. См. Http://code.google.com/p/google-gson/issues/detail?id=231. для получения дополнительной информации.
Если использовать новый RuntimeTypeAdapter невозможно и вам нужно использовать Gson, я думаю, вам придется развернуть свое собственное решение, зарегистрировав собственный десериализатор либо как адаптер иерархии типов, либо как адаптер типа. Ниже приводится один из таких примеров.
// output:
// Starting machine1
// Stopping machine2
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.Map;
import com.google.gson.FieldNamingPolicy;
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;
public class Foo
{
// [{"machine_name":"machine1","command":"start"},{"machine_name":"machine2","command":"stop"}]
static String jsonInput = "[{\"machine_name\":\"machine1\",\"command\":\"start\"},{\"machine_name\":\"machine2\",\"command\":\"stop\"}]";
public static void main(String[] args)
{
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
CommandDeserializer deserializer = new CommandDeserializer("command");
deserializer.registerCommand("start", Start.class);
deserializer.registerCommand("stop", Stop.class);
gsonBuilder.registerTypeAdapter(Command.class, deserializer);
Gson gson = gsonBuilder.create();
Command[] commands = gson.fromJson(jsonInput, Command[].class);
for (Command command : commands)
{
command.execute();
}
}
}
class CommandDeserializer implements JsonDeserializer<Command>
{
String commandElementName;
Gson gson;
Map<String, Class<? extends Command>> commandRegistry;
CommandDeserializer(String commandElementName)
{
this.commandElementName = commandElementName;
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES);
gson = gsonBuilder.create();
commandRegistry = new HashMap<String, Class<? extends Command>>();
}
void registerCommand(String command, Class<? extends Command> commandInstanceClass)
{
commandRegistry.put(command, commandInstanceClass);
}
@Override
public Command deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException
{
try
{
JsonObject commandObject = json.getAsJsonObject();
JsonElement commandTypeElement = commandObject.get(commandElementName);
Class<? extends Command> commandInstanceClass = commandRegistry.get(commandTypeElement.getAsString());
Command command = gson.fromJson(json, commandInstanceClass);
return command;
}
catch (Exception e)
{
throw new RuntimeException(e);
}
}
}
abstract class Command
{
String machineName;
Command(String machineName)
{
this.machineName = machineName;
}
abstract void execute();
}
class Stop extends Command
{
Stop(String machineName)
{
super(machineName);
}
void execute()
{
System.out.println("Stopping " + machineName);
}
}
class Start extends Command
{
Start(String machineName)
{
super(machineName);
}
void execute()
{
System.out.println("Starting " + machineName);
}
}RuntimeTypeAdapterтеперь завершено, к сожалению, пока не похоже, что оно в ядре Gson. :-(
У Марка Юния Брута был отличный ответ (спасибо!). Чтобы расширить его пример, вы можете сделать его класс адаптера универсальным для работы со всеми типами объектов (не только IAnimal) со следующими изменениями:
class InheritanceAdapter<T> implements JsonSerializer<T>, JsonDeserializer<T>
{
....
public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context)
....
public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException
....
}И в тестовом классе:
public class Test {
public static void main(String[] args) {
....
builder.registerTypeAdapter(IAnimal.class, new InheritanceAdapter<IAnimal>());
....
}GSON предлагает здесь довольно хороший тестовый пример, показывающий, как определить и зарегистрировать адаптер иерархии типов.
Чтобы использовать это, сделайте следующее:
gson = new GsonBuilder()
.registerTypeAdapter(BaseQuestion.class, new BaseQuestionAdaptor())
.create();Метод Serialize адаптера может быть каскадной проверкой if-else того, какого типа он сериализует.
JsonElement result = new JsonObject();
if (src instanceof SliderQuestion) {
result = context.serialize(src, SliderQuestion.class);
}
else if (src instanceof TextQuestion) {
result = context.serialize(src, TextQuestion.class);
}
else if (src instanceof ChoiceQuestion) {
result = context.serialize(src, ChoiceQuestion.class);
}
return result;Десериализация - это немного хакерский процесс. В примере модульного теста он проверяет наличие контрольных атрибутов, чтобы решить, в какой класс десериализоваться. Если вы можете изменить источник сериализуемого объекта, вы можете добавить атрибут classType к каждому экземпляру, который содержит FQN имени класса экземпляра. Хотя это очень не объектно-ориентированный подход.
Google выпустила собственный RuntimeTypeAdapterFactory для обработки полиморфизма, но, к сожалению, он не является частью ядра gson (вы должны скопировать и вставить класс в свой проект).
Пример:
RuntimeTypeAdapterFactory<Animal> runtimeTypeAdapterFactory = RuntimeTypeAdapterFactory
.of(Animal.class, "type")
.registerSubtype(Dog.class, "dog")
.registerSubtype(Cat.class, "cat");
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(runtimeTypeAdapterFactory)
.create();Здесь я разместил полный рабочий пример с использованием моделей Animal, Dog и Cat.
Думаю, лучше положиться на этот адаптер, чем заново реализовывать его с нуля.
Прошло много времени, но я не мог найти действительно хорошего решения в Интернете ... Вот небольшой поворот в решении @ MarcusJuniusBrutus, который позволяет избежать бесконечной рекурсии.
Оставьте тот же десериализатор, но удалите сериализатор -
public class IAnimalAdapter implements JsonDeSerializer<IAnimal> {
private static final String CLASSNAME = "CLASSNAME";
private static final String INSTANCE = "INSTANCE";
@Override
public IAnimal deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
JsonObject jsonObject = json.getAsJsonObject();
JsonPrimitive prim = (JsonPrimitive) jsonObject.get(CLASSNAME);
String className = prim.getAsString();
Class<?> klass = null;
try {
klass = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new JsonParseException(e.getMessage());
}
return context.deserialize(jsonObject.get(INSTANCE), klass);
}
}Затем в исходном классе добавьте поле с расширением @SerializedName("CLASSNAME"). Хитрость заключается в том, чтобы инициализировать это в конструкторе базового класса , поэтому превратите ваш интерфейс в абстрактный класс.
public abstract class IAnimal {
@SerializedName("CLASSNAME")
public String className;
public IAnimal(...) {
...
className = this.getClass().getName();
}
}Причина, по которой здесь нет бесконечной рекурсии, заключается в том, что мы передаем фактический класс среды выполнения (т.е. Dog, а не IAnimal) context.deserialize. Это не вызовет наш адаптер типа, пока мы используем, registerTypeAdapterа неregisterTypeHierarchyAdapter
Я описываю решение для различных случаев применения и буду решение бесконечной рекурсии проблемы , а также
Случай 1: Вы контролируете классы , то есть, вы можете написать свои собственные Cat, Dogклассы, а такжеIAnimal интерфейс. Вы можете просто следовать решению, предоставленному @ marcus-junius-brutus (самый популярный ответ)
Бесконечной рекурсии не будет, если есть общий базовый интерфейс как IAnimal
Но что, если я не хочу реализовывать тот IAnimalили иной интерфейс?
Тогда @ marcus-junius-brutus (ответ с самым высоким рейтингом) вызовет бесконечную ошибку рекурсии. В этом случае мы можем сделать что-то вроде ниже.
Нам нужно будет создать конструктор копирования внутри базового класса и подкласса оболочки следующим образом:
.
// Base class(modified)
public class Cat implements IAnimal {
public String name;
public Cat(String name) {
super();
this.name = name;
}
// COPY CONSTRUCTOR
public Cat(Cat cat) {
this.name = cat.name;
}
@Override
public String sound() {
return name + " : \"meaow\"";
};
}
// The wrapper subclass for serialization
public class CatWrapper extends Cat{
public CatWrapper(String name) {
super(name);
}
public CatWrapper(Cat cat) {
super(cat);
}
}И сериализатор для типа Cat:
public class CatSerializer implements JsonSerializer<Cat> {
@Override
public JsonElement serialize(Cat src, Type typeOfSrc, JsonSerializationContext context) {
// Essentially the same as the type Cat
JsonElement catWrapped = context.serialize(new CatWrapper(src));
// Here, we can customize the generated JSON from the wrapper as we want.
// We can add a field, remove a field, etc.
return modifyJSON(catWrapped);
}
private JsonElement modifyJSON(JsonElement base){
// TODO: Modify something
return base;
}
}Итак, почему конструктор копирования?
Что ж, после того как вы определите конструктор копирования, независимо от того, насколько сильно изменится базовый класс, ваша оболочка продолжит выполнять ту же роль. Во-вторых, если мы не определяем конструктор копирования и просто подклассифицируем базовый класс, тогда нам придется «говорить» в терминах расширенного класса, т. Е.CatWrapper . Вполне возможно, что ваши компоненты говорят о базовом классе, а не о типе оболочки.
Есть ли простая альтернатива?
Конечно, теперь он был представлен Google - это RuntimeTypeAdapterFactoryреализация:
RuntimeTypeAdapterFactory<Animal> runtimeTypeAdapterFactory = RuntimeTypeAdapterFactory
.of(Animal.class, "type")
.registerSubtype(Dog.class, "dog")
.registerSubtype(Cat.class, "cat");
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(runtimeTypeAdapterFactory)
.create();Здесь вам нужно будет ввести поле с именем «type» in Animalи значение того же внутри, Dogчтобы быть «dog», Catчтобы быть «cat».
Полный пример: https://static.javadoc.io/org.danilopianini/gson-extras/0.2.1/com/google/gson/typeadapters/RuntimeTypeAdapterFactory.html
Случай 2: Вы не контролируете классы . Вы присоединяетесь к компании или используете библиотеку, в которой классы уже определены, и ваш менеджер не хочет, чтобы вы меняли их каким-либо образом - вы можете создать подклассы для своих классов и заставить их реализовать общий интерфейс маркера (который не имеет никаких методов ), например AnimalInterface.
Пример:
.
// The class we are NOT allowed to modify
public class Dog implements IAnimal {
public String name;
public int ferocity;
public Dog(String name, int ferocity) {
super();
this.name = name;
this.ferocity = ferocity;
}
@Override
public String sound() {
return name + " : \"bark\" (ferocity level:" + ferocity + ")";
}
}
// The marker interface
public interface AnimalInterface {
}
// The subclass for serialization
public class DogWrapper extends Dog implements AnimalInterface{
public DogWrapper(String name, int ferocity) {
super(name, ferocity);
}
}
// The subclass for serialization
public class CatWrapper extends Cat implements AnimalInterface{
public CatWrapper(String name) {
super(name);
}
}Итак, мы бы использовали CatWrapperвместо Cat, DogWrapperвместо Dogи
AlternativeAnimalAdapterвместоIAnimalAdapter
// The only difference between `IAnimalAdapter` and `AlternativeAnimalAdapter` is that of the interface, i.e, `AnimalInterface` instead of `IAnimal`
public class AlternativeAnimalAdapter implements JsonSerializer<AnimalInterface>, JsonDeserializer<AnimalInterface> {
private static final String CLASSNAME = "CLASSNAME";
private static final String INSTANCE = "INSTANCE";
@Override
public JsonElement serialize(AnimalInterface src, Type typeOfSrc,
JsonSerializationContext context) {
JsonObject retValue = new JsonObject();
String className = src.getClass().getName();
retValue.addProperty(CLASSNAME, className);
JsonElement elem = context.serialize(src);
retValue.add(INSTANCE, elem);
return retValue;
}
@Override
public AnimalInterface deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
JsonObject jsonObject = json.getAsJsonObject();
JsonPrimitive prim = (JsonPrimitive) jsonObject.get(CLASSNAME);
String className = prim.getAsString();
Class<?> klass = null;
try {
klass = Class.forName(className);
} catch (ClassNotFoundException e) {
e.printStackTrace();
throw new JsonParseException(e.getMessage());
}
return context.deserialize(jsonObject.get(INSTANCE), klass);
}
}Выполняем тест:
public class Test {
public static void main(String[] args) {
// Note that we are using the extended classes instead of the base ones
IAnimal animals[] = new IAnimal[]{new CatWrapper("Kitty"), new DogWrapper("Brutus", 5)};
Gson gsonExt = null;
{
GsonBuilder builder = new GsonBuilder();
builder.registerTypeAdapter(AnimalInterface.class, new AlternativeAnimalAdapter());
gsonExt = builder.create();
}
for (IAnimal animal : animals) {
String animalJson = gsonExt.toJson(animal, AnimalInterface.class);
System.out.println("serialized with the custom serializer:" + animalJson);
AnimalInterface animal2 = gsonExt.fromJson(animalJson, AnimalInterface.class);
}
}
}Вывод:
serialized with the custom serializer:{"CLASSNAME":"com.examples_so.CatWrapper","INSTANCE":{"name":"Kitty"}}
serialized with the custom serializer:{"CLASSNAME":"com.examples_so.DogWrapper","INSTANCE":{"name":"Brutus","ferocity":5}}Если вы хотите управлять TypeAdapter для типа и другим для его подтипа, вы можете использовать TypeAdapterFactory следующим образом:
public class InheritanceTypeAdapterFactory implements TypeAdapterFactory {
private Map<Class<?>, TypeAdapter<?>> adapters = new LinkedHashMap<>();
{
adapters.put(Animal.class, new AnimalTypeAdapter());
adapters.put(Dog.class, new DogTypeAdapter());
}
@SuppressWarnings("unchecked")
@Override
public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
TypeAdapter<T> typeAdapter = null;
Class<?> currentType = Object.class;
for (Class<?> type : adapters.keySet()) {
if (type.isAssignableFrom(typeToken.getRawType())) {
if (currentType.isAssignableFrom(type)) {
currentType = type;
typeAdapter = (TypeAdapter<T>)adapters.get(type);
}
}
}
return typeAdapter;
}
}Эта фабрика пришлет самый точный TypeAdapter
Если вы объедините ответ Маркуса Юниуса Брута с редактированием user2242263, вы можете избежать необходимости указывать большую иерархию классов в своем адаптере, определив свой адаптер как работающий с типом интерфейса. Затем вы можете предоставить реализации по умолчанию для toJSON () и fromJSON () в своем интерфейсе (который включает только эти два метода) и иметь каждый класс, который вам нужно для сериализации, для реализации вашего интерфейса. Чтобы иметь дело с приведением типов, в своих подклассах вы можете предоставить статический метод fromJSON (), который десериализует и выполняет соответствующее приведение из вашего типа интерфейса. Это отлично сработало для меня (просто будьте осторожны с сериализацией / десериализацией классов, содержащих хэш-карты - добавьте это, когда вы создаете экземпляр своего построителя gson:
GsonBuilder builder = new GsonBuilder().enableComplexMapKeySerialization();
Надеюсь, это поможет кому-то сэкономить время и силы!