La désérialisation Map<Object, Object> avec GSon

J'ai une Carte contenant un mélange de types, comme dans cet exemple simple

final Map<String, Object> map = new LinkedHashMap<String, Object>();
map.put("a", 1);
map.put("b", "a");
map.put("c", 2);
final Gson gson = new Gson();
final String string = gson.toJson(map);
final Type type = new TypeToken<LinkedHashMap<String, Object>>(){}.getType();
final Map<Object, Object> map2 = gson.fromJson(string, type);
for (final Entry<Object, Object> entry : map2.entrySet()) {
    System.out.println(entry.getKey() + " : " + entry.getValue());
}

Ce que je récupère sont plaine Objects, pas de Integers, pas de Strings. La sortie ressemble à

a : java.lang.Object@48d19bc8
b : java.lang.Object@394a8cd1
c : java.lang.Object@4d630ab9

Puis-je la corriger en quelque sorte? Je préfère attendre que de tels cas simples seront traitées correctement par défaut.

^{je sais que les informations sur le type ne peuvent pas toujours être préservée, et éventuellement 1 et "1" signifie exactement la même chose en JSON. Cependant, le retour de la plaine de contenu-moins d'objets tout simplement pas de sens pour moi.}

Mise à jour: La version sérialisée (c'est à dire la string ci-dessus) a l'air bien:

{"a":1,"b":"a","c":2}

Pourriez-vous regarder ce que le final String string ressemble? Je suis sûr qu'il pourrait aider à comprendre le problème.
J'ai juste rencontré ce ainsi... C'est pourquoi j'utilise mon JSONer... ça risque d'être un peu plus lent, mais beaucoup plus générique que Gson: nu-art-infrastructure.blogspot.co.il/2013/03/jsoner.html
J'ai suivi le "clair et statique de la structure de données" conseils à la place. Toutefois, la fabrication de Gson gérer cela devrait être assez trivial. Avez-vous soin de déposer un problème?
La chose terrible à ce sujet, que j'utilise GSON avec Android, et sur mon téléphone, il fonctionne bien, alors que sur les autres téléphones, il crée ce que vous avez décrit... Ma solution a été aussi clair et statique, mais dans le JSONer analyseur, vous pouvez utiliser des cartes et des listes imbriquées les objets complexes, et il est résolu au sein de l'annotation!
Soin de déposer une question à propos de quoi? ils savent à propos de cette question, n'est-ce pas?

OriginalL'auteur maaartinus | 2011-03-22

7

Gson n'est pas intelligent. Plutôt de fournir un clair et statique de la structure de données dans la saveur d'une classe Javabean de sorte que Gson comprend ce que le type des propriétés distinctes sont censés être désérialisé.

E. g.
```
public class Data {
    private Integer a;
    private String b;
    private Integer c;
    //...
}
```
en combinaison avec
```
Data data1 = new Data(1, "a", 2);
String json = gson.toJson(data1);
Data data2 = gson.fromJson(json, Data.class);
```
Mise à jour: selon les commentaires, le clavier ne semble pas être fixe (même si vous semblez être en mesure de le convertir manuellement par la suite sans connaître la structure à l'avance). Vous pouvez créer un personnalisé deserializer. Voici un rapide n'dirty exemple.
```
public class ObjectDeserializer implements JsonDeserializer<Object> {

    @Override
    public Object deserialize(JsonElement element, Type type, JsonDeserializationContext context) throws JsonParseException {
        String value = element.getAsString();
        try {
            return Long.valueOf(value);
        } catch (NumberFormatException e) {
            return value;
        }
    }

}
```
que vous utilisez comme suit:
```
final Gson gson = new GsonBuilder().registerTypeAdapter(Object.class, new ObjectDeserializer()).create();
//... 
```
Un Javabean est sûrement pas possible, tant que la clé n'est pas fixe. Comme une solution de contournement que je peux utiliser Map<String, String> et convertir les types manuellement (quelque chose comme ça), je me demande simplement pourquoi GSon qui se comporte étrangement.
La capacité de convertir les types manuellement suggère que vous connaissez la structure de données à l'avance. Donc l'argument que le clavier n'est pas fixe est un non-argument. Comme pour Gson, vous pourriez envisager une coutume deserializer qui détermine si la valeur est un nombre (regex, analyseur, Long#valueOf(), etc) et retourne Long ou String. Voir aussi sites.google.com/site/gson/...
J'ai mis à jour la réponse avec un exemple, vous pourriez trouver utile.
"Donc, l'argument que le clavier n'est pas fixe est un non-argument." - Cette "non-argument" rend le Javabean solution nulle. Mais merci pour la ObjectDeserializer exemple, elle travaille à nice.
En supposant une Carte est un Javabean, oui. 😉

OriginalL'auteur BalusC

Gson gson = new GsonBuilder()
    .registerTypeAdapter(Object.class, new JsonDeserializer<Object>() {
      @Override
      public Object deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        JsonPrimitive value = json.getAsJsonPrimitive();
        if (value.isBoolean()) {
          return value.getAsBoolean();
        } else if (value.isNumber()) {
          return value.getAsNumber();
        } else {
          return value.getAsString();
        }
      }
    }).create();

OriginalL'auteur Michael Lancaster

4

De mise à niveau pour Gson 2.1. Il imprime ceci:
```
a : 1.0
b : a
c : 2.0
```
OriginalL'auteur Jesse Wilson
-1

Vous de stocker les données dans une Carte. Il semble que vous besoin pour convertir l'objet pour le type dont vous avez besoin.

Pour sûr de ne pas, si le type a été String ou Integer, il ne pouvait pas sortie java.lang.Object@.... J'ai aussi vérifié à l'aide de getClass().

OriginalL'auteur John Kane
-1

Si vous voulez une chaîne JSON à partir de Map<Object, Object>, je pense que json-simple est le meilleur choix que Gson.

Ceci est un bref exemple de http://code.google.com/p/json-simple/wiki/EncodingExamples :
```
//import java.util.LinkedHashMap;
//import java.util.Map;
//import org.json.simple.JSONValue;

Map obj=new LinkedHashMap();
obj.put("name","foo");
obj.put("num",new Integer(100));
obj.put("balance",new Double(1000.21));
obj.put("is_vip",new Boolean(true));
obj.put("nickname",null);
String jsonText = JSONValue.toJSONString(obj);
System.out.print(jsonText);
```
Résultat: {"name":"foo","num":100,"balance":1000.21,"is_vip":true,"nickname":null}

Pour le décodage, reportez-vous à http://code.google.com/p/json-simple/wiki/DecodingExamples .

OriginalL'auteur philipjkim

Vous devez vous connecter pour publier un commentaire.