Gson Parser Json avec un tableau avec les différents types d'objets

Comment puis-je analyser ce JSON à l'aide de Gson?
J'ai un tableau avec plusieurs types d'objet et je ne sais pas quel type d'objet que j'ai besoin de créer pour enregistrer cette structure. Je ne peux pas changer le json message (je n'ai pas de contrôle sur le serveur).

La seule classe de fonction (en quelque sorte) a ce

public class Response {
    private List<Object> tr;
    private int results;

    (...)

}

JSON Message (Note du tableau avec plusieurs types d'objets.)

{
   "tr":
   [
       {
           "a":
           {
               "userId": "112"
           }
       },
       {
           "b":
           {
               "userId": "123",
               "address":"street dummy" 
           }
       },
       {
           "a":
           {
               "userId": "154"
           }
       }
   ],
"results":3
}

OriginalL'auteur Laranjeiro | 2013-02-05

18

La Gson Guide de l'Utilisateur couvre explicitement ceci:

https://sites.google.com/site/gson/gson-user-guide#TOC-Serializing-and-Deserializing-Collection-with-Objects-of-Arbitrary-Types

Vous avez un objet avec un champ tr qui est un tableau contenant des types arbitraires.

Le guide de l'utilisateur explique que vous ne pouvez pas directement désérialiser une telle structure, et recomends:

Utilisation Gson de l'analyseur (API bas niveau en streaming parser DOM parser
JsonParser) pour analyser les éléments d'un tableau et ensuite utiliser Gson.fromJson()
sur chacun des éléments du tableau. C'est l'approche privilégiée.

Dans votre cas ... il serait vraiment dépendre de ce que les objets étaient possibles dans ce tableau. Si ils vont tous avoir le même intérieur de l'objet que vous aimeriez faire quelque chose comme...
```
List<MyUserPojo> list = new ArrayList<MyUserPojo>();
JsonArray array = parser.parse(json).getAsJsonObject().getAsJsonArray("tr");
for (JsonElement je : array)
{
    Set<Map.Entry<String,JsonElement>> set = je.getAsObject().entrySet();
    JsonElement je2 = set.iterator().next().getValue();

    MyUserPojo mup = new Gson().fromJson(je2, MyUserPojo.class);
    list.add(mup);
}
```
Et bien sûr, cela devra être à l'intérieur d'une coutume deserializer pour votre objet réel qui aurait tr et results champs.
```
class MyPojo
{
    List<MyUserPojo> userList;
    int results; 
}

class MyUserPojo
{
    String userId;
    String address;
}

class MyDeserializer implements JsonDeserializer<MyPojo>
{
    @Override
    public MyPojo deserialize(JsonElement je, Type type, JsonDeserializationContext jdc)
                              throws JsonParseException
    {
        List<MyUserPojo> list = new ArrayList<MyUserPojo>();
        JsonArray array = je.getAsJsonObject().getAsJsonArray("tr");
        for (JsonElement je2 : array)
        {
            Set<Map.Entry<String,JsonElement>> set = je2.getAsObject().entrySet();
            JsonElement je3 = set.iterator().next().getValue();                 

            MyUserPojo mup = new Gson().fromJson(je3, MyUserPojo.class);
            list.add(mup);
        }

        MyPojo mp = new MyPojo();
        mp.tr = list;
        mp.results = je.getAsObject().getAsJsonPrimitive("results").getAsInt();

        return mp;
    }
}
```
Maintenant vous êtes tous ensemble - vous pouvez l'utiliser deserializer et créer votre objet:
```
Gson gson = new GsonBuilder()
                .registerTypeAdapter(MyPojo.class, new MyDeserializer())
                .build();

MyPojo mp = gson.fromJson(json, MyPojo.class);
```
Si le a, b etc sont importants ... eh bien, vous aurez à comprendre. Mais le ci-dessus devrait vous bien sur votre chemin à la compréhension de ce qui va être nécessaire pour faire face à votre structure JSON.

Par souci d'exhaustivité, le seul "hacky" moyen de contourner cela est si il y a un nombre assez limité de ces types de l'intérieur de l'objet est aussi assez limité en termes de ses champs. Vous pouvez créer un POJO qui englobe toutes les possibilités:
```
class MyPojo 
{
    MySecondPojo a;
    MySecondPojo b;
    ...
    MySecondPojo f;
}

class MySecondPojo
{
    String userId;
    String address;
    ...
    String someOtherField;
}
```
Quand Gson désérialise JSON il sera mis en manque des champs dans votre POJO(s) à null. Vous pouvez maintenant avoir tr être un List ou un tableau de ces dans votre POJO. Et de souligner, c'est vraiment très hacky et la mauvaise façon de le faire, mais j'ai pensé que je voudrais vous expliquer ce qui serait nécessaire pour analyser directement de ce tableau.

Presque une heure plus tard, vous construire une belle deserializer. Du bon travail, mais à mon humble avis une mauvaise pratique de downvote toutes les autres réponses juste parce que vous pouvez faire mieux. À mon humble avis une raison pour un downvote, mais c'est trop stupide pour déchets rep pour quelque chose comme ça.
Mec, de quoi parles-tu? J'ai reçu l'e-mail d'alimentation de ces derniers et d'y répondre au déjeuner. Je viens de réaliser qu'il était en fait plus de douleur que d'abord regardé, mais à la fin ... oui, cela fonctionne.

OriginalL'auteur Brian Roach

Je chercher quelque chose de chaque réponse et il l'a fait de cette façon:

Réponse Objet

public class Response {
    private List<Users> tr;
    private int results;

    (...)
}

Générique Utilisateur

public class User {
    public static final int TYPE_USER_A =0;
    public static final int TYPE_USER_B =1;
    private String userId;
    private int type;
    (...)
}

public class a extends User {
    private String location;
    (...) 
}

public class b extends User { 
    private String adress;   
    (...)
}

L'Analyse De La Méthode

private Response buildResponseObject(String response) {
        Response tls = new Response();
        List<Users> users = new ArrayList<users>();
        User u;

        try {
            JSONObject object = new JSONObject(response);
            tls.setResults(object.getInt("results"));
            JSONArray array = object.getJSONArray("tr");

            for (int i = 0; i < array.length(); i++) {
                JSONObject trs = array.getJSONObject(i);

                if (trs.has("a")) {
                    String json = trns.getString("a");
                    A a = new Gson().fromJson(json,A.class);
                    a.setType(User.TYPE_USER_A);
                    users.add(a);

                } else if (trs.has("b")) {
                    String json = trs.getString("b");
                    B b= new Gson().fromJson(json,B.class);
                    B.setType(User.TYPE_USER_B);
                    users.add(b);
                }
            }

            tls.setUsers(users);

        } catch (JSONException e) {
            //TODO Auto-generated catch block
            e.printStackTrace();
        }
        return tls;
    }

Ce n'est pas aussi élégant comme je le voulais et mélanger natif JsonObjects avec Gson méthodes mais qui fonctionne pour moi.

OriginalL'auteur Laranjeiro

Essayer ce code ici:

public class Address {
    public String userId;
    public String address;
    //...
}

public class Response {
    private HashMap<String, Address> tr;
    private int results;
    //...
}

Utilisation:

String json = "{\n  \"tr\":\n  {\n    \"a\": {\n       \"userId\": \"112\"\n    },\n    \"b\": {\n       \"userId\": \"123\",\n       \"address\":\"street dummy\"\n    },\n    \"c\": {\n       \"userId\": \"154\"\n    }\n  },\n  \"results\":3\n}";

Response users = new Gson().fromJson(json, Response.class);

Comme vous pouvez le voir j'ai besoin de modifier la structure:

{
  "tr":
  {
    "a": {
       "userId": "112"
    },
    "b": {
       "userId": "123",
       "address":"street dummy"
    },
    "c": {
       "userId": "154"
    }
  },
  "results":3
}

Mais malheureusement je n'ai pas réussi à permettre à plusieurs clés. Droit maintenant, je n'ai aucune idée de comment résoudre ce problème.

Il donne une erreur lors de l'analyse. Cela peut être une erreur de mon code mais de toute façon, ne serait pas le deuxième "a" effacer le premier objet parce qu'ils ont la même clé?
Après avoir écrit ma réponse, j'ai demandé à moi-même. Je pense que la classe doit être remplacée par quelque chose d'autre. Je vais rechercher une alternative. Qu'est-ce que votre exception?
Peut-être un Hashtable peut slove le problème. Je vais écrire un scénario de test.
Veuillez consulter ma réponse.
Je ne peux pas changer le JSON message.

OriginalL'auteur rekire

0

Je pense que ce lien peut vous aider à:
https://sites.google.com/site/gson/gson-user-guide#TOC-Collections-Examples

Fondamentalement, créer une classe pour votre "objet" (type d'utilisateur, je suppose), puis utilisez la désérialisation code de Gson, comme ceci:
```
Type collectionType = new TypeToken<Collection<User>>(){}.getType();
Collection<User> users= gson.fromJson(json, collectionType);
```
OriginalL'auteur Aerilys
-2

Vous pouvez créer des classes java correspondantes pour les objets json. L'entier, chaîne de valeurs peut être mappé comme est. Json peut être analysé comme celui-
```
Gson gson = new GsonBuilder().create();
Response r = gson.fromJson(jsonString, Response.class);
```
Voici un exemple- http://rowsandcolumns.blogspot.com/2013/02/url-encode-http-get-solr-request-and.html

OriginalL'auteur Harpreet

Vous devez vous connecter pour publier un commentaire.