it-swarm.com.de

Wie man JSON in Java analysiert

Ich habe den folgenden JSON-Text. Wie kann ich es analysieren, um die Werte von 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"
         }
    ]
}

Die org.json Bibliothek ist einfach zu benutzen. 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 analysieren

JAR zum Herunterladen: http://mvnrepository.com/artifact/org.json/json

686
user1931858

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

private class Person {
    public String name;

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

Google GSON ( Maven )

Mein persönlicher Favorit für die großartige JSON-Serialisierung/Deserialisierung 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"}

Update

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

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

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

Org.JSON ( Maven )

Wenn Sie keine Objektserialisierung benötigen, sondern nur ein Attribut erhalten möchten, können Sie org.json ( oder das GSON-Beispiel oben anschauen! )

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
500
SDekov
  1. Wenn Sie ein Java -Objekt aus JSON erstellen möchten und umgekehrt, verwenden Sie GSON- oder JACKSON-Jars von Drittanbietern usw.

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
    
  2. Wenn Sie jedoch nur eine JSON-Zeichenfolge analysieren und einige Werte abrufen möchten (ODER eine JSON-Zeichenfolge von Grund auf neu erstellen, um sie über Kabel zu senden), verwenden Sie einfach die JaveEE-JAR-Datei, die JsonReader, JsonArray, JsonObject usw. enthält. Sie möchten möglicherweise deren Implementierung herunterladen spec wie javax.json. Mit diesen beiden Gläsern kann ich den json analysieren und die Werte verwenden.

    Diese APIs folgen tatsächlich dem DOM/SAX-Analysemodell 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");
    
96
nondescript

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

Eigenschaften:

  • Entspricht der JSON-Spezifikation (RFC4627)
  • Leistungsstarker JSON-Parser
  • Unterstützt den flexiblen/konfigurierbaren Parsing-Ansatz
  • Konfigurierbare Validierung von Schlüssel/Wert-Paaren einer beliebigen JSON-Hierarchie
  • Einfach zu bedienen # Sehr kleiner Platzbedarf
  • Löst entwicklerfreundliche und leicht zu verfolgende Ausnahmen aus
  • Unterstützung für steckbare benutzerdefinierte Validierung - Schlüssel/Werte können validiert werden, indem benutzerdefinierte Validierer konfiguriert werden, sobald sie auftreten
  • Parser-Unterstützung wird überprüft und nicht überprüft
  • Unterstützung für zwei Konfigurationstypen (JSON/XML) für die Verwendung des Parsers für die schnelle JSON-Validierung
  • 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 Sammlungstyps während des Analyseprozesses

Es kann so verwendet werden:

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

A - Erklärung

Sie können Jackson -Bibliotheken verwenden, um JSON-Zeichenfolgen in POJO ( Plain Old Javazu binden. _ Objekt ) Instanzen. POJO ist einfach eine Klasse mit nur privaten Feldern und öffentlichen Get-/Setter-Methoden. Jackson durchläuft die Methoden (unter Verwendung von Reflektion) und ordnet das JSON-Objekt der POJO-Instanz zu, während 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. Daher sollten unsere POJO-Klassen dieselbe Hierarchie haben. Ich werde das gesamte JSON-Objekt als Page Objekt aufrufen. Page Objekt besteht aus einem PageInfo Objekt und einem Post Objektarray.

Wir müssen also drei verschiedene POJO-Klassen erstellen.

  • Page Klasse, eine Zusammenstellung von PageInfo Klasse und Array von Post Instanzen
  • PageInfo Klasse
  • Beiträge Klasse

Das einzige Paket, das ich verwendet habe, ist Jackson ObjectMapper. Wir binden Daten.

com.fasterxml.jackson.databind.ObjectMapper

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

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

Hier ist der erforderliche Code;

B - POJO - Hauptklasse:

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 - Untergeordnete 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: Post

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 - JSON-Beispieldatei: sampleJSONFile.json

Ich habe gerade Ihr JSON-Beispiel in diese Datei kopiert und im 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 - Demo Code

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 - Demo-Ausgabe

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
35

Fast alle Antworten erfordern eine vollständige Deserialisierung des JSON in ein Java - Objekt, bevor auf den Wert in der Eigenschaft von Interesse zugegriffen werden kann. Eine andere Alternative, die diesen Weg nicht geht, ist die Verwendung von JsonPATH , die XPath für JSON ähnelt und das Durchlaufen von JSON-Objekten ermöglicht.

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

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 benutzen:

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

usw...

Auf der JsonPath-Spezifikationsseite finden Sie weitere Informationen zu den anderen Möglichkeiten, JSON zu übertragen.

34
dade

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 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 mit Online-Tools wie this automatisch ein Modell aus JSON generieren.

31
lubilis

Verwenden Sie minimal-json , das sehr schnell und einfach zu bedienen ist. Sie können aus String obj und Stream analysieren.

Beispieldaten:

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

Parsing:

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

JSON erstellen:

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>
24
Sakib Sami

Ich glaube, die beste Vorgehensweise sollte darin bestehen, die offiziellen Java JSON API zu durchlaufen, die noch in Arbeit sind.

19
Giovanni Botta

Das folgende Beispiel zeigt, wie der Text in der Frage gelesen wird, der als "jsonText" -Variable dargestellt wird. Diese Lösung verwendet die API Java EE7 javax.json (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 tatsächlich auf einige der in der Frage gezeigten Werte zugegriffen wird. Ein Implementierung der javax.json-API ist erforderlich, damit dieser Code ausgeführt wird. Das vollständige Paket für jede der erforderlichen Klassen war enthalten, da ich "import" -Anweisungen nicht 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");

Bevor jemand diese Antwort abstimmt, weil er nicht GSON, org.json, Jackson oder eines der anderen verfügbaren Frameworks von Drittanbietern verwendet, ist dies ein Beispiel für "erforderlichen Code" gemäß der Frage, um den bereitgestellten Text zu analysieren. Mir ist bewusst, dass die Einhaltung des aktuellen Standards JSR 353 wurde für JDK 9 nicht berücksichtigt und als solches JSR 353-Spezifikation wie jeder andere Dritte behandelt werden sollte Implementierung für die JSON-Verarbeitung.

18
justin.hughey

Da es noch niemand erwähnt hat, ist hier ein Anfang einer Lösung mit Nashorn (JavaScript-Laufzeit-Teil von Java 8, jedoch veraltet in Java 11).

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 habe JSON-Inhalte geschrieben, die drei Arrays mit jeweils 20, 20 und 100 Elementen enthalten. Ich möchte nur die 100 Elemente aus dem dritten Array erhalten. Ich verwende die folgende JavaScript-Funktion, um meine Einträge zu analysieren und abzurufen.

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

Das millionenfache Ausführen des Anrufs mit Nashorn dauert 7,5 ~ 7,8 Sekunden

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

org.json dauert 20 bis 21 Sekunden

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

Jackson benötigt 6,5 ~ 7 Sekunden

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

In diesem Fall schneidet Jackson besser ab als Nashorn, was viel besser abschneidet als org.json. Die Nashorn-API ist schwerer zu verwenden als die von org.json oder Jackson. Je nach Ihren Anforderungen können Jackson und Nashorn tragfähige Lösungen sein.

16
otonglet

Das hat mich umgehauen, wie einfach es war. Sie können einfach ein String, das Ihren JSON-Code enthält, an den Konstruktor eines JSONObjects im Standardpaket org.json übergeben.

JSONArray rootOfPage =  new JSONArray(JSONString);

Getan. Mikrofon fallen lassen. Dies funktioniert auch mit JSONObjects. Danach können Sie einfach Ihre Hierarchie von Objects mit den get() -Methoden für Ihre Objekte durchsehen.

14
brainmurphy1

In Java sind viele JSON-Bibliotheken verfügbar.

Die bekanntesten sind: Jackson, GSON, Genson, FastJson und org.json.

Es gibt normalerweise drei Dinge, auf die man bei der Auswahl einer Bibliothek achten sollte:

  1. Performance
  2. Benutzerfreundlichkeit (Code ist einfach zu schreiben und lesbar) - das passt zu den Funktionen.
  3. Für mobile Apps: Abhängigkeit/Glasgröße

Speziell für JSON-Bibliotheken (und alle Serialisierungs-/Deserialisierungsbibliotheken) ist die Datenbindung in der Regel auch von Interesse, da zum Packen/Entpacken der Daten kein Code auf der Kesselplatte mehr geschrieben werden muss.

Für 1 siehe diesen Benchmark: https://github.com/fabienrenaud/Java-json-benchmark Ich habe JMH verwendet, um (jackson, gson, genson) zu vergleichen , fastjson, org.json, jsonp) Leistung von Serialisierern und Deserialisierern unter Verwendung von Stream- und Datenbindungs-APIs. Zu 2 finden Sie zahlreiche Beispiele im Internet. Die obige Benchmark kann auch als Quelle für Beispiele verwendet werden ...

Schneller Rückgriff auf den Benchmark: Jackson schneidet 5- bis 6-mal besser ab als org.json und mehr als zweimal besser als GSON.

Für Ihr spezielles Beispiel dekodiert der folgende Code Ihren json mit jackson:

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

Lassen Sie mich wissen, wenn Sie Fragen haben.

12
fabien

Zusätzlich zu anderen Antworten empfehle ich diesen OpenSource-Onlinedienst jsonschema2pojo.org , um schnell Java Klassen aus json oder json-Schema für GSON, Jackson 1.x oder Jackson 2.x zu generieren . 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 jsonschema2pojo.org 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;
}
10

Es gibt viele Open-Source-Bibliotheken, mit denen JSON-Inhalte auf ein Objekt analysiert oder nur JSON-Werte gelesen werden können. Ihre Anforderung ist nur, Werte zu lesen und sie in ein benutzerdefiniertes Objekt zu analysieren. Die org.json-Bibliothek ist in Ihrem Fall also ausreichend.

Verwenden Sie die Bibliothek org.json, um sie zu analysieren und JsonObject zu erstellen:

JSONObject jsonObj = new JSONObject(<jsonStr>);

Verwenden Sie nun dieses Objekt, um Ihre Werte abzurufen:

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

Ein vollständiges Beispiel finden Sie hier:

Wie man JSON in Java analysiert

9
lalitbhagtani

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

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

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

9

Gson ist leicht zu erlernen und zu implementieren. Was wir wissen müssen, sind zwei Methoden

  • toJson () - Konvertiert Java -Objekt in das JSON-Format

  • fromJson () - Konvertiert JSON in Java Objekt

`

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

    }
}

`

8
venkat

Bitte machen Sie so etwas:

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

Sie können die Gson-Bibliothek verwenden, um die JSON-Zeichenfolge zu analysieren.

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 das Array "posts" auch folgendermaßen durchlaufen:

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

Lesen Sie den folgenden Blog-Beitrag, JSON in Java .

Dieser Beitrag ist ein bisschen alt, aber ich möchte immer noch Ihre Frage beantworten.

Schritt 1: Erstellen Sie eine POJO-Klasse Ihrer Daten.

Schritt 2: Erstellen Sie nun ein Objekt mit JSON.

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

Zur weiteren Bezugnahme können Sie auf das folgende Link verweisen.

6
sumit kumar
{
   "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
}
4
LReddy

Dazu müssen Sie zunächst eine Implementierungsbibliothek auswählen.

Die Java-API für JSON-Verarbeitung (JSR 353) bietet portable APIs zum Parsen, Generieren, Transformieren und Abfragen von JSON mithilfe von Objektmodell- und Streaming-APIs.

Die Referenzimplementierung ist hier: https://jsonp.Java.net/

Hier finden Sie eine Liste der Implementierungen von JSR 353:

Welche API implementiert JSR-353 (JSON)?

Und als Entscheidungshilfe ... Ich habe auch diesen Artikel gefunden:

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

Wenn Sie sich für Jackson entscheiden, finden Sie hier einen guten Artikel über die Konvertierung von JSON in/von Java mit Jackson: https://www.mkyong.com/Java/how-to-convert- Java-Objekt-zu-von-Json-Jackson /

Ich hoffe es hilft!

Bei den häufigsten Antworten auf dieser Seite werden zu einfache Beispiele verwendet, z. B. Objekte mit einer Eigenschaft (z. B. {Name: Wert}). Ich denke, dass noch einfache, aber reale Beispiele jemandem helfen können.

Dies ist also die von der Google Übersetzer-API zurückgegebene JSON:

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

Ich möchte den Wert des Attributs "translatedText" abrufen, z. "Arbeit" mit Googles Gson.

Zwei mögliche Ansätze:

  1. Rufen Sie nur ein erforderliches Attribut ab

    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. Erstellen Sie ein Java -Objekt aus 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;
    
4
yurin

Sie können Jayway JsonPath verwenden. Unten ist ein GitHub-Link mit Quellcode, POM-Details und guter Dokumentation.

https://github.com/jayway/JsonPath

Bitte befolgen Sie die folgenden Schritte.

Schritt 1 : Fügen Sie die Jayway-JSON-Pfadabhängigkeit in Ihren Klassenpfad mit Maven ein oder laden Sie die JAR-Datei herunter und fügen Sie sie manuell hinzu.

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

Schritt 2 : Bitte speichern Sie Ihre Eingabe-JSON als Datei für dieses Beispiel. In meinem Fall habe ich Ihren JSON als sampleJson.txt gespeichert. Beachten Sie, dass Sie ein Komma zwischen pageInfo und Beiträgen verpasst haben.

Schritt 3 : Lesen Sie den JSON-Inhalt aus der obigen Datei mit bufferedReader und speichern Sie ihn als 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();

Schritt 4 : Analysieren Sie Ihren JSON-String mit dem JSON-Parser von Jayway.

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

Schritt 5 : Lesen Sie die Details wie unten.

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

Die Ausgabe wird sein:

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

Ich habe JSON wie folgt:

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

Java-Klasse

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Code zum Konvertieren dieses JSON in eine Java -Klasse.

    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>
2
Parth Solanki

jsoniter (jsoniterator) ist eine relativ neue und einfache json-Bibliothek, die einfach und schnell gestaltet wurde. Alles, was Sie tun müssen, um JSON-Daten zu deserialisieren, ist

JsonIterator.deserialize(jsonData, int[].class);

dabei ist jsonData eine Zeichenfolge von JSON-Daten.

Weitere Informationen finden Sie auf der offiziellen Website .

Sie können die Stream-Parsing-Bibliothek DSM zum Parsen komplexer Json- und XML-Dokumente verwenden. DSM analysiert Daten nur einmal und lädt nicht alle Daten in den Speicher.

Nehmen wir an, wir haben die Klasse Page , um bestimmte JSON-Daten zu deserialisieren.

Seitenklasse

public class Page {
    private String pageName;
    private String pageImage;
    private List<Sting> postIds;

    // getter/setter

}

Erstellen Sie eine Yaml-Mapping-Datei.

result:
  type: object     # result is array
  path: /posts
  fields:
    pageName:
        path: /pageInfo/pageName
    pageImage:
        path: /pageInfo/pagePic
    postIds:
      path: post_id
      type: array

Verwenden Sie DSM, um Felder zu extrahieren.

DSM dsm=new DSMBuilder(new File("path-to-yaml-config.yaml")).create(Page.class);
Page page= (Page)dsm.toObject(new path-to-json-data.json");

Seitenvariable serialisiert nach json:

{
  "pageName" : "abc",
  "pageImage" : "http://example.com/content.jpg",
  "postIds" : [ "123456789012_123456789012" ]
}

DSM eignet sich sehr gut für komplexe JSON- und XML-Dateien.

1
mfe

Man kann Apache @Model Annotation verwenden, um Java Modellklassen zu erstellen, die die Struktur von DARSTELLEN. JSON Dateien und verwenden Sie diese, um auf verschiedene Elemente im JSON Baum zuzugreifen. Im Gegensatz zu anderen Lösungen arbeitet diese vollständig ohne Reflexion und ist daher für Umgebungen geeignet, in denen Reflexion unmöglich ist oder mit erheblichem Overhead verbunden ist.

Es gibt ein Beispiel für ein Maven-Projekt , das die Verwendung zeigt. Zunächst wird die Struktur definiert:

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

anschließend werden die generierten Klassen RepositoryInfo und Owner verwendet, um den bereitgestellten Eingabestream zu analysieren und dabei bestimmte Informationen abzurufen:

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

Das ist es! Zusätzlich ist hier ein Live-Gist , das ein ähnliches Beispiel zusammen mit einer asynchronen Netzwerkkommunikation zeigt.

1
Jaroslav Tulach

Mit der JSONObject-Klasse können Sie eine JSON-Zeichenfolge in ein JSON-Objekt konvertieren und über das JSON-Objekt iterieren. Verwenden Sie den folgenden 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));
  }
}
1
smith

Sie können JsonNode für eine strukturierte Baumdarstellung Ihrer JSON-Zeichenfolge verwenden. Es ist Teil der Rock Solid Jackson Bibliothek , die allgegenwärtig ist.

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