java जावा में JSON का विश्लेषण कैसे करें




parsing (23)

मेरे पास निम्नलिखित JSON टेक्स्ट है। pageName , pagePic , pagePic pageName पाने के लिए मैं इसे कैसे पार्स कर सकता हूं?

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

चूंकि किसी ने इसका अभी तक उल्लेख नहीं किया है, यहां Nashorn (जावा 8 का जावास्क्रिप्ट रनटाइम भाग) का उपयोग करके समाधान की शुरुआत है।

उपाय

private static final String EXTRACTOR_SCRIPT =
    "var fun = function(raw) { " +
    "var json = JSON.parse(raw); " +
    "return [json.pageInfo.pageName, json.pageInfo.pagePic, json.posts[0].post_id];};";

public void run() throws ScriptException, NoSuchMethodException {
    ScriptEngine engine = new ScriptEngineManager().getEngineByName("nashorn");
    engine.eval(EXTRACTOR_SCRIPT);
    Invocable invocable = (Invocable) engine;
    JSObject result = (JSObject) invocable.invokeFunction("fun", JSON);
    result.values().forEach(e -> System.out.println(e));
}

प्रदर्शन तुलना

मैंने JSON सामग्री को क्रमशः 20, 20 और 100 तत्वों के तीन सरणीएं लिखीं। मैं केवल तीसरे सरणी से 100 तत्व प्राप्त करना चाहता हूं। मैं पार्स करने के लिए निम्न जावास्क्रिप्ट फ़ंक्शन का उपयोग करता हूं और अपनी प्रविष्टियां प्राप्त करता हूं।

var fun = function(raw) {JSON.parse(raw).entries};

नैशर्न का उपयोग करके लाखों बार कॉल चलाने से 7.5 ~ 7.8 सेकंड लगते हैं

(JSObject) invocable.invokeFunction("fun", json);

org.json 20 ~ 21 सेकंड लेता है

new JSONObject(JSON).getJSONArray("entries");

जैक्सन 6.5 ~ 7 सेकंड लेता है

mapper.readValue(JSON, Entries.class).getEntries();

इस मामले में जैक्सन नैशर्न से बेहतर प्रदर्शन करता है, जो org.json से बेहतर प्रदर्शन करता है। नॉरॉर्न एपीआई org.json या जैक्सन की तुलना में उपयोग करना मुश्किल है। आपकी आवश्यकताओं के आधार पर जैक्सन और नैशर्न दोनों व्यावहारिक समाधान हो सकते हैं।


ब्याज की संपत्ति में मूल्य तक पहुंचने से पहले लगभग सभी उत्तरों को जेएसओएन के जावा ऑब्जेक्ट में पूर्ण deserialization की आवश्यकता होती है। एक और विकल्प, जो इस मार्ग पर नहीं जाता है, JsonPATH का उपयोग JsonPATH जो JsonPATH लिए JsonPATH की तरह है और जेएसओएन ऑब्जेक्ट्स के ट्रैवर्सिंग की अनुमति देता है।

यह एक विनिर्देश है और जयवे के अच्छे लोगों ने विनिर्देश के लिए जावा कार्यान्वयन बनाया है जिसे आप यहां पा सकते हैं: https://github.com/jayway/JsonPath

तो मूल रूप से इसका उपयोग करने के लिए, इसे अपनी परियोजना में जोड़ें, उदाहरण के लिए:

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>${version}</version>
</dependency>

और उपयोग करने के लिए:

String pageName = JsonPath.read(yourJsonString, "$.pageInfo.pageName");
String pagePic = JsonPath.read(yourJsonString, "$.pageInfo.pagePic");
String post_id = JsonPath.read(yourJsonString, "$.pagePosts[0].post_id");

आदि...

JSON ट्रांसवर्स करने के अन्य तरीकों के बारे में अधिक जानकारी के लिए जेसनपैथ विनिर्देश पृष्ठ देखें।


जावा में कई JSON पुस्तकालय उपलब्ध हैं।

सबसे कुख्यात लोग हैं: जैक्सन, जीएसओएन, जेन्सन, फास्टजसन और ऑर्ग.जेसन।

आमतौर पर किसी भी पुस्तकालय को चुनने के लिए तीन चीजें देखना चाहिए:

  1. प्रदर्शन
  2. उपयोग की आसानी (कोड लिखना और सुगम है) - जो सुविधाओं के साथ जाता है।
  3. मोबाइल ऐप्स के लिए: निर्भरता / जार आकार

विशेष रूप से जेएसओएन पुस्तकालयों (और किसी भी क्रमबद्धता / deserialization libs) के लिए, डाटाबेसिंग आमतौर पर ब्याज का है क्योंकि यह डेटा को पैक / अनपैक करने के लिए बॉयलर-प्लेट कोड लिखने की आवश्यकता को हटा देता है।

1 के लिए, यह बेंचमार्क देखें: github.com/fabienrenaud/java-json-benchmark मैंने JMH का उपयोग किया जो तुलना करता है (जैक्सन, जीसन, जेन्सन, फास्टजसन, ऑर्ग.जेसन, जेसनपी) स्ट्रीम का उपयोग करके धारावाहिक और deserializers का प्रदर्शन और डेटाबेस एपीआई। 2 के लिए, आप इंटरनेट पर कई उदाहरण पा सकते हैं। उपरोक्त बेंचमार्क का उपयोग उदाहरणों के स्रोत के रूप में भी किया जा सकता है ...

बेंचमार्क का त्वरित अधिग्रहण: जैक्सन org.json से 5 से 6 गुना बेहतर और जीएसओएन से दो गुना बेहतर प्रदर्शन करता है।

आपके विशेष उदाहरण के लिए, निम्न कोड जैक्सन के साथ आपके जेसन को डीकोड करता है:

public class MyObj {

    private PageInfo pageInfo;
    private List<Post> posts;

    static final class PageInfo {
        private String pageName;
        private String pagePic;
    }

    static final class Post {
        private String post_id;
        @JsonProperty("actor_id");
        private String actorId;
        @JsonProperty("picOfPersonWhoPosted")
        private String pictureOfPoster;
        @JsonProperty("nameOfPersonWhoPosted")
        private String nameOfPoster;
        private String likesCount;
        private List<String> comments;
        private String timeOfPost;
    }

    private static final ObjectMapper JACKSON = new ObjectMapper();
    public static void main(String[] args) throws IOException {
        MyObj o = JACKSON.readValue(args[0], MyObj.class); // assumes args[0] contains your json payload provided in your question.
    }
}

अगर आपका कोई प्रश्न हैं, तो मुझे से पूछें।


You can use Jayway JsonPath . Below is a GitHub link with source code, pom details and good documentation.

https://github.com/jayway/JsonPath

Please follow the below steps.

Step 1 : Add the jayway JSON path dependency in your class path using Maven or download the JAR file and manually add it.

<dependency>
            <groupId>com.jayway.jsonpath</groupId>
            <artifactId>json-path</artifactId>
            <version>2.2.0</version>
</dependency>

Step 2 : Please save your input JSON as a file for this example. In my case I saved your JSON as sampleJson.txt. Note you missed a comma between pageInfo and posts.

Step 3 : Read the JSON contents from the above file using bufferedReader and save it as String.

BufferedReader br = new BufferedReader(new FileReader("D:\\sampleJson.txt"));

        StringBuilder sb = new StringBuilder();
        String line = br.readLine();

        while (line != null) {
            sb.append(line);
            sb.append(System.lineSeparator());
            line = br.readLine();
        }
        br.close();
        String jsonInput = sb.toString();

Step 4 : Parse your JSON string using jayway JSON parser.

Object document = Configuration.defaultConfiguration().jsonProvider().parse(jsonInput);

Step 5 : Read the details like below.

String pageName = JsonPath.read(document, "$.pageInfo.pageName");
String pagePic = JsonPath.read(document, "$.pageInfo.pagePic");
String post_id = JsonPath.read(document, "$.posts[0].post_id");

System.out.println("$.pageInfo.pageName " + pageName);
System.out.println("$.pageInfo.pagePic " + pagePic);
System.out.println("$.posts[0].post_id " + post_id);

The output will be :

$.pageInfo.pageName = abc
$.pageInfo.pagePic = http://example.com/content.jpg
$.posts[0].post_id  = 123456789012_123456789012

जीसन सीखना और कार्यान्वित करना आसान है, जिसे हमें जानने की जरूरत है, दो विधियों का पालन कर रहे हैं

  • toJson () - जावा ऑब्जेक्ट को JSON प्रारूप में कनवर्ट करें

  • से जेसन () - जेएसओएन जावा ऑब्जेक्ट में कनवर्ट करें

`

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import com.google.gson.Gson;

public class GsonExample {
    public static void main(String[] args) {

    Gson gson = new Gson();

    try {

        BufferedReader br = new BufferedReader(
            new FileReader("c:\\file.json"));

        //convert the json string back to object
        DataObject obj = gson.fromJson(br, DataObject.class);

        System.out.println(obj);

    } catch (IOException e) {
        e.printStackTrace();
    }

    }
}

`


First you need to select an implementation library to do that.

The Java API for JSON Processing (JSR 353) provides portable APIs to parse, generate, transform, and query JSON using object model and streaming APIs.

The reference implementation is here: https://jsonp.java.net/

Here you can find a list of implementations of JSR 353:

What are the API that does implement JSR-353 (JSON)

And to help you decide ... I found this article as well:

http://blog.takipi.com/the-ultimate-json-library-json-simple-vs-gson-vs-jackson-vs-json/

If you go for Jackson, here is a good article about conversion between JSON to/from Java using Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

Hope it helps!


यह मेरे दिमाग को उड़ा दिया कि यह कितना आसान था। आप डिफ़ॉल्ट रूप से org.json पैकेज में JSONObject के निर्माता को अपने JSON को रखने वाली String पास कर सकते हैं।

JSONArray rootOfPage =  new JSONArray(JSONString);

किया हुआ। माइक्रोफोन ड्रॉप यह JSONObjects साथ भी काम करता है। उसके बाद, आप अपनी ऑब्जेक्ट्स पर get() विधियों का उपयोग करके Objects अपने पदानुक्रम को देख सकते हैं।


Top answers on this page use too simple examples like object with one property (eg {name: value}). I think that still simple but real life example can help someone.

So this is the JSON returned by Google Translate API:

{
  "data": 
     {
        "translations": 
          [
            {
              "translatedText": "Arbeit"
             }
          ]
     }
}

I want to retrieve the value of "translatedText" attribute eg "Arbeit" using Google's Gson.

Two possible approaches:

  1. Retrieve just one needed attribute

    String json  = callToTranslateApi("work", "de");
    JsonObject jsonObject = new JsonParser().parse(json).getAsJsonObject();
    return jsonObject.get("data").getAsJsonObject()
            .get("translations").getAsJsonArray()
            .get(0).getAsJsonObject()
            .get("translatedText").getAsString();
    
  2. Create Java object from JSON

    class ApiResponse {
        Data data;      
        class Data {
            Translation[] translations;         
            class Translation {
                String translatedText;
            }
         }
     }
    

    ...

     Gson g = new Gson();
     String json =callToTranslateApi("work", "de");
     ApiResponse response = g.fromJson(json, ApiResponse.class);
     return response.data.translations[0].translatedText;
    

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

Java code :

JSONObject obj = new JSONObject(responsejsonobj);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......etc
}

org.json लाइब्रेरी का उपयोग करना आसान है। नीचे उदाहरण कोड:

import org.json.*;


JSONObject obj = new JSONObject(" .... ");
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts");
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

आप जावा में पार्स JSON से अतिरिक्त उदाहरण पा सकते हैं

डाउनलोड करने योग्य जार: http://mvnrepository.com/artifact/org.json/json


किसी ऑब्जेक्ट पर JSON सामग्री को पार्स करने के लिए या JSON मानों को पढ़ने के लिए कई ओपन सोर्स लाइब्रेरी मौजूद हैं। आपकी आवश्यकता केवल मूल्यों को पढ़ने और इसे कस्टम ऑब्जेक्ट पर पार्स करने के लिए है। तो org.json लाइब्रेरी आपके मामले में पर्याप्त है।

Orse.json लाइब्रेरी का प्रयोग इसे पार्स करने के लिए करें और जेसनऑब्जेक्ट बनाएं:

JSONObject jsonObj = new JSONObject(<jsonStr>);

अब, अपने मूल्य प्राप्त करने के लिए इस ऑब्जेक्ट का उपयोग करें:

String id = jsonObj.getString("pageInfo");

आप यहां एक पूरा उदाहरण देख सकते हैं:

जावा में JSON का विश्लेषण कैसे करें


minimal-json प्रयोग करें जो बहुत तेज़ और उपयोग करने में आसान है। आप स्ट्रिंग ओबीजे और स्ट्रीम से पार्स कर सकते हैं।

नमूना डेटा:

{
  "order": 4711,
  "items": [
    {
      "name": "NE555 Timer IC",
      "cat-id": "645723",
      "quantity": 10,
    },
    {
      "name": "LM358N OpAmp IC",
      "cat-id": "764525",
      "quantity": 2
    }
  ]
}

पार्सिंग:

JsonObject object = Json.parse(input).asObject();
int orders = object.get("order").asInt();
JsonArray items = object.get("items").asArray();

जेएसओएन बनाना:

JsonObject user = Json.object().add("name", "Sakib").add("age", 23);

Maven:

<dependency>
  <groupId>com.eclipsesource.minimal-json</groupId>
  <artifactId>minimal-json</artifactId>
  <version>0.9.4</version>
</dependency>

अन्य उत्तरों के अलावा, मैं जीएसओएन, जैक्सन 1.x या जैक्सन 2.x के लिए जेसन या जेसन स्कीमा से त्वरित जेनरेटिंग जावा कक्षाओं के लिए इस ऑनलाइन ओपनसोर्स सेवा this सिफारिश करता हूं। उदाहरण के लिए, यदि आपके पास है:

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": 1234567890,
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": 2,
              "comments": [],
              "timeOfPost": 1234567890
         }
    ]
}

this लिए jsonschema2pojo.org उत्पन्न:

@Generated("org.jsonschema2pojo")
public class Container {
    @SerializedName("pageInfo")
    @Expose
    public PageInfo pageInfo;
    @SerializedName("posts")
    @Expose
    public List<Post> posts = new ArrayList<Post>();
}

@Generated("org.jsonschema2pojo")
public class PageInfo {
    @SerializedName("pageName")
    @Expose
    public String pageName;
    @SerializedName("pagePic")
    @Expose
    public String pagePic;
}

@Generated("org.jsonschema2pojo")
public class Post {
    @SerializedName("post_id")
    @Expose
    public String postId;
    @SerializedName("actor_id")
    @Expose
    public long actorId;
    @SerializedName("picOfPersonWhoPosted")
    @Expose
    public String picOfPersonWhoPosted;
    @SerializedName("nameOfPersonWhoPosted")
    @Expose
    public String nameOfPersonWhoPosted;
    @SerializedName("message")
    @Expose
    public String message;
    @SerializedName("likesCount")
    @Expose
    public long likesCount;
    @SerializedName("comments")
    @Expose
    public List<Object> comments = new ArrayList<Object>();
    @SerializedName("timeOfPost")
    @Expose
    public long timeOfPost;
}

We can use the JSONObject class to convert a JSON string to a JSON object, and to iterate over the JSON object. Use the following code.

JSONObject jObj = new JSONObject(contents.trim());
Iterator<?> keys = jObj.keys();

while( keys.hasNext() ) {
  String key = (String)keys.next();
  if ( jObj.get(key) instanceof JSONObject ) {           
    System.out.println(jObj.getString(String key));
  }
}

क्विक-जेसन पार्सर बहुत सरल, लचीला, बहुत तेज और अनुकूलन योग्य है। कोशिश करो

विशेषताएं:

  • जेएसओएन विनिर्देश के साथ अनुपालन (आरएफसी 4627)
  • उच्च प्रदर्शन JSON पार्सर
  • लचीला / विन्यास योग्य पार्सिंग दृष्टिकोण का समर्थन करता है
  • किसी भी JSON पदानुक्रम के कुंजी / मूल्य जोड़े के कॉन्फ़िगर करने योग्य सत्यापन
  • उपयोग करने में आसान # बहुत छोटा पदचिह्न
  • डेवलपर अनुकूल और अपवादों का पता लगाने में आसान बनाता है
  • प्लग करने योग्य कस्टम सत्यापन समर्थन - कुंजी / मानों को कस्टम सत्यापनकर्ताओं को कॉन्फ़िगर करके सत्यापित किया जा सकता है
  • प्रमाणीकरण और गैर-मान्य पार्सर समर्थन
  • त्वरित-JSON सत्यापन पार्सर का उपयोग करने के लिए दो प्रकार के कॉन्फ़िगरेशन (JSON / XML) के लिए समर्थन
  • जेडीके 1.5 की आवश्यकता है
  • बाहरी पुस्तकालयों पर कोई निर्भरता नहीं
  • ऑब्जेक्ट क्रमबद्धता के माध्यम से JSON जनरेशन के लिए समर्थन
  • पार्सिंग प्रक्रिया के दौरान संग्रह प्रकार चयन के लिए समर्थन

इसका इस्तेमाल इस तरह किया जा सकता है:

JsonParserFactory factory=JsonParserFactory.getInstance();
JSONParser parser=factory.newJsonParser();
Map jsonMap=parser.parseJson(jsonString);

आप Google जीसन का उपयोग कर सकते हैं।

इस पुस्तकालय का उपयोग करने के लिए आपको केवल उसी JSON संरचना के साथ एक मॉडल बनाने की आवश्यकता है। फिर मॉडल स्वचालित रूप से भर जाता है। आपको अपने चर को अपने JSON कुंजी के रूप में कॉल करना होगा, या @SerializedName का उपयोग करना होगा यदि आप अलग-अलग नामों का उपयोग करना चाहते हैं।

आपके उदाहरण के लिए:

JSON:

{
"pageInfo": {
     "pageName": "abc",
     "pagePic": "http://example.com/content.jpg"
}
"posts": [
     {
          "post_id": "123456789012_123456789012",
          "actor_id": "1234567890",
          "picOfPersonWhoPosted": "http://example.com/photo.jpg",
          "nameOfPersonWhoPosted": "Jane Doe",
          "message": "Sounds cool. Can't wait to see it!",
          "likesCount": "2",
          "comments": [],
          "timeOfPost": "1234567890"
     }
]

}

आदर्श:

class MyModel {

    private PageInfo pageInfo;
    private ArrayList<Post> posts = new ArrayList<>();
}

class PageInfo {

    private String pageName;
    private String pagePic;
}

class Post {

    private String post_id;

    @SerializedName("actor_id") // <- example SerializedName
    private String actorId;

    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private String likesCount;
    private ArrayList<String> comments;
    private String timeOfPost;
}

अब आप जीसन लाइब्रेरी का उपयोग कर पार्स कर सकते हैं:

MyModel model = gson.fromJson(jsonString, MyModel.class);

आप this तरह के ऑनलाइन टूल्स का उपयोग कर स्वचालित रूप से JSON से मॉडल जेनरेट कर सकते हैं।


यदि आपके पास JSON स्ट्रिंग (jsonString) का प्रतिनिधित्व करने वाला कुछ जावा क्लास (संदेश कहें) है, तो आप Jackson JSON लाइब्रेरी का उपयोग कर सकते हैं:

Message message= new ObjectMapper().readValue(jsonString, Message.class);

और संदेश ऑब्जेक्ट से आप इसकी कोई भी विशेषता प्राप्त कर सकते हैं।


ए - स्पष्टीकरण

आप जेएसओएन स्ट्रिंग को पीओजेओ ( सादा ओल्ड जावा ऑब्जेक्ट ) उदाहरणों में बाध्य करने के लिए जैक्सन पुस्तकालयों का उपयोग कर सकते हैं। पीओजेओ केवल एक निजी वर्ग और सार्वजनिक गेटर / सेटर विधियों के साथ एक वर्ग है। जैक्सन विधियों ( प्रतिबिंब का उपयोग करके) को पार करने जा रहा है, और जेएसओएन ऑब्जेक्ट को पीओजेओ इंस्टेंस में मैप करता है क्योंकि वर्ग के फील्ड नाम JSON ऑब्जेक्ट के फील्ड नामों के साथ फिट बैठते हैं।

आपके JSON ऑब्जेक्ट में, जो वास्तव में एक समग्र वस्तु है, मुख्य वस्तु में दो उप-ऑब्जेक्ट होते हैं। तो, हमारे पीओजेओ कक्षाओं में एक ही पदानुक्रम होना चाहिए। मैं पूरे जेएसओएन ऑब्जेक्ट को पेज ऑब्जेक्ट के रूप में कॉल करूंगा। पेज ऑब्जेक्ट में पेजइन्फो ऑब्जेक्ट, और एक पोस्ट ऑब्जेक्ट सरणी शामिल है।

तो हमें तीन अलग-अलग पीओजेओ कक्षाएं बनाना है;

  • पेज क्लास, पेजइन्फो क्लास का एक समग्र और पोस्ट इंस्टेंस की सरणी
  • पेजइन्फो क्लास
  • डाक कक्षा

जैक्सन ऑब्जेक्टमैपर का उपयोग करने वाला एकमात्र पैकेज है, हम जो करते हैं वह बाध्यकारी डेटा है;

com.fasterxml.jackson.databind.ObjectMapper

आवश्यक निर्भरता, जार फ़ाइलों को नीचे सूचीबद्ध किया गया है;

  • जैक्सन कोर-2.5.1.jar
  • जैक्सन-DataBind-2.5.1.jar
  • जैक्सन-एनोटेशन-2.5.0.jar

आवश्यक कोड यहां है;

बी - मुख्य पीओजेओ कक्षा: पृष्ठ

package com.levo.jsonex.model;

public class Page {

    private PageInfo pageInfo;
    private Post[] posts;

    public PageInfo getPageInfo() {
        return pageInfo;
    }

    public void setPageInfo(PageInfo pageInfo) {
        this.pageInfo = pageInfo;
    }

    public Post[] getPosts() {
        return posts;
    }

    public void setPosts(Post[] posts) {
        this.posts = posts;
    }

}

सी - चाइल्ड पीओजेओ क्लास: पेजइन्फो

package com.levo.jsonex.model;

public class PageInfo {

    private String pageName;
    private String pagePic;

    public String getPageName() {
        return pageName;
    }

    public void setPageName(String pageName) {
        this.pageName = pageName;
    }

    public String getPagePic() {
        return pagePic;
    }

    public void setPagePic(String pagePic) {
        this.pagePic = pagePic;
    }

}

डी - चाइल्ड पीओजेओ कक्षा: पोस्ट

package com.levo.jsonex.model;

public class Post {

    private String post_id;
    private String actor_id;
    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private int likesCount;
    private String[] comments;
    private int timeOfPost;

    public String getPost_id() {
        return post_id;
    }

    public void setPost_id(String post_id) {
        this.post_id = post_id;
    }

    public String getActor_id() {
        return actor_id;
    }

    public void setActor_id(String actor_id) {
        this.actor_id = actor_id;
    }

    public String getPicOfPersonWhoPosted() {
        return picOfPersonWhoPosted;
    }

    public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
        this.picOfPersonWhoPosted = picOfPersonWhoPosted;
    }

    public String getNameOfPersonWhoPosted() {
        return nameOfPersonWhoPosted;
    }

    public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
        this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getLikesCount() {
        return likesCount;
    }

    public void setLikesCount(int likesCount) {
        this.likesCount = likesCount;
    }

    public String[] getComments() {
        return comments;
    }

    public void setComments(String[] comments) {
        this.comments = comments;
    }

    public int getTimeOfPost() {
        return timeOfPost;
    }

    public void setTimeOfPost(int timeOfPost) {
        this.timeOfPost = timeOfPost;
    }

}

ई - नमूना JSON फ़ाइल: sampleJSONFile.json

मैंने अभी आपके JSON नमूने को इस फ़ाइल में कॉपी किया है और इसे प्रोजेक्ट फ़ोल्डर के नीचे रखा है।

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    },
    "posts": [
         {
              "post_id": "123456789012_123456789012",
              "actor_id": "1234567890",
              "picOfPersonWhoPosted": "http://example.com/photo.jpg",
              "nameOfPersonWhoPosted": "Jane Doe",
              "message": "Sounds cool. Can't wait to see it!",
              "likesCount": "2",
              "comments": [],
              "timeOfPost": "1234567890"
         }
    ]
}

एफ - डेमो कोड

package com.levo.jsonex;

import java.io.File;
import java.io.IOException;
import java.util.Arrays;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.levo.jsonex.model.Page;
import com.levo.jsonex.model.PageInfo;
import com.levo.jsonex.model.Post;

public class JSONDemo {

    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            Page page = objectMapper.readValue(new File("sampleJSONFile.json"), Page.class);

            printParsedObject(page);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    private static void printParsedObject(Page page) {
        printPageInfo(page.getPageInfo());
        System.out.println();
        printPosts(page.getPosts());
    }

    private static void printPageInfo(PageInfo pageInfo) {
        System.out.println("Page Info;");
        System.out.println("**********");
        System.out.println("\tPage Name : " + pageInfo.getPageName());
        System.out.println("\tPage Pic  : " + pageInfo.getPagePic());
    }

    private static void printPosts(Post[] posts) {
        System.out.println("Page Posts;");
        System.out.println("**********");
        for(Post post : posts) {
            printPost(post);
        }
    }

    private static void printPost(Post post) {
        System.out.println("\tPost Id                   : " + post.getPost_id());
        System.out.println("\tActor Id                  : " + post.getActor_id());
        System.out.println("\tPic Of Person Who Posted  : " + post.getPicOfPersonWhoPosted());
        System.out.println("\tName Of Person Who Posted : " + post.getNameOfPersonWhoPosted());
        System.out.println("\tMessage                   : " + post.getMessage());
        System.out.println("\tLikes Count               : " + post.getLikesCount());
        System.out.println("\tComments                  : " + Arrays.toString(post.getComments()));
        System.out.println("\tTime Of Post              : " + post.getTimeOfPost());
    }

}

जी - डेमो आउटपुट

Page Info;
****(*****
    Page Name : abc
    Page Pic  : http://example.com/content.jpg
Page Posts;
**********
    Post Id                   : 123456789012_123456789012
    Actor Id                  : 1234567890
    Pic Of Person Who Posted  : http://example.com/photo.jpg
    Name Of Person Who Posted : Jane Doe
    Message                   : Sounds cool. Can't wait to see it!
    Likes Count               : 2
    Comments                  : []
    Time Of Post              : 1234567890

उदाहरण के लिए मान लीजिए कि आपके पास सिर्फ एक name वाला क्लास Person

private class Person {
    public String name;

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

Google जीएसओएन ( मेवेन )

ऑब्जेक्ट्स के महान JSON serialization / de-serialization के रूप में मेरा व्यक्तिगत पसंदीदा।

Gson g = new Gson();

Person person = g.fromJson("{\"name\": \"John\"}", Person.class);
System.out.println(person.name); //John

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

अद्यतन करें

यदि आप एक एकल विशेषता प्राप्त करना चाहते हैं तो आप इसे आसानी से Google लाइब्रेरी के साथ भी कर सकते हैं:

JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject();

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

org.json ( org.json )

यदि आपको ऑब्जेक्ट डी-सीरियलाइज़ेशन की आवश्यकता नहीं है लेकिन केवल एक विशेषता प्राप्त करने के लिए, आप org.json ( या ऊपर GSON उदाहरण देखें! ) आज़मा सकते हैं।

JSONObject obj = new JSONObject("{\"name\": \"John\"}");

System.out.println(obj.getString("name")); //John

Jackson ( Maven )

ObjectMapper mapper = new ObjectMapper();
Person user = mapper.readValue("{\"name\": \"John\"}", Person.class);

System.out.println(user.name); //John

I have JSON like this:

{
   "pageInfo": {
         "pageName": "abc",
         "pagePic": "http://example.com/content.jpg"
    }
}

Java class

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Code for converting this JSON to a Java class.

    PageInfo pageInfo = JsonPath.parse(jsonString).read("$.pageInfo", PageInfo.class);

Maven

<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>2.2.0</version>
</dependency>

कृपया ऐसा कुछ करें:

JSONParser jsonParser = new JSONParser();
JSONObject obj = (JSONObject) jsonParser.parse(contentString);
String product = (String) jsonObject.get("productId");

Read the following blog post, JSON in Java .

This post is a little bit old, but still I want to answer you question.

Step 1: Create a POJO class of your data.

Step 2: Now create a object using JSON.

Employee employee = null;
ObjectMapper mapper = new ObjectMapper();
try{
    employee =  mapper.readValue(newFile("/home/sumit/employee.json"), Employee.class);
} 
catch (JsonGenerationException e){
    e.printStackTrace();
}

For further reference you can refer to the following link .


You can use JsonNode for a structured tree representation of your JSON string. It's part of the rock solid Jackson which is omnipresent.

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");






parsing