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




parsing (19)

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

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

मेरे पास निम्नलिखित 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"
         }
    ]
}

  1. यदि कोई जेएसओएन से जावा वस्तु बनाना चाहता है और इसके विपरीत, जीएसओएन या जैक्सन थर्ड पार्टी जार इत्यादि का उपयोग करें।

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
    
  2. लेकिन अगर कोई सिर्फ JSON स्ट्रिंग को पार्स करना चाहता है और कुछ मान प्राप्त करना चाहता है, (या तार पर भेजने के लिए स्क्रैच से JSON स्ट्रिंग बनाएं) केवल जेवीईई जार का उपयोग करें जिसमें जेसन रीडर, जेसनएरे, जेसनऑब्जेक्ट इत्यादि शामिल हैं। आप इसका कार्यान्वयन डाउनलोड करना चाहेंगे javax.json की तरह कल्पना। इन दो जारों के साथ मैं जेसन को पार्स करने और मूल्यों का उपयोग करने में सक्षम हूं।

    ये एपीआई वास्तव में एक्सएमएल के डीओएम / एसएक्स पार्सिंग मॉडल का पालन करते हैं।

    Response response = request.get(); // REST call 
        JsonReader jsonReader = Json.createReader(new StringReader(response.readEntity(String.class)));
        JsonArray jsonArray = jsonReader.readArray();
        ListIterator l = jsonArray.listIterator();
        while ( l.hasNext() ) {
              JsonObject j = (JsonObject)l.next();
              JsonObject ciAttr = j.getJsonObject("ciAttributes");
    

आप 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 से मॉडल जेनरेट कर सकते हैं।


आप जेएसओएन स्ट्रिंग को पार्स करने के लिए जीसन लाइब्रेरी का उपयोग कर सकते हैं।

Gson gson = new Gson();
JsonObject jsonObject = gson.fromJson(jsonAsString, JsonObject.class);

String pageName = jsonObject.getAsJsonObject("pageInfo").get("pageName").getAsString();
String pagePic = jsonObject.getAsJsonObject("pageInfo").get("pagePic").getAsString();
String postId = jsonObject.getAsJsonArray("posts").get(0).getAsJsonObject().get("post_id").getAsString();

आप "पोस्ट" सरणी के माध्यम से भी लूप कर सकते हैं:

JsonArray posts = jsonObject.getAsJsonArray("posts");
for (JsonElement post : posts) {
  String postId = post.getAsJsonObject().get("post_id").getAsString();
  //do something
}

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

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

JSONObject jsonObj = new JSONObject(<jsonStr>);

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

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

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

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


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

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

जावा में कई 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.
    }
}

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


नीचे दिया गया उदाहरण दिखाता है कि प्रश्न में पाठ को कैसे पढ़ा जाए, जिसे "jsonText" चर के रूप में दर्शाया गया है। यह समाधान Java EE7 javax.json API का उपयोग करता है (जिसका उल्लेख कुछ अन्य उत्तरों में किया गया है)। एक अलग उत्तर के रूप में मैंने इसे जोड़ने का कारण यह है कि निम्न कोड दिखाता है कि प्रश्न में दिखाए गए कुछ मूल्यों को वास्तव में कैसे पहुंचाया जाए। इस कोड को चलाने के लिए javax.json API के कार्यान्वयन की आवश्यकता होगी। आवश्यक प्रत्येक कक्षा के लिए पूरा पैकेज शामिल था क्योंकि मैं "आयात" बयान घोषित नहीं करना चाहता था।

javax.json.JsonReader jr = 
    javax.json.Json.createReader(new StringReader(jsonText));
javax.json.JsonObject jo = jr.readObject();

//Read the page info.
javax.json.JsonObject pageInfo = jo.getJsonObject("pageInfo");
System.out.println(pageInfo.getString("pageName"));

//Read the posts.
javax.json.JsonArray posts = jo.getJsonArray("posts");
//Read the first post.
javax.json.JsonObject post = posts.getJsonObject(0);
//Read the post_id field.
String postId = post.getString("post_id");

अब, इससे पहले कि कोई भी इस जवाब को छोड़ देता है और डाउनवॉट करता है क्योंकि यह जीएसओएन, ऑर्ग.जसन, जैक्सन या किसी अन्य तृतीय पक्ष ढांचे का उपयोग नहीं करता है, यह प्रदान किए गए पाठ को पार्स करने के लिए प्रश्न के अनुसार "आवश्यक कोड" का एक उदाहरण है। मुझे अच्छी तरह से पता है कि वर्तमान मानक जेएसआर 353 का पालन जेडीके 9 के लिए नहीं माना जा रहा था और इस तरह के जेएसआर 353 स्पेक को किसी भी अन्य तृतीय पक्ष जेएसओएन हैंडलिंग कार्यान्वयन के समान माना जाना चाहिए।


मेरा मानना ​​है कि आधिकारिक जावा JSON एपीआई के माध्यम से जाने का सबसे अच्छा अभ्यास होना चाहिए जो अभी भी प्रगति पर काम कर रहे हैं।


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

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

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


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

विशेषताएं:

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

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

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

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>

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>

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

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

    }
}

`


One can use Apache @Model annotation to create Java model classes representing structure of JSON files and use them to access various elements in the JSON tree. Unlike other solutions this one works completely without reflection and is thus suitable for environments where reflection is impossible or comes with significant overhead.

There is a sample Maven project showing the usage. First of all it defines the structure:

@Model(className="RepositoryInfo", properties = {
    @Property(name = "id", type = int.class),
    @Property(name = "name", type = String.class),
    @Property(name = "owner", type = Owner.class),
    @Property(name = "private", type = boolean.class),
})
final class RepositoryCntrl {
    @Model(className = "Owner", properties = {
        @Property(name = "login", type = String.class)
    })
    static final class OwnerCntrl {
    }
}

and then it uses the generated RepositoryInfo and Owner classes to parse the provided input stream and pick certain information up while doing that:

List<RepositoryInfo> repositories = new ArrayList<>();
try (InputStream is = initializeStream(args)) {
    Models.parse(CONTEXT, RepositoryInfo.class, is, repositories);
}

System.err.println("there is " + repositories.size() + " repositories");
repositories.stream().filter((repo) -> repo != null).forEach((repo) -> {
    System.err.println("repository " + repo.getName() + 
        " is owned by " + repo.getOwner().getLogin()
    );
})

That is it! In addition to that here is a live gist showing similar example together with asynchronous network communication.


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 .


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

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

{
   "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
}




parsing