Android
Org.json के साथ Android में JSON

वाक्य - विन्यास

• ऑब्जेक्ट : एक ऑब्जेक्ट नाम / मूल्य जोड़े का एक अनियंत्रित सेट है। एक वस्तु {(बाएं ब्रेस) से शुरू होती है और} (दाएं ब्रेस) के साथ समाप्त होती है। प्रत्येक नाम के बाद होता है: (कोलन) और नाम / मान जोड़े अलग हो जाते हैं, (अल्पविराम)।

• सरणी : एक सरणी मानों का एक आदेशित संग्रह है। एक सरणी [(बाएं ब्रैकेट) के साथ शुरू होती है और साथ समाप्त होती है] (दाएं ब्रैकेट)। मान (अल्पविराम) द्वारा अलग किए जाते हैं।

• मूल्य : एक मूल्य दोहरे उद्धरण चिह्नों, या एक संख्या, या सही या गलत या अशक्त, या एक वस्तु या एक सरणी में एक स्ट्रिंग हो सकता है। इन संरचनाओं को नस्ट किया जा सकता है।

• स्ट्रिंग : एक स्ट्रिंग शून्य या अधिक यूनिकोड वर्णों का एक क्रम है, जो बैकस्लैश एस्केप का उपयोग करके दोहरे उद्धरण चिह्नों में लिपटे हुए है। एक चरित्र को एकल वर्ण स्ट्रिंग के रूप में दर्शाया जाता है। एक स्ट्रिंग बहुत सी या जावा स्ट्रिंग की तरह है।

• संख्या : एक संख्या बहुत सी या जावा संख्या की तरह है, सिवाय इसके कि ऑक्टल और हेक्साडेसिमल स्वरूपों का उपयोग नहीं किया जाता है।

टिप्पणियों

पार्स सरल JSON ऑब्जेक्ट

निम्नलिखित JSON स्ट्रिंग पर विचार करें:

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

इस JSON ऑब्जेक्ट को निम्न कोड का उपयोग करके पार्स किया जा सकता है:

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

यहाँ JSONObject के अंदर नेस्टेड JSONArray के साथ एक और उदाहरण दिया गया है:

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

यह निम्नलिखित कोड के साथ पार्स किया जा सकता है:

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

एक साधारण JSON ऑब्जेक्ट बनाना

खाली JSONObject का उपयोग करके JSONObject बनाएं और put() विधि का उपयोग करके फ़ील्ड जोड़ें, जो अतिभारित है ताकि इसे विभिन्न प्रकारों के साथ उपयोग किया जा सके:

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

परिणामी JSON स्ट्रिंग इस तरह दिखता है:

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

JSONArray को 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();

परिणामी JSON स्ट्रिंग इस तरह दिखता है:

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

शून्य मान के साथ एक JSON स्ट्रिंग बनाएँ।

यदि आपको इस तरह null मान के साथ JSON स्ट्रिंग का उत्पादन करने की आवश्यकता है:

{  
   "name":null
}

फिर आपको विशेष स्थिरांक JSONObject.NULL का उपयोग करना होगा ।

समारोह का उदाहरण:

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

जन्स को पार्स करते समय नल-स्ट्रिंग के साथ काम करना

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

अगर हम इस तरह से उपयोग करेंगे:

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

हम उत्पादन होगा:

someString = "null";

इसलिए हमें यह समाधान प्रदान करने की आवश्यकता है:

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

और फिर कॉल करें:

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

और हम उम्मीद के मुताबिक आउटपुट देंगे:

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

JSONReader का उपयोग करके JSON को एक स्ट्रीम से पढ़ने के लिए

JsonReader टोकन की एक धारा के रूप में JSON एन्कोडेड मान पढ़ता है।

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

नेस्टेड JSON ऑब्जेक्ट बनाएँ

नेस्टेड JSON ऑब्जेक्ट का उत्पादन करने के लिए, आपको बस एक JSON ऑब्जेक्ट को दूसरे में जोड़ना होगा:

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 में पूरे requestObject साथ एक मुख्य नाम का claim होता है। मान के रूप में।

JSON प्रतिक्रिया के लिए गतिशील कुंजी को संभालना

यह एक उदाहरण है कि प्रतिक्रिया के लिए गतिशील कुंजी को कैसे संभालना है। यहां A और B गतिशील कुंजी हैं यह कुछ भी हो सकता है

प्रतिक्रिया

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

जावा कोड

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

JSON पर खेतों के अस्तित्व की जाँच करें

कभी-कभी यह जांचना उपयोगी होता है कि कोई कोड आपके JSON पर मौजूद है या आपके कोड पर कुछ JSONException से बचने के लिए अनुपस्थित है।

इसे प्राप्त करने के लिए, JSONObject#has(String) या विधि का उपयोग करें, जैसे निम्न उदाहरण पर:

नमूना JSON

{
   "name":"James"
}

जावा कोड

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".

JSON में तत्वों को अद्यतन करना

अद्यतन करने के लिए नमूना जॉनसन

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

Json में एलिमेंट्स वैल्यू अपडेट करने के लिए हमें वैल्यू असाइन करना और अपडेट करना होगा।

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

अद्यतन मूल्य

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