Java Language
जावा में JSON

परिचय

टिप्पणियों

JSON के रूप में डेटा एन्कोडिंग

यदि आपको एक JSONObject बनाने और उसमें डेटा डालने की आवश्यकता है, तो निम्न उदाहरण पर विचार करें:

// Create a new javax.json.JSONObject instance.
JSONObject first = new JSONObject();

first.put("foo", "bar");
first.put("temperature", 21.5);
first.put("year", 2016);

// Add a second object.
JSONObject second = new JSONObject();
second.put("Hello", "world");
first.put("message", second);

// Create a new JSONArray with some values
JSONArray someMonths = new JSONArray(new String[] { "January", "February" });
someMonths.put("March");
// Add another month as the fifth element, leaving the 4th element unset.
someMonths.put(4, "May");

// Add the array to our object
object.put("months", someMonths);

// Encode
String json = object.toString();

// An exercise for the reader: Add pretty-printing!
/* {
       "foo":"bar",
       "temperature":21.5,
       "year":2016,
       "message":{"Hello":"world"},
       "months":["January","February","March",null,"May"]
   }
*/

डिकसन JSON डेटा

यदि आपको JSONObject से डेटा प्राप्त करने की आवश्यकता है, तो निम्न उदाहरण पर विचार करें:

String json = "{\"foo\":\"bar\",\"temperature\":21.5,\"year\":2016,\"message\":{\"Hello\":\"world\"},\"months\":[\"January\",\"February\",\"March\",null,\"May\"]}";

// Decode the JSON-encoded string
JSONObject object = new JSONObject(json);

// Retrieve some values
String foo = object.getString("foo");
double temperature = object.getDouble("temperature");
int year = object.getInt("year");

// Retrieve another object
JSONObject secondary = object.getJSONObject("message");
String world = secondary.getString("Hello");

// Retrieve an array
JSONArray someMonths = object.getJSONArray("months");
// Get some values from the array
int nMonths = someMonths.length();
String february = someMonths.getString(1);

ऑप्टएक्सएक्सएक्सएक्स बनाम गेटएक्सएक्सएक्स तरीके

JSONObject और JSONArray में कुछ विधियां हैं जो इस संभावना से निपटने के दौरान बहुत उपयोगी हैं कि आपके द्वारा प्राप्त किए जाने वाले मूल्य का कोई अस्तित्व नहीं है या किसी अन्य प्रकार का है।

JSONObject obj = new JSONObject();
obj.putString("foo", "bar");

// For existing properties of the correct type, there is no difference
obj.getString("foo");        // returns "bar"
obj.optString("foo");        // returns "bar"
obj.optString("foo", "tux"); // returns "bar"

// However, if a value cannot be coerced to the required type, the behavior differs
obj.getInt("foo");      // throws JSONException
obj.optInt("foo");      // returns 0
obj.optInt("foo", 123); // returns 123

// Same if a property does not exist
obj.getString("undefined");        // throws JSONException
obj.optString("undefined");        // returns ""
obj.optString("undefined", "tux"); // returns "tux"

वही नियम के लिए लागू getXXX / optXXX के तरीकों JSONArray ।

JSON (Gson लाइब्रेरी) के लिए ऑब्जेक्ट

मान लें कि आपके पास एक वर्ग है जिसे सिर्फ name Person कहा जाता है

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

कोड:

Gson g = new Gson();

Person person = new Person("John");
System.out.println(g.toJson(person)); // {"name":"John"}

बेशक गन्स जार क्लासपाथ पर होना चाहिए।

JSON टू ऑब्जेक्ट (Gson लाइब्रेरी)

मान लें कि आपके पास एक वर्ग है जिसे सिर्फ name Person कहा जाता है

private class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

कोड:

Gson gson = new Gson();
String json = "{\"name\": \"John\"}";

Person person = gson.fromJson(json, Person.class);
System.out.println(person.name); //John

आपके पास अपने वर्गपथ में gson पुस्तकालय होना चाहिए।

JSON से एकल तत्व निकालें

String json = "{\"name\": \"John\", \"age\":21}";

JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();

System.out.println(jsonObject.get("name").getAsString()); //John
System.out.println(jsonObject.get("age").getAsInt()); //21

जैक्सन ऑब्जेक्ट मैपर का उपयोग करना

पूजो मॉडल

public class Model {
    private String firstName;
    private String lastName;
    private int age;
    /* Getters and setters not shown for brevity */        
}

उदाहरण: स्ट्रिंग टू ऑब्जेक्ट

Model outputObject = objectMapper.readValue(
     "{\"firstName\":\"John\",\"lastName\":\"Doe\",\"age\":23}",
     Model.class);
System.out.println(outputObject.getFirstName());
//result: John

उदाहरण: स्ट्रिंग के लिए वस्तु

String jsonString = objectMapper.writeValueAsString(inputObject));
//result: {"firstName":"John","lastName":"Doe","age":23}

विवरण

आयात विवरण आवश्यक:

import com.fasterxml.jackson.databind.ObjectMapper;

मावेन निर्भरता: जैक्सन-डेटाबाइंड

ObjectMapper उदाहरण

//creating one
ObjectMapper objectMapper = new ObjectMapper();

• ObjectMapper है
• अनुशंसित: एक साझा, स्थिर उदाहरण है

deserialization:

<T> T readValue(String content, Class<T> valueType)  

• valueType को निर्दिष्ट करने की आवश्यकता है - वापसी इस प्रकार की होगी
• फेंकता
  • IOException - निम्न-स्तरीय I / O समस्या के मामले में
  • JsonParseException - यदि अंतर्निहित इनपुट में अमान्य सामग्री है
  • JsonMappingException - यदि इनपुट JSON संरचना ऑब्जेक्ट संरचना से मेल नहीं खाती है

उपयोग उदाहरण (jsonString इनपुट स्ट्रिंग है):

Model fromJson = objectMapper.readValue(jsonString, Model.class);

क्रमांकन के लिए विधि:

स्ट्रिंग राइटवाल्यूएस्टएस्ट्रिंग (ऑब्जेक्ट मान)

• फेंकता
  • त्रुटि के मामले में JsonProcessingException
  • नोट: संस्करण 2.1 से पहले, थ्रो क्लॉज में IOException शामिल था; २.१ ने इसे हटा दिया।

JSON Iteration

JSONObject गुणों पर JSONObject

JSONObject obj = new JSONObject("{\"isMarried\":\"true\", \"name\":\"Nikita\", \"age\":\"30\"}");
Iterator<String> keys = obj.keys();//all keys: isMarried, name & age
while (keys.hasNext()) {                      //as long as there is another key
      String key = keys.next();               //get next key 
      Object value = obj.get(key);            //get next value by key
      System.out.println(key + " : " + value);//print key : value
}

JSONArray मान पर JSONArray

JSONArray arr = new JSONArray();        //Initialize an empty array
//push (append) some values in:
arr.put("Stack");
arr.put("Over");
arr.put("Flow");
for (int i = 0; i < arr.length(); i++) {//iterate over all values
    Object value = arr.get(i);          //get value
    System.out.println(value);          //print each value
}

JSON बिल्डर - तरीकों का पीछा करते हुए

आप JSONObject और JSONArray साथ काम करते समय विधि का उपयोग कर सकते हैं।

JSONObject उदाहरण

JSONObject obj = new JSONObject();//Initialize an empty JSON object 
//Before: {}
obj.put("name","Nikita").put("age","30").put("isMarried","true");
//After: {"name":"Nikita","age":30,"isMarried":true}

JSONArray

JSONArray arr = new JSONArray();//Initialize an empty array
//Before: []
arr.put("Stack").put("Over").put("Flow");
//After: ["Stack","Over","Flow"]

JSONObject.NULL

यदि आपको एक null मान के साथ एक संपत्ति जोड़ने की आवश्यकता है, तो आपको पूर्वनिर्धारित स्थिर अंतिम JSONObject.NULL उपयोग करना चाहिए और मानक जावा null संदर्भ का नहीं।

JSONObject.NULL एक प्रहरी मूल्य है जिसका उपयोग किसी रिक्त मान वाली संपत्ति को स्पष्ट रूप से परिभाषित करने के लिए किया जाता है।

JSONObject obj = new JSONObject();
obj.put("some", JSONObject.NULL);   //Creates: {"some":null}
System.out.println(obj.get("some"));//prints: null

ध्यान दें

JSONObject.NULL.equals(null); //returns true

जो Java.equals() अनुबंध का स्पष्ट उल्लंघन है:

किसी भी गैर-शून्य संदर्भ मान x के लिए, x.equals (नल) को गलत लौटना चाहिए

JsonArray से जावा सूची (Gson लाइब्रेरी)

यहाँ एक सरल JsonArray है, जिसे आप Java ArrayList बदलना चाहते हैं:

{
    "list": [
                "Test_String_1",
                "Test_String_2"
            ] 
}

अब JsonArray 'सूची' को निम्न विधि से पास करें जो एक संबंधित जावा ArrayList :

public ArrayList<String> getListString(String jsonList){
    Type listType = new TypeToken<List<String>>() {}.getType();
    //make sure the name 'list' matches the name of 'JsonArray' in your 'Json'.
    ArrayList<String> list = new Gson().fromJson(jsonList, listType);    
    return list;
}

आपको अपनी POM.xml फ़ाइल में निम्न POM.xml निर्भरता को जोड़ना चाहिए:

<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.7</version>
</dependency>

या आपके पास आपके classpath में jar com.google.code.gson:gson:jar:<version> होना चाहिए।

जैक्सन का उपयोग करके वस्तुओं के संग्रह के लिए JSON संग्रह का वर्णन करें

मान लीजिए कि आपके पास एक पॉज़ो क्लास Person

public class Person {
    public String name;

    public Person(String name) {
        this.name = name;
    }
}

और आप इसे JSON सरणी या व्यक्तिगत ऑब्जेक्ट के मानचित्र में पार्स करना चाहते हैं। प्रकार के क्षरण के कारण आप सीधे रनटाइम पर List<Person> और Map<String, Person> का निर्माण नहीं कर सकते हैं (और इस तरह उन्हें JSON का उपयोग करने के लिए उपयोग करें) । इस सीमा को पार करने के लिए TypeFactory दो दृष्टिकोण प्रदान करता है - TypeFactory और TypeReference ।

TypeFactory

यहां लिया गया दृष्टिकोण आपके लिए अपने प्रकार का निर्माण करने के लिए एक कारखाने (और इसकी स्थिर उपयोगिता फ़ंक्शन) का उपयोग करना है। जो पैरामीटर लेता है वह वह संग्रह होता है जिसका आप उपयोग करना चाहते हैं (सूची, सेट, आदि) और उस संग्रह में आप जिस वर्ग को संग्रहीत करना चाहते हैं।

TypeReference

प्रकार संदर्भ दृष्टिकोण सरल लगता है क्योंकि यह आपको टाइप करने में थोड़ा बचाता है और क्लीनर दिखता है। TypeReference एक प्रकार का पैरामीटर स्वीकार करता है, जहाँ आप वांछित प्रकार की List<Person> पास करते हैं List<Person> । आप बस इस TypeReference ऑब्जेक्ट को तुरंत टाइप करते हैं और इसे अपने टाइप कंटेनर के रूप में उपयोग करते हैं।

अब देखते हैं कि वास्तव में अपने JSON को जावा ऑब्जेक्ट में कैसे निष्क्रिय किया जाए। यदि आपके JSON को एक सरणी के रूप में स्वरूपित किया गया है, तो आप इसे सूची के रूप में दे सकते हैं। यदि कोई अधिक जटिल नेस्टेड संरचना है, तो आप मानचित्र के लिए डिसरिज़लाइज़ करना चाहेंगे। हम दोनों के उदाहरणों को देखेंगे।

JSON सरणी का वर्णन करना

String jsonString = "[{\"name\": \"Alice\"}, {\"name\": \"Bob\"}]"

टाइपफैक्ट दृष्टिकोण

CollectionType listType = 
    factory.constructCollectionType(List.class, Person.class);
List<Preson> list = mapper.readValue(jsonString, listType);

TypeReference दृष्टिकोण

TypeReference<Person> listType = new TypeReference<List<Person>>() {};
List<Person> list = mapper.readValue(jsonString, listType);

JSON के नक्शे का वर्णन करना

String jsonString = "{\"0\": {\"name\": \"Alice\"}, \"1\": {\"name\": \"Bob\"}}"

टाइपफैक्ट दृष्टिकोण

CollectionType mapType = 
    factory.constructMapLikeType(Map.class, String.class, Person.class);
List<Person> list = mapper.readValue(jsonString, mapType);

TypeReference दृष्टिकोण

TypeReference<Person> mapType = new TypeReference<Map<String, Person>>() {};
Map<String, Person> list = mapper.readValue(jsonString, mapType);

विवरण

उपयोग किए गए आयात विवरण:

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.CollectionType;

प्रयुक्त उदाहरण:

ObjectMapper mapper = new ObjectMapper();
TypeFactory factory = mapper.getTypeFactory();

ध्यान दें

जबकि TypeReference दृष्टिकोण बेहतर हो सकता है इसमें कई कमियां हैं:

1. TypeReference को अनाम वर्ग का उपयोग करके तत्काल किया जाना चाहिए
2. आपको सामान्य अन्वेषण प्रदान करना चाहिए

ऐसा करने में विफल रहने से जेनेरिक प्रकार के तर्क का नुकसान हो सकता है जो कि डीसेरिएलाइजेशन विफलता का कारण होगा।