L'utilisation des Enums lors de l'analyse de JSON avec GSON

Cela est lié à une précédente question que j'ai posée ici plus tôt

Je suis en train d'analyser le même JSON, mais maintenant, j'ai changé mes classes un peu.

{
    "lower": 20,
    "upper": 40,
    "delimiter": " ",
    "scope": ["${title}"]
}

Ma classe ressemble maintenant à:

public class TruncateElement {

   private int lower;
   private int upper;
   private String delimiter;
   private List<AttributeScope> scope;

   //getters and setters
}


public enum AttributeScope {

    TITLE("${title}"),
    DESCRIPTION("${description}"),

    private String scope;

    AttributeScope(String scope) {
        this.scope = scope;
    }

    public String getScope() {
        return this.scope;
    }
}

Ce code génère une exception,

com.google.gson.JsonParseException: The JsonDeserializer EnumTypeAdapter failed to deserialized json object "${title}" given the type class com.amazon.seo.attribute.template.parse.data.AttributeScope
at

L'exception est compréhensible, parce que par la solution à ma question précédente, GSON attend l'énumération des objets à être créé en tant que

${title}("${title}"),
${description}("${description}");

Mais puisque c'est impossible du point de vue syntaxique, quelles sont les solutions recommandées, des solutions de contournement?

InformationsquelleAutor Sachin Kulkarni | 2011-11-21

De la documentation de Gson:

Gson fournit par défaut de la sérialisation et la désérialisation pour les Enums... Si vous préférez modifier la représentation par défaut, vous pouvez le faire par l'enregistrement d'un type de carte à travers GsonBuilder.registerTypeAdapter(Type, de l'Objet).

Qui suit est une telle approche.

import java.io.FileReader;
import java.lang.reflect.Type;
import java.util.List;
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.JsonParseException;
public class GsonFoo
{
public static void main(String[] args) throws Exception
{
GsonBuilder gsonBuilder = new GsonBuilder();
gsonBuilder.registerTypeAdapter(AttributeScope.class, new AttributeScopeDeserializer());
Gson gson = gsonBuilder.create();
TruncateElement element = gson.fromJson(new FileReader("input.json"), TruncateElement.class);
System.out.println(element.lower);
System.out.println(element.upper);
System.out.println(element.delimiter);
System.out.println(element.scope.get(0));
}
}
class AttributeScopeDeserializer implements JsonDeserializer<AttributeScope>
{
@Override
public AttributeScope deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
throws JsonParseException
{
AttributeScope[] scopes = AttributeScope.values();
for (AttributeScope scope : scopes)
{
if (scope.scope.equals(json.getAsString()))
return scope;
}
return null;
}
}
class TruncateElement
{
int lower;
int upper;
String delimiter;
List<AttributeScope> scope;
}
enum AttributeScope
{
TITLE("${title}"), DESCRIPTION("${description}");
String scope;
AttributeScope(String scope)
{
this.scope = scope;
}
}

InformationsquelleAutor Programmer Bruce

285

Je veux développer un peu plus NAZIK/user2724653 réponse (pour mon cas). Voici un code Java:
```
public class Item {
@SerializedName("status")
private Status currentState = null;
//other fields, getters, setters, constructor and other code...
public enum Status {
@SerializedName("0")
BUY,
@SerializedName("1")
DOWNLOAD,
@SerializedName("2")
DOWNLOADING,
@SerializedName("3")
OPEN
}
}
```
dans le fichier json vous avez juste un champ "status": "N",, où N=0,1,2,3 - de s'appuyer sur les valeurs de Statut. Donc, c'est tout, GSON fonctionne très bien avec les valeurs de la imbriquée enum classe. Dans mon cas, j'ai analysé une liste de Items de json tableau:
```
List<Item> items = new Gson().<List<Item>>fromJson(json,
new TypeToken<List<Item>>(){}.getType());
```
- Cette réponse résout tout parfaitement, pas besoin de cartes de type!
- Quand je fais cela, avec la Rénovation/Gson, le SerializedName de valeurs enum a des guillemets ajoutés. Le serveur reçoit réellement "1", par exemple, au lieu de simplement 1...
- Ce qui va se passer, si json avec le statut 5 va arriver? Est-il possible de définir la valeur par défaut?
- Si la valeur de JSON ne correspond à aucun SerializedName puis l'enum par défaut null. Comportement par défaut de l'inconnu de l'état pourraient être traitées dans une classe wrapper. Si vous avez toutefois besoin d'une représentation de "inconnu" autres que null alors vous aurez besoin d'écrire une coutume deserializer ou le type de carte.
InformationsquelleAutor validcat

Utiliser les annotations @SerializedName:

@SerializedName("${title}")
TITLE,
@SerializedName("${description}")
DESCRIPTION

InformationsquelleAutor Inc

Avec GSON version 2.2.2 enum sera maintenue en ordre et unmarshalled facilement.

import com.google.gson.annotations.SerializedName;
enum AttributeScope
{
@SerializedName("${title}")
TITLE("${title}"),
@SerializedName("${description}")
DESCRIPTION("${description}");
private String scope;
AttributeScope(String scope)
{
this.scope = scope;
}
public String getScope() {
return scope;
}
}

InformationsquelleAutor user2601995

L'extrait de code suivant supprime le besoin explicite Gson.registerTypeAdapter(...), à l'aide de la @JsonAdapter(class) annotation, disponible depuis Gson 2.3 (voir le commentaire pm_labs).

@JsonAdapter(Level.Serializer.class)
public enum Level {
WTF(0),
ERROR(1),
WARNING(2),
INFO(3),
DEBUG(4),
VERBOSE(5);
int levelCode;
Level(int levelCode) {
this.levelCode = levelCode;
}
static Level getLevelByCode(int levelCode) {
for (Level level : values())
if (level.levelCode == levelCode) return level;
return INFO;
}
static class Serializer implements JsonSerializer<Level>, JsonDeserializer<Level> {
@Override
public JsonElement serialize(Level src, Type typeOfSrc, JsonSerializationContext context) {
return context.serialize(src.levelCode);
}
@Override
public Level deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) {
try {
return getLevelByCode(json.getAsNumber().intValue());
} catch (JsonParseException e) {
return INFO;
}
}
}
}

Veuillez noter que cette annotation est disponible uniquement à partir de la version 2.3: google.github.io/gson/apidocs/index.le html?/com / google/gson/...
soyez prudent pour ajouter votre sérialiseur/deserializer-classes pour votre proguard config, car ils peuvent être supprimés (c'est arrivé pour moi)

InformationsquelleAutor Wout

Si vous voulez vraiment utiliser les Enum valeur ordinale vous pouvez enregistrer un type de carte à l'usine pour remplacer Gson par défaut de l'usine.

public class EnumTypeAdapter <T extends Enum<T>> extends TypeAdapter<T> {
private final Map<Integer, T> nameToConstant = new HashMap<>();
private final Map<T, Integer> constantToName = new HashMap<>();
public EnumTypeAdapter(Class<T> classOfT) {
for (T constant : classOfT.getEnumConstants()) {
Integer name = constant.ordinal();
nameToConstant.put(name, constant);
constantToName.put(constant, name);
}
}
@Override public T read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
return nameToConstant.get(in.nextInt());
}
@Override public void write(JsonWriter out, T value) throws IOException {
out.value(value == null ? null : constantToName.get(value));
}
public static final TypeAdapterFactory ENUM_FACTORY = new TypeAdapterFactory() {
@SuppressWarnings({"rawtypes", "unchecked"})
@Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
Class<? super T> rawType = typeToken.getRawType();
if (!Enum.class.isAssignableFrom(rawType) || rawType == Enum.class) {
return null;
}
if (!rawType.isEnum()) {
rawType = rawType.getSuperclass(); //handle anonymous subclasses
}
return (TypeAdapter<T>) new EnumTypeAdapter(rawType);
}
};
}

Ensuite, il suffit de s'inscrire à l'usine.

Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(EnumTypeAdapter.ENUM_FACTORY)
.create();

InformationsquelleAutor Tom Bollwitt

0

utiliser cette méthode
```
GsonBuilder.enableComplexMapKeySerialization();
```
- Alors que ce code peut répondre à la question, en fournissant plus de contexte sur comment et/ou pourquoi il résout le problème serait d'améliorer la réponse à long terme de valeur.
- comme de gson 2.8.5 cela est nécessaire afin d'utiliser SerializedName annotations sur les énumérations que vous souhaitez utiliser en tant que clés
InformationsquelleAutor Ahamadullah Saikat

Vous devez vous connecter pour publier un commentaire.