Analyseur JSON

Détails
Catégorie : Utilisation des ressources Internet
Affichages : 9

Analyse de JSON à l'aide de l'analyseur JSON

 Cette section fournit un bref aperçu du JsonParser, en montrant comment il peut être utilisé pour analyser les détails d'un séisme à partir du fil JSON du United States Geological Survey (USGS), disponible à l'adresse suivante: 

earthquake.usgs.gov/earthquakes/feed/v1.0/summary/2.5_day.geojson.

 Comme pour l'analyse XML dans les sections précédentes, les instructions détaillées pour l'analyse JSON sortent du cadre de ce manuel. Cependant, avec de nombreuses API fournissant maintenant des flux JSON, il est important d’introduire les concepts. Comme l’analyseur Pull, l’analyseur JSON vous permet d’analyser un document en une seule passe, en présentant les éléments de votre document dans une série séquentielle d’objets, de tableaux et de valeurs. Pour créer un analyseur récursif, vous devez d'abord créer une méthode de point d'entrée qui utilise un flux d'entrée et crée un nouveau lecteur JSON:

 

  1. private List<Earthquake> parseJson(InputStream in) throws IOException {
  2.  
  3.   // Create a new Json Reader to parse the input.
  4.  
  5.   JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
  6.  
  7.     // TODO: Parse the InputStream
  8. }

 Les données au sein de chaque flux JSON sont stockées sous forme de noms et de valeurs, structurées à l'aide d'objets et de tableaux. Les objets JSON sont utilisés de la même manière que les objets de code, regroupant des valeurs sémantiquement liées. JSON prend également en charge les tableaux pour regrouper plusieurs valeurs ou objets.  Par exemple, le fil USGS contient une valeur de type, ainsi que des objets de métadonnées et de cadres de sélection au niveau racine, ainsi qu'un tableau de plusieurs objets de caractéristiques représentant chaque séisme. Chaque objet caractéristique contient ensuite des valeurs pour le type et l'ID, ainsi que des objets permettant de regrouper les propriétés sismiques et les détails géométriques. L'objet géométrie inclut à son tour une valeur pour le type de géométrie et un tableau de valeurs représentant la latitude, la longitude et la profondeur de chaque séisme. Cette structure est illustrée en partie à la figure 7-2.  Pour analyser ces structures, créez des méthodes de gestionnaire qui analyseront chaque objet et tableau dans le texte JSON..Pour les méthodes de gestionnaire de structure d’objet, commencez par appeler la méthode beginObject de votre objet JSON Reader pour utiliser l’accolade d’ouverture. Utilisez ensuite la méthode hasNext pour contrôler une boucle while au sein de laquelle vous pouvez extraire des valeurs ou d’autres objets (ou tableaux). Utilisez la méthode endObject pour lire l’accolade de fermeture de l’objet lorsque celui-ci a été entièrement lu:

 

  1. private MyObject readMyObject(JsonReader reader) throws IOException {
  2.   // Create variables for the return values.
  3.   String myValue = null;
  4.   // Consume the opening brace.
  5.   reader.beginObject();  
  6.   // Traverse the values, objects, and arrays within this object.
  7.   while (reader.hasNext()) { 
  8.     // Find the next name.
  9.     String name = reader.nextName();
  10.     // Extract each of the values based on name matches.
  11.      if (name.equals("my_value")) {
  12.        myValue = reader.nextString();
  13.     // Skip any unexpected (or purposefully ignored) values.
  14.     } else {
  15.       reader.skipValue();
  16.     }
  17.   }
  18.   // Consume closing brace.
  19.   reader.endObject();
  20.   // Return parsed object.
  21.   return new MyObject(myValue); 
  22. }

Les tableaux sont gérés de la même manière, en utilisant les méthodes beginArray et endArray pour consommer respectivement les crochets d’ouverture et de fermeture. Les valeurs dans un tableau sont homogènes, vous permettant d’ajouter simplement chaque valeur à une liste:

 

  1.  public List<Double> readDoublesArray(JsonReader reader)
  2.   throws IOException {
  3.   List<Double> doubles = new ArrayList<Double>(); 
  4.   reader.beginArray();
  5.  
  6.   while (reader.hasNext()) {  
  7.    doubles.add(reader.nextDouble()); 
  8.   }
  9.   reader.endArray();
  10.    return doubles; 
  11. }

 Lorsque vous parcourez chaque objet ou tableau, si un objet ou un tableau imbriqué est trouvé, passez simplement l'objet JSON Reader à la méthode d'analyse correspondante. Si un nom inconnu est rencontré, vous pouvez appeler skipValue pour ignorer de manière récursive les jetons imbriqués de la valeur. Le Listing 7-5 montre comment utiliser l'analyseur JSON pour extraire des détails du flux JSON de séisme de magnitude 2,5+ du dernier jour fourni par l'USGS.

 LISTING 7-5: Analyse de JSON à l'aide de l'analyseur JSON

 

  1. private List<Earthquake> parseJson(InputStream in)
  2.  throws IOException {
  3.   // Create a new Json Reader to parse the input.
  4.   JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
  5.   try {
  6.     // Create an empty list of earthquakes.
  7.     List<Earthquake> earthquakes = null;
  8.     // The root node of the Earthquake JSON feed is an object that
  9.     // we must parse.
  10.     reader.beginObject();
  11.      while (reader.hasNext()) {
  12.       String name = reader.nextName();
  13.       // We are only interested in one sub-object: the array of
  14.       // earthquakes labeled as features.
  15.       if (name.equals("features")) {
  16.         earthquakes = readEarthquakeArray(reader);
  17.        } else {
  18.         // We will ignore all other root level values and objects.
  19.         reader.skipValue();
  20.       }
  21.     }
  22.      reader.endObject();
  23.      return earthquakes;
  24.   } finally {
  25.     reader.close();
  26.   }
  27. }
  28.  
  29. // Traverse the array of earthquakes.
  30. private List<Earthquake> readEarthquakeArray(JsonReader reader)
  31.   throws IOException {
  32.    List<Earthquake> earthquakes = new ArrayList<Earthquake>();
  33.   // The earthquake details are stored in an array.
  34.   reader.beginArray();   while (reader.hasNext()) {
  35.     // Traverse the array, parsing each earthquake.
  36.     earthquakes.add(readEarthquake(reader));
  37.   }
  38.    reader.endArray();
  39.    return earthquakes; 
  40. }
  41.  
  42. // Parse each earthquake object within the earthquake array.
  43. public Earthquake readEarthquake(JsonReader reader) throws IOException {
  44.   String id = null;
  45.   Location location = null;
  46.   Earthquake earthquakeProperties = null;
  47.   reader.beginObject();
  48.    while (reader.hasNext()) {
  49.     String name = reader.nextName();
  50.      if (name.equals("id")) {
  51.       // The ID is stored as a value.
  52.        id = reader.nextString();
  53.     } else if (name.equals("geometry")) {
  54.       // The location is stored as a geometry object
  55.       // that must be parsed.
  56.       location = readLocation(reader);
  57.     } else if (name.equals("properties")) {
  58.       // Most of the earthquake details are stored as a
  59.       // properties object that must be parsed.
  60.       earthquakeProperties = readEarthquakeProperties(reader);
  61.     } else {
  62.       reader.skipValue();
  63.     }
  64.   }   reader.endObject();
  65.   // Construct a new Earthquake based on the parsed details.
  66.    return new Earthquake(id, earthquakeProperties.getDate(), earthquakeProperties.getDetails(),location,earthquakeProperties.getMagnitude(),earthquakeProperties.getLink());
  67. }
  68.  
  69. // Parse the properties object for each earthquake object
  70. // within the earthquake array. 
  71. public Earthquake readEarthquakeProperties(JsonReader reader) throws IOException {
  72.   Date date = null;
  73.   String details = null;   double magnitude = -1;   String link = null;
  74.   reader.beginObject();   while (reader.hasNext()) {
  75.     String name = reader.nextName();
  76.      if (name.equals("time")) {
  77.        long time = reader.nextLong();
  78.        date = new Date(time);
  79.     } else if (name.equals("place")) {
  80.        details = reader.nextString();
  81.      } else if (name.equals("url")) {
  82.        link = reader.nextString();
  83.     } else if (name.equals("mag")) {
  84.        magnitude = reader.nextDouble();
  85.     } else {
  86.       reader.skipValue();
  87.     }
  88.   }
  89.   reader.endObject();
  90.   return new Earthquake(null, date, details, null, magnitude, link); 
  91. }
  92.  
  93. // Parse the coordinates object to obtain a location.
  94. private Location readLocation(JsonReader reader) throws IOException { 
  95.   Location location = null;
  96.   reader.beginObject();
  97.    while (reader.hasNext()) {
  98.     String name = reader.nextName();
  99.      if (name.equals("coordinates")) {
  100.        // The location coordinates are stored within an 
  101.       // array of doubles.
  102.        List<Double> coords = readDoublesArray(reader);
  103.        location = new Location("dummy");
  104.        location.setLatitude(coords.get(0));
  105.        location.setLongitude(coords.get(1));
  106.     } else {
  107.       reader.skipValue();
  108.     }
  109.   }
  110.    reader.endObject();
  111.    return location; 
  112. }
  113.  
  114. // Parse an array of doubles.
  115. public List<Double> readDoublesArray(JsonReader reader) throws IOException {
  116.   List<Double> doubles = new ArrayList<Double>();
  117.   reader.beginArray();
  118.    while (reader.hasNext()) { 
  119.     doubles.add(reader.nextDouble());
  120.   }
  121.    reader.endArray();
  122.    return doubles; 
  123. }
  124.  
  125.