Android
JSON in Android met org.json

Syntaxis

• Object : een object is een ongeordende set naam / waarde-paren. Een object begint met {(linker accolade) en eindigt met} (rechter accolade). Elke naam wordt gevolgd door: (dubbele punt) en de naam / waarde-paren worden gescheiden door, (komma).

• Array : een array is een geordende verzameling waarden. Een array begint met [(linker haakje) en eindigt met] (rechter haakje). Waarden worden gescheiden door, (komma).

• Waarde : een waarde kan een tekenreeks in dubbele aanhalingstekens zijn, of een getal, of waar of onwaar of null, of een object of een array. Deze structuren kunnen worden genest.

• String : een string is een reeks van nul of meer Unicode-tekens, gewikkeld in dubbele aanhalingstekens, met behulp van backslash-escapes. Een karakter wordt weergegeven als een enkele tekenreeks. Een string lijkt erg op een C- of Java-string.

• Number : een nummer lijkt erg op een C- of Java-nummer, behalve dat de octale en hexadecimale notaties niet worden gebruikt.

Opmerkingen

Eenvoudig JSON-object ontleden

Overweeg de volgende JSON-string:

{
  "title": "test",
  "content": "Hello World!!!",
  "year": 2016,
  "names" : [
        "Hannah",
        "David",
        "Steve"
   ]
} 

Dit JSON-object kan worden ontleed met de volgende code:

try {
    // create a new instance from a string
    JSONObject jsonObject = new JSONObject(jsonAsString);
    String title = jsonObject.getString("title");
    String content = jsonObject.getString("content");
    int year = jsonObject.getInt("year");
    JSONArray names = jsonObject.getJSONArray("names"); //for an array of String objects
} catch (JSONException e) {
    Log.w(TAG,"Could not parse JSON. Error: " + e.getMessage());
}

Hier is nog een voorbeeld met een JSONArray genest in JSONObject:

{
    "books":[
      {
        "title":"Android JSON Parsing",
        "times_sold":186
      }
    ]
}

Dit kan worden ontleed met de volgende code:

JSONObject root = new JSONObject(booksJson);
JSONArray booksArray = root.getJSONArray("books");
JSONObject firstBook = booksArray.getJSONObject(0);
String title = firstBook.getString("title");
int timesSold = firstBook.getInt("times_sold");

Een eenvoudig JSON-object maken

Maak het JSONObject met de lege constructor en voeg velden toe met de methode put() , die overbelast is, zodat het met verschillende typen kan worden gebruikt:

try {
    // Create a new instance of a JSONObject
    final JSONObject object = new JSONObject();
    
    // With put you can add a name/value pair to the JSONObject
    object.put("name", "test");
    object.put("content", "Hello World!!!1");
    object.put("year", 2016);
    object.put("value", 3.23);
    object.put("member", true);
    object.put("null_value", JSONObject.NULL);

    // Calling toString() on the JSONObject returns the JSON in string format.
    final String json = object.toString();
    
} catch (JSONException e) {
    Log.e(TAG, "Failed to create JSONObject", e);
}

De resulterende JSON string ziet er als volgt uit:

{  
   "name":"test",
   "content":"Hello World!!!1",
   "year":2016,
   "value":3.23,
   "member":true,
   "null_value":null
}

Voeg JSONArray toe aan JSONObject

// Create a new instance of a JSONArray
JSONArray array = new JSONArray();

// With put() you can add a value to the array.
array.put("ASDF");
array.put("QWERTY");

// Create a new instance of a JSONObject
JSONObject obj = new JSONObject();

try {
    // Add the JSONArray to the JSONObject
    obj.put("the_array", array);
} catch (JSONException e) {
    e.printStackTrace();
}

String json = obj.toString();

De resulterende JSON-string ziet er als volgt uit:

{  
   "the_array":[  
      "ASDF",
      "QWERTY"
   ]
}

Maak een JSON-string met nulwaarde.

Als u een JSON-string met een waarde van null als deze moet produceren:

{  
   "name":null
}

Dan moet u de speciale constante JSONObject.NULL gebruiken .

Werkend voorbeeld:

jsonObject.put("name", JSONObject.NULL);

Werken met null-string bij het parseren van json

{
    "some_string": null,
    "ather_string": "something"
}

Als we op deze manier zullen gebruiken:

JSONObject json = new JSONObject(jsonStr);
String someString = json.optString("some_string");

We zullen output hebben:

someString = "null";

Daarom moeten we deze oplossing bieden:

/**
 * According to http://stackoverflow.com/questions/18226288/json-jsonobject-optstring-returns-string-null
 * we need to provide a workaround to opt string from json that can be null.
 * <strong></strong>
 */
public static String optNullableString(JSONObject jsonObject, String key) {
    return optNullableString(jsonObject, key, "");
}

/**
 * According to http://stackoverflow.com/questions/18226288/json-jsonobject-optstring-returns-string-null
 * we need to provide a workaround to opt string from json that can be null.
 * <strong></strong>
 */
public static String optNullableString(JSONObject jsonObject, String key, String fallback) {
    if (jsonObject.isNull(key)) {
        return fallback;
    } else {
        return jsonObject.optString(key, fallback);
    }
}

En bel dan:

JSONObject json = new JSONObject(jsonStr);
String someString = optNullableString(json, "some_string");
String someString2 = optNullableString(json, "some_string", "");

En we zullen output hebben zoals we hadden verwacht:

someString = null; //not "null"
someString2 = "";

JsonReader gebruiken om JSON uit een stream te lezen

JsonReader leest een JSON-gecodeerde waarde als een stroom tokens.

   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);
   }

Maak een genest JSON-object

Om een genest JSON-object te produceren, moet u eenvoudig een JSON-object aan een ander toevoegen:

JSONObject mainObject = new JSONObject();            // Host object
JSONObject requestObject = new JSONObject();         // Included object

try {
    requestObject.put("lastname", lastname);
    requestObject.put("phone", phone);
    requestObject.put("latitude", lat);
    requestObject.put("longitude", lon);
    requestObject.put("theme", theme);
    requestObject.put("text", message);

    mainObject.put("claim", requestObject);
} catch (JSONException e) {
    return "JSON Error";
}

mainObject bevat nu een sleutel met de naam claim met het hele requestObject als waarde.

Omgaan met dynamische sleutel voor JSON-reactie

Dit is een voorbeeld voor het omgaan met dynamische sleutel voor respons. Hier zijn A en B dynamische toetsen, het kan van alles zijn

antwoord

{
  "response": [
    {
      "A": [
        {
          "name": "Tango"
        },
        {
          "name": "Ping"
        }
      ],
      "B": [
        {
          "name": "Jon"
        },
        {
          "name": "Mark"
        }
      ]
    }
  ]
}

Java-code

// ResponseData is raw string of response
JSONObject responseDataObj = new JSONObject(responseData);
JSONArray responseArray = responseDataObj.getJSONArray("response");
for (int i = 0; i < responseArray.length(); i++) {
    // Nodes ArrayList<ArrayList<String>> declared globally
    nodes = new ArrayList<ArrayList<String>>();
    JSONObject obj = responseArray.getJSONObject(i);
    Iterator keys = obj.keys();
    while(keys.hasNext()) {
       // Loop to get the dynamic key
       String currentDynamicKey = (String)keys.next();
       // Get the value of the dynamic key
       JSONArray currentDynamicValue = obj.getJSONArray(currentDynamicKey);
       int jsonArraySize = currentDynamicValue.length();
       if(jsonArraySize > 0) {
           for (int ii = 0; ii < jsonArraySize; ii++) {
                // NameList ArrayList<String> declared globally
                nameList = new ArrayList<String>();
               if(ii == 0) {
                JSONObject nameObj = currentDynamicValue.getJSONObject(ii);
                String name = nameObj.getString("name");
                System.out.print("Name = " + name);
                // Store name in an array list
                nameList.add(name);
              }
           }                    
       }
     nodes.add(nameList);
    }
}

Controleer op het bestaan van velden op JSON

Soms is het handig om te controleren of een veld aanwezig of afwezig is op uw JSON om enige JSONException op uw code te voorkomen.

Om dit te bereiken, gebruikt u de JSONObject#has(String) of de methode, zoals in het volgende voorbeeld:

Voorbeeld JSON

{
   "name":"James"
}

Java-code

String jsonStr = " { \"name\":\"James\" }";
JSONObject json = new JSONObject(jsonStr);
// Check if the field "name" is present
String name, surname;

// This will be true, since the field "name" is present on our JSON.
if (json.has("name")) {
    name = json.getString("name");
}
else {
    name = "John";
}
// This will be false, since our JSON doesn't have the field "surname".
if (json.has("surname")) {
    surname = json.getString("surname");
}
else {
    surname = "Doe";
}

// Here name == "James" and surname == "Doe".

De elementen in de JSON bijwerken

sample json om bij te werken

 {
 "student":{"name":"Rahul", "lastname":"sharma"},
 "marks":{"maths":"88"}
 }

Om de elementenwaarde in de json bij te werken, moeten we de waarde toewijzen en bijwerken.

try {
    // Create a new instance of a JSONObject
    final JSONObject object = new JSONObject(jsonString);
    
    JSONObject studentJSON = object.getJSONObject("student");
    studentJSON.put("name","Kumar");
  
     object.remove("student");

     object.put("student",studentJSON);

    // Calling toString() on the JSONObject returns the JSON in string format.
    final String json = object.toString();
    
} catch (JSONException e) {
    Log.e(TAG, "Failed to create JSONObject", e);
}

bijgewerkte waarde

 {
 "student":{"name":"Kumar", "lastname":"sharma"},
 "marks":{"maths":"88"}
 }