Gson, JSON et les subtilités de LinkedTreeMap

J'ai récemment commencé à jouer avec les JSON cordes, et a dit que Google est propre bibliothèque, Gson, est la nouvelle et de la hanche façon de composer avec ces.

La façon dont je l'ai compris, c'est qu'un JSON chaîne est essentiellement une carte. Où chaque variable de points de valeur dans la chaîne.

Par exemple:

String jsonInput2 = "{\"created_at\":\"Sat Feb 08 15:37:37 +0000 2014\",\"id\":432176397474623489\"}

Jusqu'ici, tout va bien. Des informations telles que lorsque cette JSON chaîne a été créé, peut être affectée à une variable avec le code suivant:

Gson gson = new Gson();

Map<String, String> map = new HashMap<String, String>();

map = (Map<String, String>) gson.fromJson(jsonInput, map.getClass());

String createdAt = map.get("created_at");

C'est presque artistique dans la beauté simple. Mais c'est là où la beauté se termine et ma confusion commence.

Le suivant est une extension de la ci-dessus JSON chaîne;

String jsonInput2 = "{\"created_at\":\"Sat Feb 08 15:37:37 +0000 2014\",\"id\":432176397474623489\",\"user\":{\"id_str\":\"366301747\",\"name\":\"somethingClever\",\"screen_name\":\"somethingCoolAndClever\"}}";

Ma question est de savoir comment ces "parenthèses dans les parenthèses" de travail pour le user section de la JSON?

Comment ai-je pu affecter les valeurs spécifiées dans ces intérieurs de supports à des variables?

Quelqu'un peut-il m'expliquer ou me montrer dans le code, comment Gson poignées des trucs comme ça, et comment je peux l'utiliser?

En bref, pourquoi ne...

String jsonInput = "{\"created_at\":\"Sat Feb 08 15:37:37 +0000 2014\",\"id\":432176397474623489\",\"user\":{\"id_str\":\"366301747\",\"name\":\"somethingClever\",\"screen_name\":\"somethingCoolAndClever\"}}";

Gson gson = new Gson();

Map<String, String> map = new HashMap<String, String>();

map = (Map<String, String>) gson.fromJson(jsonInput, map.getClass());

String name = map.get("name");

System.out.println(name);

... imprimer null?

OriginalL'auteur ViRALiC | 2014-03-09

31

Oublier Java. Vous devez d'abord comprendre le Format JSON. C'est, fondamentalement, il s'
```
object
    {}
    { members }
members
    pair
    pair , members
pair
    string : value
array
    []
    [ elements ]
elements
    value 
    value , elements
value
    string
    number
    object
    array
    true
    false
    null
```
Votre deuxième JSON String (qui a un manque ") est la suivante (utilisation jsonlint.com de format)
```
{
    "created_at": "Sat Feb 08 15:37:37 +0000 2014",
    "id": "432176397474623489",
    "user": {
        "id_str": "366301747",
        "name": "somethingClever",
        "screen_name": "somethingCoolAndClever"
    }
}
```
Le JSON est un objet, extérieur {}, qui contient trois paires, created_at qui est une chaîne JSON, id qui est aussi une chaîne JSON, et user qui est un objet JSON. Que l'objet JSON contient plus de trois paires qui sont toutes les chaînes JSON.

Vous avez demandé

Comment ai-je pu affecter les valeurs spécifiées à l'intérieur de ces intérieur de parenthèses pour
les variables?

Plus avancé parsing JSON/génération de bibliothèques sont destinés à convertir en JSON pour Pojo et à l'arrière.

Alors vous pouvez mapper vos format JSON pour les classes Java.
```
class Pojo {
    @SerializedName("created_at")
    private String createdAt;
    private String id;
    private User user;
}

class User {
    @SerializedName("id_str")
    private String idStr;
    private String name;
    @SerializedName("screen_name")
    private String screenName;
}

//with appropriate getters, setters, and a toString() method
```
Note le @SerializedName de sorte que vous pouvez garder à l'aide de conventions de nommage Java pour votre champs.

Vous pouvez maintenant désérialiser votre JSON
```
Gson gson = new Gson();
Pojo pojo = gson.fromJson(jsonInput2, Pojo.class);
System.out.println(pojo);
```
serait d'imprimer
```
Pojo [createdAt=Sat Feb 08 15:37:37 +0000 2014, id=432176397474623489", user=User [idStr=366301747, name=somethingClever, screenName=somethingCoolAndClever]]
```
montrant que tous les champs ont été correctement définies.

Quelqu'un peut-il m'expliquer ou me montrer dans le code, comment Gson poignées des trucs comme ça, et comment je peux l'utiliser?

Le code source de Gson est disponible gratuitement. Vous pouvez le trouver en ligne. Il est complexe et source code explication n'aurait pas sa place ici. Tout simplement, il utilise le Class objet que vous fournissez afin de déterminer comment il sera la carte au format JSON paires. Il ressemble à la classe correspondante. Si ces champs sont d'autres classes, puis il se reproduit jusqu'à ce qu'il a construit un plan de tout ce qu'il faut pour désérialiser.

En bref, pourquoi ne...imprimer null?

Parce que la racine de votre objet JSON, n'ont pas de paire avec le nom name. Au lieu d'utiliser Map, utilisez Gson de JsonObject type.
```
JsonObject jsonObject = new Gson().fromJson(jsonInput2, JsonObject.class);

String name = jsonObject.get("user")       //get the 'user' JsonElement
                        .getAsJsonObject() //get it as a JsonObject
                        .get("name")       //get the nested 'name' JsonElement
                        .getAsString();    //get it as a String
System.out.println(name);
```
qui imprime
```
somethingClever
```
La méthode ci-dessus, une classe pourrait avoir jeté un certain nombre d'exceptions si elles n'étaient pas du bon type. Si, par exemple, nous avions fait
```
String name = jsonObject.get("user")       //get the 'user' JsonElement
                        .getAsJsonArray()  //get it as a JsonArray
```
il échoue parce qu' user n'est pas un tableau JSON. Plus précisément, elle devrait jeter
```
Exception in thread "main" java.lang.IllegalStateException: This is not a JSON Array.
    at com.google.gson.JsonElement.getAsJsonArray(JsonElement.java:106)
    at com.spring.Example.main(Example.java:19)
```
De sorte que le JsonElement classe (qui est la classe mère de JsonObject, JsonArray, et quelques autres) fournit des méthodes pour vérifier ce qu'il en est. Voir la javadoc.

Le meilleur et le plus facile de comprendre la réponse. Merci Sotirios!
Vous êtes les bienvenus. Mon meilleur conseil est d'être à l'aise avec JSON avant de vous regardez dans les Gson.
Je vais certainement lire. Je vous remercie encore.

OriginalL'auteur Sotirios Delimanolis
4

La chaîne JSON a la structure suivante:
```
{
    created_at: "",
    id: "",
    user: {
            id_str: "",
            name: "",
            screen_name: ""
    }
 }
```
Quand vous mettez les valeurs de la carte à l'aide du code:
```
Map<String, Object> map = new HashMap<String, Object>();
map = (Map<String, Object>) gson.fromJson(jsonInput, map.getClass());
```
Il a des valeurs de clés suivantes:
```
created_at
id
user
```
et c'est pourquoi vous êtes en mesure d'utiliser map.get("created_at").

Maintenant, puisque vous voulez obtenir le nom de l'utilisateur, vous devez obtenir la carte de l'utilisateur:
```
LinkedTreeMap<String, Object> userMap = (LinkedTreeMap<String, Object>) map.get("user");
```
Dans le userMap, vous obtenez les valeurs de clés suivantes:
```
id_str
name
screen_name
```
Maintenant, vous pouvez obtenir le name de la user
```
String name = userMap.get("name");
```
Cette gson.fromJson(map.get("user") échouera. map.getUser("user") renvoie une LinkedTreeMap.
Merci! Mon erreur - mise à jour de la réponse

OriginalL'auteur AKS
3

Pour les gens qui viennent ici pour trouver un moyen de convertir LinkedTreeMap de l'objet:
```
MyClass object = new Gson().fromJson(new Gson().toJson(((LinkedTreeMap<String, Object>) theLinkedTreeMapObject)), MyClass .class)
```
Cela a été utile pour moi quand j'en avais besoin pour analyser un objet générique comme:
```
Class fullObject {
  private String name;
  private String objectType;
  private Object objectFull;   
}
```
Mais je ne sais pas l'objet sur lequel le serveur va envoyer. Le objectFull deviendra un LinkedTreeMap

OriginalL'auteur sagits
1

user est un JsonObject lui-même:
```
JsonObject user = map.get("user");
```
Il pourrait être, mais cela ne fonctionne pas comme map est déclarée comme Map<String, String>.
La droite! Édité...
Non, dans ce cas, il sera par défaut à LinkedTreeMap. Gson ne sais pas à propos de JsonObject sauf si vous lui dites.

OriginalL'auteur Smutje
0

Ok. Tout d'abord JSON est l'abréviation de "JavaScript Object Notation" de sorte que votre affirmation selon laquelle "une chaîne JSON est essentiellement une carte" est incorrecte. Un JSON bloc est un graphe d'objets, décrits à l'aide du langage JavaScript syntaxe. Depuis votre tente de contraindre un objet graphique d'une Carte de la Chaîne, Sting kay paires de valeur, ce n'est que d'aller travailler dans les cas où aucune donnée JSON en objet graphique est essentiellement juste que (donc pas très souvent). Une stratégie plus efficace serait probablement gson.fromJson() qui va convertir votre JSON à un objet Java graphique.

OriginalL'auteur Mikkel Løkke

Vous devez vous connecter pour publier un commentaire.