JsonReader Klasse

Definition

[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

Vererbung

Object

JavaObject

Object

JsonReader

Attribute

RegisterAttribute

Implementiert

IJavaObject IJavaPeerable ICloseable IDisposable

Hinweise

Liest einen JSON-Codierten WERT (RFC 4627) als Datenstrom von Token. Dieser Datenstrom enthält sowohl Literalwerte (Zeichenfolgen, Zahlen, Booleane und NULL-Werte) als auch die Anfangs- und Endtrennzeichen von Objekten und Arrays. Die Token werden in der ersten Reihenfolge durchlaufen, die gleiche Reihenfolge wie im JSON-Dokument. Innerhalb von JSON-Objekten werden Name/Wert-Paare durch ein einzelnes Token dargestellt.

<h3>Parsing JSON</h3> Um einen rekursiven Abstiegsparser für Ihre eigenen JSON-Streams zu erstellen, erstellen Sie zuerst eine Einstiegspunktmethode, die eine JsonReader.

Erstellen Sie als Nächstes Handlermethoden für jede Struktur in Ihrem JSON-Text. Sie benötigen eine Methode für jeden Objekttyp und für jeden Arraytyp. <ul><li>Innerhalb <einer starken>Arraybehandlung</starke> Methoden, rufen Sie zuerst #beginArray auf, um die öffnende Klammer des Arrays zu nutzen. Erstellen Sie dann eine While-Schleife, die Werte ansammelt und beendet wird, wenn #hasNext "false" ist. Lesen Sie schließlich die schließende Klammer des Arrays durch Aufrufen.#endArray <li>Innerhalb <einer starken>Objektbehandlung</starken> Methoden wird zuerst aufgerufen #beginObject , um die öffnende Klammer des Objekts zu nutzen. Erstellen Sie dann eine While-Schleife, die basierend auf ihrem Namen Werte lokalen Variablen zuweist. Diese Schleife sollte beendet werden, wenn #hasNext "false" ist. Lesen Sie schließlich die schließende geschweifte Klammer des Objekts durch Aufrufen #endObject. </ul>

Wenn ein geschachteltes Objekt oder array gefunden wird, delegieren Sie an die entsprechende Handlermethode.

Wenn ein unbekannter Name gefunden wird, sollten strenge Parser mit ausnahmefehlern. Lenient parsers should call #skipValue() to rekursive skip the value's nested tokens, which may otherwise conflict.

Wenn ein Wert möglicherweise null ist, sollten Sie zuerst die Verwendung überprüfen #peek(). Nullliterale können entweder oder #nextNull()#skipValue()verwendet werden.

<h3>Beispiel</h3> Angenommen, wir möchten einen Datenstrom von Nachrichten analysieren, z. B. folgendes:

{@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
                }
              }
            ]}

Dieser Code implementiert den Parser für die obige Struktur:

{@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>Zahlenbehandlung</h3> Dieser Reader erlaubt es, numerische Werte als Zeichenfolgen und Zeichenfolgenwerte als Zahlen zu lesen. Beispielsweise können beide Elemente des JSON-Arrays [1, "1"] entweder oder #nextInt#nextString. Dieses Verhalten dient dazu, verlustbehaftete numerische Konvertierungen zu verhindern: Double ist der einzige numerische Typ von JavaScript und sehr große Werte wie 9007199254740993 können nicht genau auf dieser Plattform dargestellt werden. Um Genauigkeitsverluste zu minimieren, sollten extrem große Werte in JSON geschrieben und als Zeichenfolgen gelesen werden.

Jeder JsonReader kann zum Lesen eines einzelnen JSON-Datenstroms verwendet werden. Instanzen dieser Klasse sind nicht threadsicher.

Java Dokumentation für android.util.JsonReader.

Teile dieser Seite sind Änderungen auf der Grundlage von Arbeiten, die von der Android Open Source Project erstellt und gemeinsam verwendet und gemäß den in der 2.5 Attribution License beschriebenen Begriffen verwendet werden.