JsonReader Classe

Définition

[Android.Runtime.Register("android/util/JsonReader", DoNotGenerateAcw=true)]
public sealed class JsonReader : Java.Lang.Object, IDisposable, Java.IO.ICloseable

[<Android.Runtime.Register("android/util/JsonReader", DoNotGenerateAcw=true)>]
type JsonReader = class
    inherit Object
    interface ICloseable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Héritage

Object

JavaObject

Object

JsonReader

Attributs

RegisterAttribute

Implémente

IJavaObject IJavaPeerable ICloseable IDisposable

Remarques

Lit une valeur encodée JSON (RFC 4627) en tant que flux de jetons. Ce flux inclut les deux valeurs littérales (chaînes, nombres, booléens et null) ainsi que les délimiteurs de début et de fin des objets et des tableaux. Les jetons sont parcourus dans un ordre détaillé, le même ordre qu’ils apparaissent dans le document JSON. Dans les objets JSON, les paires nom/valeur sont représentées par un seul jeton.

<h3>Analyse JSON</h3> Pour créer un analyseur de descente récursive pour vos propres flux JSON, commencez par créer une méthode de point d’entrée qui crée un JsonReader.

Ensuite, créez des méthodes de gestionnaire pour chaque structure dans votre texte JSON. Vous aurez besoin d’une méthode pour chaque type d’objet et pour chaque type de tableau. <ul><li>In <strong>array handling</strong> methods, first call #beginArray to consume the array’s opening crochet. Créez ensuite une boucle while qui accumule les valeurs, ce qui se termine lorsqu’elle #hasNext a la valeur false. Enfin, lisez le crochet fermant du tableau en appelant #endArray. <li>Within <strong>object handling</strong> methods, first call #beginObject to consume the object’s opening brace. Créez ensuite une boucle while qui affecte des valeurs à des variables locales en fonction de leur nom. Cette boucle doit se terminer lorsqu’elle #hasNext a la valeur false. Enfin, lisez l’accolade fermante de l’objet en appelant #endObject. </ul>

Lorsqu’un objet ou tableau imbriqué est rencontré, délégué à la méthode de gestionnaire correspondante.

Lorsqu’un nom inconnu est rencontré, les analyseurs stricts doivent échouer avec une exception. Les analyseurs lenient doivent appeler #skipValue() pour ignorer de manière récursive les jetons imbriqués de la valeur, qui peuvent autrement être en conflit.

Si une valeur peut être null, vous devez d’abord vérifier à l’aide #peek()de . Les littéraux Null peuvent être consommés à l’aide de l’une ou l’autre #nextNull() .#skipValue()

<Exemple h3></h3> Supposons que nous aimerions analyser un flux de messages tels que les suivants :

{@code
            [
              {
                "id": 912345678901,
                "text": "How do I read JSON on Android?",
                "geo": null,
                "user": {
                  "name": "android_newb",
                  "followers_count": 41
                 }
              },
              {
                "id": 912345678902,
                "text": "@android_newb just use android.util.JsonReader!",
                "geo": [50.454722, -104.606667],
                "user": {
                  "name": "jesse",
                  "followers_count": 2
                }
              }
            ]}

Ce code implémente l’analyseur pour la structure ci-dessus :

{@code

              public List<Message> readJsonStream(InputStream in) throws IOException {
                JsonReader reader = new JsonReader(new InputStreamReader(in, "UTF-8"));
                try {
                  return readMessagesArray(reader);
                } finally {
                  reader.close();
                }
              }

              public List<Message> readMessagesArray(JsonReader reader) throws IOException {
                List<Message> messages = new ArrayList<Message>();

                reader.beginArray();
                while (reader.hasNext()) {
                  messages.add(readMessage(reader));
                }
                reader.endArray();
                return messages;
              }

              public Message readMessage(JsonReader reader) throws IOException {
                long id = -1;
                String text = null;
                User user = null;
                List<Double> geo = null;

                reader.beginObject();
                while (reader.hasNext()) {
                  String name = reader.nextName();
                  if (name.equals("id")) {
                    id = reader.nextLong();
                  } else if (name.equals("text")) {
                    text = reader.nextString();
                  } else if (name.equals("geo") && reader.peek() != JsonToken.NULL) {
                    geo = readDoublesArray(reader);
                  } else if (name.equals("user")) {
                    user = readUser(reader);
                  } else {
                    reader.skipValue();
                  }
                }
                reader.endObject();
                return new Message(id, text, user, geo);
              }

              public List<Double> readDoublesArray(JsonReader reader) throws IOException {
                List<Double> doubles = new ArrayList<Double>();

                reader.beginArray();
                while (reader.hasNext()) {
                  doubles.add(reader.nextDouble());
                }
                reader.endArray();
                return doubles;
              }

              public User readUser(JsonReader reader) throws IOException {
                String username = null;
                int followersCount = -1;

                reader.beginObject();
                while (reader.hasNext()) {
                  String name = reader.nextName();
                  if (name.equals("name")) {
                    username = reader.nextString();
                  } else if (name.equals("followers_count")) {
                    followersCount = reader.nextInt();
                  } else {
                    reader.skipValue();
                  }
                }
                reader.endObject();
                return new User(username, followersCount);
              }}

<h3>Number Handling</h3> Ce lecteur permet de lire des valeurs numériques sous forme de chaînes et de valeurs de chaîne à lire en tant que nombres. Par exemple, les deux éléments du tableau [1, "1"] JSON peuvent être lus à l’aide de l’une ou l’autre #nextInt .#nextString Ce comportement est destiné à empêcher les conversions numériques perdues : double est le seul type numérique de JavaScript et les valeurs très volumineuses telles que 9007199254740993 ne peuvent pas être représentées exactement sur cette plateforme. Pour réduire la perte de précision, les valeurs extrêmement volumineuses doivent être écrites et lues en tant que chaînes au format JSON.

Chacun JsonReader peut être utilisé pour lire un seul flux JSON. Les instances de cette classe ne sont pas thread-safe.

Java documentation pour android.util.JsonReader.

Les parties de cette page sont des modifications basées sur le travail créé et partagé par Android Open Source et utilisées en fonction des termes décrits dans la Creative Commons 2.5 Attribution License.