Analyse du tableau JSON dans java.util.List avec Gson

J'ai un JsonObjectnommé "mapping"avec le contenu suivant:

{
    "client": "127.0.0.1",
    "servers": [
        "8.8.8.8",
        "8.8.4.4",
        "156.154.70.1",
        "156.154.71.1"
    ]
}

Je sais que je peux obtenir le tableau "servers"avec:

mapping.get("servers").getAsJsonArray()

Et maintenant, je veux analyser cela JsonArrayen un java.util.List...

Quelle est la manière la plus simple de faire ça?

Le moyen le plus simple de le faire est d'utiliser la fonction d'analyse par défaut de Gson fromJson() .

Il existe une implémentation de cette fonction adaptée lorsque vous devez désérialiser en any ParameterizedType(par exemple, any List), ce qui est fromJson(JsonElement json, Type typeOfT).

Dans votre cas, il vous suffit d'obtenir le Typeof a List<String>, puis d'analyser le tableau JSON en cela Type, comme ceci:

import java.lang.reflect.Type;
import com.google.gson.reflect.TypeToken;

JsonElement yourJson = mapping.get("servers");
Type listType = new TypeToken<List<String>>() {}.getType();

List<String> yourList = new Gson().fromJson(yourJson, listType);

Dans votre cas, yourJsonc'est a JsonElement, mais cela peut aussi être a String, any Readerou a JsonReader.

Vous voudrez peut-être consulter la documentation de l'API Gson .

Le code ci-dessous utilise com.google.gson.JsonArray. J'ai imprimé le nombre d'éléments dans la liste ainsi que les éléments dans la liste

import java.util.ArrayList;

import com.google.gson.Gson;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;


public class Test {

    static String str = "{ "+ 
            "\"client\":\"127.0.0.1\"," + 
            "\"servers\":[" + 
            "    \"8.8.8.8\"," + 
            "    \"8.8.4.4\"," + 
            "    \"156.154.70.1\"," + 
            "    \"156.154.71.1\" " + 
            "    ]" + 
            "}";

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {

            JsonParser jsonParser = new JsonParser();
            JsonObject jo = (JsonObject)jsonParser.parse(str);
            JsonArray jsonArr = jo.getAsJsonArray("servers");
            //jsonArr.
            Gson googleJson = new Gson();
            ArrayList jsonObjList = googleJson.fromJson(jsonArr, ArrayList.class);
            System.out.println("List size is : "+jsonObjList.size());
                    System.out.println("List Elements are  : "+jsonObjList.toString());


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

PRODUCTION

List size is : 4

List Elements are  : [8.8.8.8, 8.8.4.4, 156.154.70.1, 156.154.71.1]

J'ai lu la solution sur le site officiel de Gson ici

Et ce code pour vous:

    String json = "{"client":"127.0.0.1","servers":["8.8.8.8","8.8.4.4","156.154.70.1","156.154.71.1"]}";

    JsonObject jsonObject = new Gson().fromJson(json, JsonObject.class);
    JsonArray jsonArray = jsonObject.getAsJsonArray("servers");

    String[] arrName = new Gson().fromJson(jsonArray, String[].class);

    List<String> lstName = new ArrayList<>();
    lstName = Arrays.asList(arrName);

    for (String str : lstName) {
        System.out.println(str);
    }    

Affichage des résultats sur le moniteur:

8.8.8.8
8.8.4.4
156.154.70.1
156.154.71.1

J'ai pu faire fonctionner le mappage de liste simplement en utilisant @SerializedNamepour tous les champs .. aucune logique Typen'était nécessaire.

En exécutant le code - à l'étape 4 ci - dessous - via le débogueur, je suis en mesure d'observer que l' List<ContentImage> mGalleryImagesobjet rempli avec les données JSON

Voici un exemple:

1. Le JSON

   {
    "name": "Some House",
    "gallery": [
      {
        "description": "Nice 300sqft. den.jpg",
        "photo_url": "image/den.jpg"
      },
      {
        "description": "Floor Plan",
        "photo_url": "image/floor_plan.jpg"
      }
    ]
  }

2. Classe Java avec la liste

public class FocusArea {

    @SerializedName("name")
    private String mName;

    @SerializedName("gallery")
    private List<ContentImage> mGalleryImages;
}

3. Classe Java pour les éléments de liste

public class ContentImage {

    @SerializedName("description")
    private String mDescription;

    @SerializedName("photo_url")
    private String mPhotoUrl;

    // getters/setters ..
}

4. Le code Java qui traite le JSON

    for (String key : focusAreaKeys) {

        JsonElement sectionElement = sectionsJsonObject.get(key);
        FocusArea focusArea = gson.fromJson(sectionElement, FocusArea.class);
    }

Étant donné que vous commencez par mapping.get("servers").getAsJsonArray(), si vous avez accès à Guava Streams , vous pouvez faire le one-liner ci-dessous:

List<String> servers = Streams.stream(jsonArray.iterator())
                              .map(je -> je.getAsString())
                              .collect(Collectors.toList());

La note StreamSupportne pourra pas fonctionner sur le JsonElementtype, donc c'est insuffisant.