Comment itérer Tableau JSON et l'extrait de chaque Objet JSON en utilisant GSON?

Ci-dessous est ma Chaîne JSON qui je suis de retour en appelant à partir d'un service de l'API. J'ai raccourcir le bas en ayant seulement trois reportRecords pour la compréhension but. En général, il pourrait avoir ~500 reportRecords

{
   "aggRecords": {
      "reportRecords": [
         {
            "min": 0,
            "max": 12,
            "avg": 0.3699187,
            "count": 246,
            "sumSq": 571,
            "stddev": 1.4779372,
            "median": 0,
            "percentileMap": {
               "95": 4
            },
            "metricName": "TransactionDuration",
            "dimensions": {
               "env": "dev",
               "pool": "titan",
               "Name": "PostProcessing",
               "Type": "PostProcessing"
            },
            "value": 91
         },
         {
            "min": 0,
            "max": 23,
            "avg": 2.3991289E-4,
            "count": 1463031,
            "sumSq": 3071,
            "stddev": 0.045814946,
            "median": 0,
            "percentileMap": {
               "95": 0
            },
            "metricName": "TransactionDuration",
            "dimensions": {
               "env": "dev",
               "pool": "titan",
               "Name": "ResourceContext",
               "Type": "ResourceContext"
            },
            "value": 351
         },
         {
            "min": 0,
            "max": 1209,
            "avg": 1.9203402,
            "count": 7344636,
            "sumSq": 71832774,
            "stddev": 2.4683187,
            "median": 2,
            "percentileMap": {
               "95": 4
            },
            "metricName": "TransactionDuration",
            "dimensions": {
               "env": "dev",
               "pool": "titan",
               "Name": "Client::Sync",
               "Type": "Client::Sync"
            },
            "value": 14104200
         }
      ]
   },
   "minRecordsMap": {}
}

Maintenant à Partir du dessus de réponse JSON, j'ai besoin d'extraire reportRecords dont Name est Client::Sync. Sens, j'ai besoin de l'extrait ci-dessous reportRecords à partir du dessus de réponse JSON seulement.

         {
            "min": 0,
            "max": 1209,
            "avg": 1.9203402,
            "count": 7344636,
            "sumSq": 71832774,
            "stddev": 2.4683187,
            "median": 2,
            "percentileMap": {
               "95": 4
            },
            "metricName": "TransactionDuration",
            "dimensions": {
               "env": "dev",
               "pool": "titan",
               "Name": "Client::Sync",
               "Type": "Client::Sync"
            },
            "value": 14104200
         }

Et maintenant, j'ai besoin d'analyser ci-dessus reportRecords pour Client::Sync au-dessous de l'objet

public class DataMetrics {
private String pool;
private String name;
private String type;
private String env;
private String metricName;
private String percentile;
private String median;
private String stdDev;
private String sumSq;
private String count;
private String avg;
private String max;
private String min;
//getters and setters here
}

Ci-dessus variable, des cartes comme celle-ci,

pool is titan
name is Client::Sync 
type is Client::Sync
env is dev
metricNname is TransactionDuration
95th  percentile is 4
median is 2
stdDev is 2.4683187 
sumSq is 71832774 
count is 7344636 
avg is 1.9203402
max is 1209
min is 0

Je suis à l'aide de GSON bibliothèque ici et ci-dessous est ce que j'ai essayé jusqu'à présent -

private static RestTemplate restTemplate = new RestTemplate();
public static void main(String[] args) {
String jsonLine = restTemplate.getForObject("some_url", String.class);
System.out.println(jsonLine); //here jsonLine will give me above big JSON String
JsonElement jelement = new JsonParser().parse(jsonLine);
JsonObject  jobject = jelement.getAsJsonObject();
jobject = jobject.getAsJsonObject("aggRecords");
JsonArray jarray = jobject.getAsJsonArray("reportRecords");
//now how do I iterate JsonArray and get each JSON object
//and then check "name" property of each object, if "Client::Sync" found, read that object for all properties
//and set it using setters.
}

Maintenant, je ne suis pas en mesure de comprendre comment dois-je effectuer une itération JsonArray et de l'extrait de chaque objet JSON à partir d'elle?

Je suis en train de travailler avec GSON et je suppose que l'exemple ci-dessus, ne pas utiliser de GSON.
désolé, mon erreur:/

InformationsquelleAutor john | 2014-06-17

3

De sorte que vous avez le JsonArray objet avec vos dossiers, voici ce que vous devez faire pour obtenir vos objets fonctionnels:
```
Type type = new TypeToken<List<DataMetrics>>() {}.getType();
List<DataMetrics> records = gson.fromJson(jsonArrayThatYouHave, type);
```
Alors vous itérer à travers des objets et de filtrer ceux dont vous avez besoin.
Dans java 8, vous pouvez faire ceci:
```
List<DataMetrics> result = records.stream().filter(record -> record.name.equals("Client::Sync")).collect(toList());
```
Cette approche est la conversion de tous les objets et d'itération après, si exactement cette partie de code est critique pour les performances, vous pouvez toujours parcourir en json et de convertir uniquement les objets nécessaires (mais je doute que ce sera effectivement plus rapide que celle décrite ci-dessus).

De toute façon c'est plus facile à maintenir et compréhensible code.

Mise à JOUR:

la même pour java 7:
```
List<DataMetrics> result = new LinkedList<>();
for(DataMetrics record : records){
if(record.name.equals("Client::Sync")){
result.add(record);
}
}
```
- Grâce Vach. Comment pourrais-je le faire dans Java7? Je suis en train de Java7 dès maintenant.
- vérifier la mise à jour
- Merci pour l'aide. J'ai essayé cela et en quelque sorte, la plupart des champs sont à venir comme vide, comme percentile, le nom, le type, min et quelques autres, mais certaines données. Voyez-vous quelque chose de mal?
- Vous avez juste besoin de la même noms de propriétés de la Classe qu'en json (ou de le spécifier avec @Qualifier d'annotation si vous ne voulez pas le changer)
InformationsquelleAutor vach

Vous pouvez analyser tous les objets, puis filtrer ceux qui vous intéressent.

Après que vous avez obtenu jArray, essayez:

//get json array from json string
JsonArray jarray = jobject.getAsJsonArray("reportRecords");
//get a list of reportRecords using Gson
Gson mGson = new Gson();
Type listType = new TypeToken<List<DataMetrics>>(){}.getType();
List<DataMetrics> dataMetricsList = mGson.fromJson(reportRecordsJsonArray, listType);
//Filter only the ones with a specific name
List<DataMetrics> dataMetricsFilteredList = dataMetricsList.stream().filter(dataMetric -> dateMetric.getName.equals("Client::Sync"));

InformationsquelleAutor U_D

0

Ou si vous souhaitez effectuer une itération json et analyser uniquement requises heres ce que vous pouvez faire:
```
Type type = new TypeToken<List<DataMetrics>>() {}.getType();
for(JsonElement elem : jsonArrayThatYouHave) {
if (elem.getAsJsonObject().get("name").getAsString().equals("Client::Sync")) {
result.add(gson.fromJson(elem, type));
}
}
```
mais je ne pense pas que c'est effectivement plus rapide que le premier, car dans les deux cas, la conversion de json pour java objet fonctionnel avec analyseur et d'obtenir JsonArray ou quoi que ce soit d'autre. En prenant en considération le fait que les deux sont Googles libs, je suppose que l'analyse de JsonObject spécifiques à certains type de gson est beaucoup plus rapide que de Chaîne (raw json) pour le même type spécifique...

InformationsquelleAutor vach

-1

je n'ai pas essayer, mais il peut fonctionner.

 public void getFromJson(JSONObject json)
{
JSONArray jarray = (JSONArray) json.get("reportRecords");
List<DataMetrics> myList = new ArrayList();
for(int i = 0; i < jarray.size(); i++)
{
myList.add((DataMetrics) getClassFromJsonObject((JSONObject) jarray.get(i),
DataMetrics.class));
}
}

////
Objet public getClassFromJsonObject(JSONObject json, Classe myClass){

    Object object = new Object();
ObjectMapper obj =  JSONMapperFactory.createMapper();
obj.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
try {
object = obj.readValue(json.toString(), myClass);
} catch (IOException e) {
e.printStackTrace();  
throw new RuntimeException(e);
}
return myClass.cast(object);
}

InformationsquelleAutor erdem karayer

Vous devez vous connecter pour publier un commentaire.