read Wie man JSON in Java parsen kann




java read json file (23)

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!

Ich habe den folgenden JSON-Text. Wie kann ich es analysieren, um pageName , pagePic , post_id usw. zu erhalten?

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

Quick-Json Parser ist sehr einfach, flexibel, sehr schnell und anpassbar. Versuch es

Eigenschaften:

  • Konform mit der JSON-Spezifikation (RFC4627)
  • Hochleistungs-JSON-Parser
  • Unterstützt flexiblen / konfigurierbaren Parsing-Ansatz
  • Konfigurierbare Validierung von Schlüssel / Wert-Paaren beliebiger JSON-Hierarchie
  • Einfach zu bedienen # Sehr kleiner Platzbedarf
  • Hebt entwicklerfreundliche und leicht nachvollziehbare Ausnahmen auf
  • Pluggable Custom Validation-Unterstützung - Schlüssel / Werte können überprüft werden, indem benutzerdefinierte Validatoren nach Bedarf konfiguriert werden
  • Validierung und Nicht-Validierung von Parser-Unterstützung
  • Unterstützung für zwei Konfigurationstypen (JSON / XML) für die Verwendung von Quick-JSON Validierungs-Parser
  • Benötigt JDK 1.5
  • Keine Abhängigkeit von externen Bibliotheken
  • Unterstützung für die JSON-Generierung durch Objektserialisierung
  • Unterstützung für die Auswahl des Sammlertyps während des Analyseprozesses

Es kann so verwendet werden:

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

Die org.json Bibliothek ist einfach zu verwenden. Beispielcode unten:

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

Weitere Beispiele finden Sie unter: JSON in Java parsen

Herunterladbares JAR: http://mvnrepository.com/artifact/org.json/json


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.


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;
    

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

Das hat mich umgehauen, wie einfach es war. Sie können einfach einen String mit Ihrem JSON an den Konstruktor eines JSONObject im Standardpaket org.json übergeben.

JSONArray rootOfPage =  new JSONArray(JSONString);

Erledigt. Lässt das Mikrofon fallen . Dies funktioniert auch mit JSONObjects . Danach können Sie mit Hilfe der Methoden get() für Ihre Objekte einfach durch Ihre Objekthierarchie Objects .


Sie können die Gson-Bibliothek zum Analysieren der JSON-Zeichenfolge verwenden.

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

Sie können auch das "posts" -Array wie folgt durchlaufen:

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

Zusätzlich zu anderen Antworten empfehle ich diesen Online- this Dienst this zum schnellen Generieren von Java-Klassen aus dem JSON- oder JSON-Schema für GSON, Jackson 1.x oder Jackson 2.x. Zum Beispiel, wenn Sie:

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

Das this für GSON generiert:

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

Fast alle gegebenen Antworten erfordern eine vollständige Deserialisierung des JSON in ein Java-Objekt, bevor auf den Wert in der Eigenschaft von Interesse zugegriffen wird. Eine andere Alternative, die diese Route nicht verwendet, ist die Verwendung von JsonPATH das wie XPath für JSON ist und das Durchqueren von JSON-Objekten ermöglicht.

Es ist eine Spezifikation und die guten Leute bei JayWay haben eine Java-Implementierung für die Spezifikation erstellt, die Sie hier finden können: https://github.com/jayway/JsonPath

Also im Grunde, um es zu verwenden, fügen Sie es Ihrem Projekt hinzu, zB:

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

und zu verwenden:

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

etc...

Weitere Informationen zu den anderen Möglichkeiten zum Query-JSON finden Sie auf der JsonPath-Spezifikationsseite.


Gson ist einfach zu erlernen und zu implementieren, was wir wissen müssen, sind zwei Methoden

  • toJson () - Java-Objekt in JSON-Format konvertieren

  • fromJson () - JSON in Java-Objekt konvertieren

`

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

    }
}

`


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

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>

Bitte tun Sie etwas wie folgt:

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

A - Erklärung

Sie können Jackson- Bibliotheken verwenden, um JSON-String in POJO- Instanzen ( Plain Old Java Object ) zu binden. POJO ist einfach eine Klasse mit nur privaten Feldern und öffentlichen Getter / Setter-Methoden. Jackson wird die Methoden durchlaufen (unter Verwendung von Reflektion ) und ordnet das JSON-Objekt der POJO-Instanz zu, da die Feldnamen der Klasse zu den Feldnamen des JSON-Objekts passen.

In Ihrem JSON-Objekt, das eigentlich ein zusammengesetztes Objekt ist, besteht das Hauptobjekt aus zwei Unterobjekten. Unsere POJO-Klassen sollten also die gleiche Hierarchie haben. Ich werde das gesamte JSON-Objekt als Page- Objekt aufrufen. Das Seitenobjekt besteht aus einem PageInfo- Objekt und einem Post- Objekt-Array.

Also müssen wir drei verschiedene POJO-Klassen erstellen;

  • Seitenklasse , eine Kombination aus PageInfo- Klasse und Array von Post- Instanzen
  • PageInfo- Klasse
  • Beiträge Klasse

Das einzige Paket, das ich benutzt habe, ist Jackson ObjectMapper, was wir tun, ist Daten zu binden;

com.fasterxml.jackson.databind.ObjectMapper

Die erforderlichen Abhängigkeiten, die JAR-Dateien, sind unten aufgeführt;

  • jackson-core-2.5.1.jar
  • jackson-databind-2.5.1.jar
  • jackson-Anmerkungen-2.5.0.jar

Hier ist der erforderliche Code;

B - Haupt POJO Klasse:

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

}

C - Child POJO Klasse: PageInfo

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

}

D - Kind POJO Klasse: Posten

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

}

E - Beispiel-JSON-Datei: sampleJSONFile.json

Ich habe gerade Ihr JSON-Beispiel in diese Datei kopiert und unter dem Projektordner abgelegt.

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

F - Democode

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

}

G - Demoausgabe

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

Da es noch niemand erwähnt hat, hier ein Anfang einer Lösung mit Nashorn (JavaScript-Laufzeitkomponente von Java 8).

Lösung

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

Leistungsvergleich

Ich schrieb JSON-Inhalt mit drei Arrays von jeweils 20, 20 und 100 Elementen. Ich möchte nur die 100 Elemente aus dem dritten Array bekommen. Ich verwende die folgende JavaScript-Funktion, um meine Einträge zu analysieren und abzurufen.

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

Wenn der Anruf eine Million Mal mit Nashorn ausgeführt wird, dauert es 7,5 ~ 7,8 Sekunden

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

org.json dauert 20 ~ 21 Sekunden

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

Jackson braucht 6,5 ~ 7 Sekunden

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

In diesem Fall ist Jackson besser als Nashorn, was viel besser ist als org.json. Nashorn API ist schwieriger zu verwenden als Org.jsons oder Jacksons. Abhängig von Ihren Anforderungen können Jackson und Nashorn beide brauchbare Lösungen sein.


Für das Beispiel nehmen wir an, Sie haben eine Klasse Person mit nur einem name .

private class Person {
    public String name;

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

Google GSON ( Maven )

Mein persönlicher Favorit bezüglich der großartigen JSON-Serialisierung / -Derialisierung von Objekten.

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

Aktualisieren

Wenn Sie ein einzelnes Attribut erhalten möchten, können Sie dies auch mit der Google-Bibliothek tun:

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

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

org.json ( http://mvnrepository.com/artifact/org.json/json )

Wenn Sie keine Objekt-Deserialisierung benötigen, sondern einfach ein Attribut erhalten, können Sie org.json ausprobieren ( oder schauen Sie sich das obige GSON-Beispiel an! )

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

Wenn Sie eine Java-Klasse (zB Message) haben, die die JSON-Zeichenfolge (jsonString) darstellt, können Sie die Jackson JSON-Bibliothek verwenden mit:

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

und vom Nachrichtenobjekt können Sie eines seiner Attribute abrufen.


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

Das folgende Beispiel zeigt, wie der Text in der Frage gelesen wird, dargestellt als "jsonText" -Variable. Diese Lösung verwendet die Java-EE7- javax.json API (die in einigen anderen Antworten erwähnt wird). Der Grund, warum ich es als separate Antwort hinzugefügt habe, ist, dass der folgende Code zeigt, wie man tatsächlich auf einige der in der Frage gezeigten Werte zugreift. Eine Implementierung der javax.json-API wäre erforderlich, um diesen Code auszuführen. Das vollständige Paket für jede der erforderlichen Klassen wurde eingefügt, da ich keine "Import" -Anweisungen deklarieren wollte.

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

Nun, bevor jemand diese Antwort beantwortet und downvotes, weil er GSON, org.json, Jackson oder eines der anderen verfügbaren Drittanbieter-Frameworks nicht verwendet, ist es ein Beispiel für "erforderlichen Code" pro Frage, um den bereitgestellten Text zu parsen. Ich bin mir bewusst, dass die Einhaltung des aktuellen Standards JSR 353 für JDK 9 nicht in Betracht gezogen wurde, und daher sollte die JSR 353-Spezifikation wie jede andere JSON-Handhabungsimplementierung von Drittanbietern behandelt werden.


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 .


  1. Wenn Sie ein JAVA-Objekt von JSON und umgekehrt erstellen möchten, verwenden Sie GSON- oder JACKSON-Drittanbieter-Jars usw.

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
    
  2. Aber wenn man nur eine JSON-Zeichenfolge parsen und einige Werte erhalten möchte (ODER eine JSON-Zeichenfolge von Grund auf neu erstellen, um sie zu verschicken), verwende einfach JaveEE jar, das JsonReader, JsonArray, JsonObject usw. enthält. Vielleicht möchtest du die Implementierung davon herunterladen Spezifikation wie javax.json. Mit diesen zwei Gläsern kann ich den JSon analysieren und die Werte verwenden.

    Diese APIs folgen tatsächlich dem DOM / SAX-Parsingmodell von XML.

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

Sie könnten Google Gson verwenden .

Mit dieser Bibliothek müssen Sie nur ein Modell mit derselben JSON-Struktur erstellen. Dann wird das Modell automatisch ausgefüllt. Sie müssen Ihre Variablen als Ihre JSON-Schlüssel aufrufen oder @SerializedName verwenden, wenn Sie andere Namen verwenden möchten.

Für Ihr Beispiel:

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

}

Modell:

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

Jetzt können Sie mit der Gson-Bibliothek analysieren:

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

Sie können ein Modell aus JSON automatisch mit Online-Tools wie this erzeugen.





parsing