Comment gérer la désérialisation avec le polymorphisme?

J'ai une classe comme:

public class Barn {
    String type;
    Animal animal;
}

public class Horse extends Animal {
}

public class Cow extends Animal {
}

et je tiens à sérialiser une liste d'entre eux:

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

Quand je sérialiser, saisissez les informations seront perdues pour l'Animal attribut. Est-il une manière que je pourrais installer un analyseur auditeur en quelque sorte pour que je puisse fournir la bonne classe pour désérialiser que lorsque chaque élément de la liste est rencontrés? C'était l'idée derrière manuellement la fourniture d'une chaîne de caractères décrivant le type de classe.

Grâce

InformationsquelleAutor user1219278 | 2013-04-01

gson java

Dans le Gson projet de code de base est le RuntimeTypeAdapter, qui apparemment fonctionne bien pour les polymorphes de la sérialisation et la désérialisation. Je ne pense pas que je n'ai pas encore essayé de l'utiliser. Voir http://code.google.com/p/google-gson/issues/detail?id=231 pour plus d'info. Remarque, il n'a pas encore été inclus dans le Gson versions.

Si elle ne correspond pas à vos besoins, puis personnaliser la désérialisation de traitement est nécessaire. La suite est une telle approche, en supposant que vous voulez utiliser la structure JSON démontré. (Je voudrais prendre une approche quelque peu différente, si la structure JSON peut être différent.)

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

Ce code pourrait-il fonctionner si les sous-types (le cheval, la vache) sont dans les différents projets Maven de la Grange? J'ai une dépendance circulaire avec Jackson désérialisation et essayer de trouver une solution

InformationsquelleAutor Programmer Bruce

Vous pouvez utiliser Gson Feu pour cela. Le code devrait ressembler à quelque chose comme ceci:

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

InformationsquelleAutor julman99

Vous n'avez pas besoin d'écrire votre propre Adaptateur.

Enfin gson a son propre RuntimeTypeAdapterFactory de gérer java polymorphisme, mais malheureusement, il ne fait pas partie de la gson bibliothèque de base (pour l'utiliser, vous devez copier et coller le classe dans votre projet).

Supposons que vous avez cette Animal.class:

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

Et Horse.class:

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

Vous pouvez initialiser le RuntimeTypeAdapterFactory à l'aide du code ci-dessous:

RuntimeTypeAdapterFactory<Animal> runtimeTypeAdapterFactory = RuntimeTypeAdapterFactory
.of(Animal.class, "type")
.registerSubtype(Horse.class, "horse")
.registerSubtype(Cow.class, "cow");
Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(runtimeTypeAdapterFactory)
.create();

Ici vous pouvez trouver plein d'exemple.

InformationsquelleAutor db80

0

Je suis aussi intéressé par la fonctionnalité et j'ai ajouté une demande de fonctionnalité pour GSon

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

InformationsquelleAutor Daniele Segato

Vous devez vous connecter pour publier un commentaire.