Comment préserver les trames de la séquence d'Gson la sérialisation

Semble Gson.la méthode toJson(Object objet) génère du code JSON avec au hasard propagation des champs de l'objet. Est-il moyen de corriger les champs de l'ordre en quelque sorte?


    public class Foo {
            public String bar;
            public String baz;

            public Foo( String bar, String baz ) {
                    this.bar = bar;
                    this.baz = baz;
            }
    }

    Gson gson = new Gson();
    String jsonRequest = gson.toJson(new Foo("bar","baz"));

    //jsonRequest now can be { "bar":"bar", "baz":"baz" } (which is correct)
    //            and can be { "baz":"baz", "bar":"bar" } (which is a wrong sequence)

Grâce.

Pourquoi est-séquence pertinente? Cela indique un mauvais outil pour parser le JSON.
Je me demandais aussi pourquoi. Mais le serveur est un .NET application. Les auteurs de la demande disent qu'ils ont besoin le champ nommé "__type" (il pointe vers le schéma) pour être le premier parmi d'autres.
Wow. De toute façon, c'est possible avec un sérialiseur. J'ai posté une réponse.
J'aimerais présenter une pétition .NET app auteurs de jeter cette exigence et de mettre en œuvre plus robuste JSON traitement.
Si vous en avez l'occasion, vous pourrait également smack le .NET application des auteurs avec la spécification JSON, où, à propos de ce qu'est un objet JSON est, le dit clairement, "Un objet est une collection non ordonnée de zéro, une ou plusieurs paires nom/valeur..." [ietf.org/rfc/rfc4627.txt?number=4627] Donc, leur application de messagerie/l'API ne sont pas conformes à la spécification JSON. (Arguments comme cela a tendance à travailler particulièrement bien avec les amateurs de "enterprise architect" les gens.)
Je voulais un autre ordre des champs dans mon JSON, donc j'ai changé l'ordre des champs dans mon code source et ça a fait l'affaire pour moi. Peut-être, il peut aider d'autres personnes aussi bien. (GSON 2.6.2)
Peut-être que si vous voulez des métadonnées dans le début, vous voudriez que cette.
Une application qui analyse un grand document JSON comme un flux d'optimiser la consommation de mémoire si elle obtient les éléments dans l'ordre optimal. Le fait qu'une application ne peut pas compter sur l'ordre des champs ne signifie pas que le programmeur ne doit pas prendre un avantage si ils étaient dans l'ordre adéquat.
C'est pas ça le problème. Le principal problème est que la spécification JSON n'est nulle part besoin de commander des propriétés de l'objet. En d'autres termes, si vous essayez d'appuyer sur la commande ou propriétés de l'objet, puis, vous êtes essentiellement en essayant de s'appuyer sur quelque chose d'indéterminé. Et que fait le code fragiles et non portables. Juste utiliser des tableaux à la place. Leurs valeurs sont en papier doivent être dans l'ordre. Ensuite, vous pouvez supposer que n'importe quel outil qui massages chaînes JSON fonctionnera de la façon que vous attendez et vous pouvez bien sûr optimiser davantage sur ce point.
Veuillez lire ce que j'ai écrit.

InformationsquelleAutor Sergey Romanovsky | 2011-06-16

20

Si GSON ne prend pas en charge la définition de l'ordre des champs, il y a d'autres bibliothèques. Jackson permet definining ce avec @JsonPropertyOrder, par exemple. D'avoir à spécifier ses propres sérialiseur semble être beaucoup de travail pour moi.

Et oui, je suis d'accord sur le fait que comme par JSON spécification, l'application ne doit pas s'attendre classement spécifique des champs.
- C'est la seule chose dont j'avais besoin. Il devrait fonctionner de la meilleure dans ce cas (c'est à dire de simples objets de sérialisation avec un forçage une propriété d'être le premier pour .NET analyseur de l'autre côté). Merci @StaxMan.
- Je suis la sérialisation des Haricots en JSON à l'aide de Jackson pour la persistance et de tests. Modification du format fait qu'il est difficile d'écrire des assertions à l'encontre de la chaîne sérialisée. C'était juste la médecine pour faire mes tests travail =)
- vous ne devriez jamais jamais comparer la sortie JSON pour une Chaîne codée en dur, c'est juste des ennuis. En plus de la commande qui peut modifier les aspects de white-space ou s'échapper pouvez modifier, légalement, et sans changer la logique de contenu. Donc, soit la comparaison devrait appliquer canonicality quelconque (pas de standard spécifique pour le JSON pour autant que je sais), ou alors, il faut utiliser JSON modèle d'objet (meilleur choix). Jackson a JsonNode, et son equals() fonctionne bien pour les tests, par exemple; ignore la commande de propriétés, les valeurs sont unifiés.
- Alors que je suis d'accord avec votre déclaration pour la production de code, tests unitaires (et de certains tests d'intégration) je considère que c'est un moyen pratique et simple de la façon d'écrire des assertions.
- Ok oui, pour de simples tests qui pourraient suffire. Il est toujours bon d'être conscient des problèmes avec des choses comme la commande, mais au moins, avec des tests, on peut avoir le plein contrôle sur l'entrée afin d'éviter la plupart des problèmes.
InformationsquelleAutor StaxMan
29

Vous auriez besoin de créer un personnalisé sérialiseur JSON.

E. g.
```
public class FooJsonSerializer implements JsonSerializer<Foo> {

    @Override
    public JsonElement serialize(Foo foo, Type type, JsonSerializationContext context) {
        JsonObject object = new JsonObject();
        object.add("bar", context.serialize(foo.getBar());
        object.add("baz", context.serialize(foo.getBaz());
        //...
        return object;
    }

}
```
et de l'utiliser comme suit:
```
Gson gson = new GsonBuilder().registerTypeAdapter(Foo.class, new FooJsonSerializer()).create();
String json = gson.toJson(foo);
//...
```
Il maintient l'ordre que vous avez spécifié dans le sérialiseur.

Voir aussi:
- Gson Guide de l'Utilisateur - Custom sérialiseurs et deserializers
- Cette approche n'est malheureusement pas dans la documentation de la JsonObject.ajouter(String, JsonElement) méthode (ou dans la documentation de l'addProperty méthodes), mais c'est plutôt révélé dans la documentation de l'entrySet() la méthode! (Pour les intéressés: L'implémentation sous-jacente qui assure cette fonction stocke ajouté des éléments à l'aide d'une LinkedHashMap.)
- merci. Cependant dans mon cas, la solution devient trop lourd. Je préfère la préfère JsonWriter recommandé par @Programmeur Bruce. Et oui, honte sur .NET parser json.
- Trop lourd? Peut-être que vous êtes en train de faire quelque chose pour lequel il existe un moyen plus facile de le faire. Je préfère utiliser des deserializer sur l'aide de la JsonWriter directement dans presque toutes les situations. Pour le problème spécifique que vous avez décrit, je voudrais prendre BalusC la solution de quelques pas plus loin, pour le rendre plus générique et de faire de l'élément de commande externe configurable. Il pourrait ensuite être réutilisées pour les différents objets.
- C'est une excellente solution. Je voulais quelque chose comme ça, et cette solution m'a vraiment aidé. Merci S'Accoupler 🙂
- Grande réponse. +1 On peut enregistrer plusieurs cartes dans le GsonBuilder en fonction de la composition d'objet. GsonBuilder gson = new GsonBuilder(); gson.registerTypeAdapter(MyType2.class, new MyTypeAdapter()); gson.registerTypeAdapter(MyType.class, new MySerializer()); gson.registerTypeAdapter(MyType.class, new MyDeserializer()); gson.registerTypeAdapter(MyType.class, new MyInstanceCreator());
InformationsquelleAutor BalusC

Voici ma solution pour boucler sur json fichiers texte dans un répertoire donné et l'écriture sur le dessus d'eux avec triés versions:

private void standardizeFormat(File dir) throws IOException {
    File[] directoryListing = dir.listFiles();
    if (directoryListing != null) {
        for (File child : directoryListing) {
            String path = child.getPath();
            JsonReader jsonReader = new JsonReader(new FileReader(path));

            Gson gson = new GsonBuilder().setPrettyPrinting().registerTypeAdapter(LinkedTreeMap.class, new SortedJsonSerializer()).create();
            Object data = gson.fromJson(jsonReader, Object.class);
            JsonWriter jsonWriter = new JsonWriter(new FileWriter(path));
            jsonWriter.setIndent("  ");
            gson.toJson(data, Object.class, jsonWriter);
            jsonWriter.close();
        }
    }
}

private class SortedJsonSerializer implements JsonSerializer<LinkedTreeMap> {
    @Override
    public JsonElement serialize(LinkedTreeMap foo, Type type, JsonSerializationContext context) {
        JsonObject object = new JsonObject();
        TreeSet sorted = Sets.newTreeSet(foo.keySet());
        for (Object key : sorted) {
            object.add((String) key, context.serialize(foo.get(key)));
        }
        return object;
    }
}

C'est assez hacky car il repose sur le fait que Gson utilise LinkedTreeMap lorsque le Type est tout simplement un Objet. C'est un détails de mise en œuvre qui n'est pas garanti. De toute façon, il est assez bon pour ma courte durée à des fins...

Fonctionne vraiment bien! Aussi longtemps que Gson utilise en interne LinkedTreeMap ce serait très bien fonctionner.

InformationsquelleAutor matt burns

2

Fait Gson.la méthode toJson(Object objet) ne génère pas de champs dans un ordre aléatoire. L'ordre du entraîné json dépend littérale de la séquence des noms de champs.

J'ai eu le même problème et il a été résolu par littérale de l'ordre des noms des propriétés de la classe.

L'exemple de la question toujours retourner les éléments suivants jsonRequest:

{ "bar":"bar", "baz":"baz" }

Afin d'avoir un ordre spécifique, vous devez modifier les noms de champs, ex: si vous voulez baz pour être le premier dans l'ordre puis vient bar:
```
public class Foo {
    public String f1_baz;
    public String f2_bar;

    public Foo ( String f1_baz, String f2_bar ) {
        this.f1_baz = f1_baz;
        this.f2_bar = f2_bar;
    }
}
```
jsonRequest sera { "f1_baz ":"baz", "f2_bar":"bar" }
- soins à élaborer?
- la réponse a été modifié
- Merci, upvoted pour prendre l'effort pour l'améliorer. BTW, je me demande si le SerializedName annotation noms de modifier cet ordre.
InformationsquelleAutor YouQam

Vous devez vous connecter pour publier un commentaire.

Voir aussi: