Come analizzare JSON in Java


1049

Ho il seguente testo JSON. Come posso analizzare per ottenere i valori di pageName, pagePic, post_ide così via?

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

7
Le librerie JSON integrate in Java sono il modo più rapido per farlo, ma nella mia esperienza GSON è la migliore libreria per analizzare un JSON in un POJO indolore.
Iman Akbari,

16
Questa è la prima domanda altamente votata e protetta di cui ho trovato le risposte più confuse
Riyafa Abdul Hameed,

6
@JaysonMinard ha concordato. Chiesto per intervento mod. Questo dovrebbe essere chiuso davvero. Inizialmente ho assunto (a torto) che non potevo farlo mentre la domanda era protetta, quindi non l'ho protetta e ho fatto le mie cose. Lo ri-protetto ora per evitare risposte a bassa rep e simili, in attesa di una mod.
Mena,

4
"Questa domanda non mostra alcuno sforzo di ricerca" - Descrizione comando pulsante downvote
Jean-François Corbett,

6
Questa domanda è in discussione su Meta .
Mark Amery,

Risposte:


754

La libreria org.json è facile da usare. Esempio di codice di seguito:

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
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");
    ......
}

Puoi trovare altri esempi da: Parse JSON in Java

Vaso scaricabile: http://mvnrepository.com/artifact/org.json/json


15
Sono d'accordo con @StaxMan. Ho appena provato org.json ed è orribilmente ingombrante. In realtà non si gioca con i tipi standard di raccolta Java, ad esempio.
Ken Williams,

7
@StaxMan Vorrei scegliere org.jsonsu altre librerie per un semplice analisi JSON senza nemmeno guardare. È la libreria di riferimento creata da Douglas Crockford (lo scopritore JSON).
Omar Al-Ithawi,

31
@OmarIthawi che è semplicemente stupido. È una prova di concetto con API scomode, implementazione inefficiente. Penso che sia meglio considerare le biblioteche per i loro meriti, invece di cercare di dedurre la qualità dalla visibilità dei suoi autori - Doug ha ottenuto molte cose, ma questo non cambia davvero le qualità della particolare lib. 10 anni fa era l'unico gioco in città, ma da allora ci sono stati molti progressi positivi. È come Struts of json libs.
StaxMan,

12
org.json è tra le peggiori librerie JSON. Si dovrebbe esaminare il set di funzionalità e le prestazioni delle librerie json disponibili prima di scegliere. Ecco un benchmark che ho fatto confrontando jackson, gson, org.json, genson usando JMH: github.com/fabienrenaud/java-json-benchmark . jackson è il chiaro vincitore qui.
fabien,

4
La Licenza non include alcuna licenza Open Source comunemente usata e detiene anche i diritti d'autore.
Christian Vielma,

537

Nell'esempio, supponiamo che tu abbia una classe Personcon solo a name.

private class Person {
    public String name;

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

Google GSON ( Maven )

Il mio preferito per quanto riguarda la grande serializzazione / deserializzazione di oggetti JSON.

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

Aggiornare

Se vuoi ottenere un singolo attributo, puoi farlo facilmente anche con la libreria di Google:

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

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

Org.JSON ( Maven )

Se non hai bisogno della deserializzazione degli oggetti ma per ottenere semplicemente un attributo, puoi provare org.json ( o guardare l'esempio GSON sopra! )

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

16
Buona risposta. Un suggerimento per un piccolo miglioramento: sia GSON che Jackson supportano anche l'uso della rappresentazione dell'albero JSON (per Jackson questi sono JsonNode, GSON ha qualcosa di simile). Potrebbe essere utile mostrare frammenti, poiché è simile all'unico modo offerto da org.json.
StaxMan,

Altre due biblioteche degne di nota (nell'interesse della completezza): json-simple e Oracle JSONP
jake stayman

3
@NeonWarge, perché? Mi sembra che questa risposta presuma che uno abbia già definito una classe Java che contiene esattamente gli stessi campi della stringa JSON, niente di meno e niente di più. Questo è un presupposto piuttosto forte.
Andrea Lazzarotto

1
json-simple e l'oracle jsonp si esibiscono in modo terribile: github.com/fabienrenaud/java-json-benchmark Per le performance, scegli jackson o dsljson.
fabien

GSON non supporta il filtraggio dinamico di campi su livelli diversi da root!
Gangnus,

102
  1. Se si desidera creare un oggetto Java da JSON e viceversa, utilizzare barattoli di terze parti GSON o JACKSON ecc.

    //from object to JSON 
    Gson gson = new Gson();
    gson.toJson(yourObject);
    
    // from JSON to object 
    yourObject o = gson.fromJson(JSONString,yourObject.class);
    
  2. Ma se si desidera semplicemente analizzare una stringa JSON e ottenere alcuni valori, (OPPURE creare una stringa JSON da zero per inviare via cavo) utilizzare solo il vaso JaveEE che contiene JsonReader, JsonArray, JsonObject ecc. È possibile scaricare l'implementazione di tale specifiche come javax.json. Con questi due barattoli sono in grado di analizzare il json e utilizzare i valori.

    Queste API in realtà seguono il modello di analisi DOM / SAX di 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");
    

4
@nondescript Se dovessi indovinare, direi che è stato sottoposto a downgrade perché non risponde alla domanda del poster originale: "Qual è il codice richiesto?" Le risposte che sono state sottoposte a votazione hanno fornito frammenti di codice.
jewbix.cube,

4
Nota: Jackson e GSON supportano entrambi il binding in stile albero e / o Maps / Lists, quindi non è necessario utilizzare il pacchetto Java EE (javax.json). javax.json ha poco da offrire oltre a Jackson o GSON.
StaxMan

Suggerisco di aggiungere un collegamento alla libreria JavaEE.
Basil Bourque,

72

il parser quick-json è molto semplice, flessibile, molto veloce e personalizzabile. Provalo

Caratteristiche:

  • Conforme alle specifiche JSON (RFC4627)
  • Parser JSON ad alte prestazioni
  • Supporta l'approccio di analisi flessibile / configurabile
  • Convalida configurabile di coppie chiave / valore di qualsiasi Gerarchia JSON
  • Facile da usare # Ingombro molto ridotto
  • Aumenta le eccezioni per gli sviluppatori e facili da tracciare
  • Supporto di convalida personalizzato collegabile: chiavi / valori possono essere convalidati configurando validatori personalizzati come e quando incontrati
  • Supporto parser di convalida e non di convalida
  • Supporto per due tipi di configurazione (JSON / XML) per l'utilizzo del parser di validazione Quick-JSON
  • Richiede JDK 1.5
  • Nessuna dipendenza da librerie esterne
  • Supporto per la generazione JSON tramite serializzazione di oggetti
  • Supporto per la selezione del tipo di raccolta durante il processo di analisi

Può essere usato in questo modo:

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

3
C'è un javadoc disponibile?
jboi,

24
Questo pacchetto non può gestire valori vuoti durante l'analisi. Ad esempio: ... "description": "" ... genera un'eccezione
Ivan,

6
Ho risolto questo problema (e molti altri) in code.google.com/p/quick-json/issues/detail?id=11 Spero che l'autore si prenda il tempo necessario per risolverlo nella versione ufficiale.
Noamik,

8
Tra le funzionalità elencate, nulla è unico rispetto ad altre opzioni e l'affermazione di alte prestazioni non è supportata da nulla; a differenza delle biblioteche più mature (Gson, Jackson, Genson, Boon) che sono incluse in benchmark come github.com/eishay/jvm-serializers , github.com/novoj/JavaJsonPerformanceTest o developer.com/lang/jscript/… - I non ho visto questa libreria inclusa nei test o menzioni che è ampiamente usata.
StaxMan,

26
Questo progetto sembra essere morto e sembra non essere più ospitato nel repository Maven centrale.
8bitjunkie,

40

Puoi usare Google Gson .

Utilizzando questa libreria è necessario solo creare un modello con la stessa struttura JSON. Quindi il modello viene compilato automaticamente. È necessario chiamare le variabili come chiavi JSON o utilizzare @SerializedNamese si desidera utilizzare nomi diversi.

JSON

Dal tuo esempio:

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

Modello

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

parsing

Ora puoi analizzare usando la libreria Gson:

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

Importazione dei gradi

Ricorda di importare la libreria nel file Gradle dell'app

implementation 'com.google.code.gson:gson:2.8.6' // or earlier versions

Generazione automatica di modelli

È possibile generare modelli da JSON automaticamente utilizzando strumenti online come questo .


38

Quasi tutte le risposte fornite richiedono una completa deserializzazione di JSON in un oggetto Java prima di accedere al valore nella proprietà di interesse. Un'altra alternativa, che non segue questa strada, è usare JsonPATH che è come XPath per JSON e consente il movimento di oggetti JSON.

È una specifica e la brava gente di JayWay ha creato un'implementazione Java per la specifica che puoi trovare qui: https://github.com/jayway/JsonPath

Quindi sostanzialmente per usarlo, aggiungilo al tuo progetto, ad esempio:

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

e usare:

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

eccetera...

Controlla la pagina delle specifiche JsonPath per ulteriori informazioni sugli altri modi per attraversare JSON.


Questa è un'ottima libreria soprattutto per la lettura e l'aggiornamento di JSON, ma fai attenzione a qualche problema noto su questa libreria. Vedi [1]: github.com/json-path/JsonPath/issues/272 [2]: github.com/json-path/JsonPath/issues/375
papigee

38

A - Spiegazione

È possibile utilizzare le librerie Jackson per associare JSON String alle istanze POJO ( Plain Old Java Object ). POJO è semplicemente una classe con solo campi privati ​​e metodi getter / setter pubblici. Jackson attraverserà i metodi (usando reflection ) e mapperà l'oggetto JSON nell'istanza POJO quando i nomi dei campi della classe si adattano ai nomi dei campi dell'oggetto JSON.

Nel tuo oggetto JSON, che in realtà è un oggetto composito , l'oggetto principale è costituito da due oggetti secondari. Quindi, le nostre classi POJO dovrebbero avere la stessa gerarchia. Chiamerò l'intero oggetto JSON come oggetto Page . L' oggetto Page è costituito da un oggetto PageInfo e da una matrice di oggetti Post .

Quindi dobbiamo creare tre diverse classi POJO;

  • Page Class, un composto di PageInfo Class e matrice di istanze postali
  • Classe PageInfo
  • Post Class

L'unico pacchetto che ho usato è Jackson ObjectMapper, quello che facciamo è legare i dati;

com.fasterxml.jackson.databind.ObjectMapper

Le dipendenze richieste, i file jar sono elencati di seguito;

  • Jackson-core-2.5.1.jar
  • jackson-databind-2.5.1.jar
  • jackson-annotazioni-2.5.0.jar

Ecco il codice richiesto;

B - Classe POJO principale: pagina

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 - Classe POJO figlio: 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 - Classe POJO bambino: Posta

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 - File JSON di esempio: sampleJSONFile.json

Ho appena copiato il tuo esempio JSON in questo file e l'ho messo nella cartella del progetto.

{
   "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 - Codice demo

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 - Uscita demo

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

26

Usa minimal-json che è molto veloce e facile da usare. È possibile analizzare da String obj e Stream.

Dati di esempio:

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

Analisi:

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

Creazione di JSON:

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

Esperto di:

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

Come apparirà il pojo?
Jesse,

Per Pojo usa gson. Questa libreria non supporta.
Sakib Sami,

22

Credo che la migliore pratica dovrebbe essere quella di passare attraverso l' API JSON Java ufficiale che è ancora in fase di elaborazione.


7
Da quando ho risposto, ho iniziato a usare Jackson e penso che sia una delle migliori librerie là fuori per la deserializzazione JSON.
Giovanni Botta,

2
Perché riutilizzano JSONP per significare qualcosa di diverso da JSON con Padding ? ...
Chris Wesseling,

@ChrisWesseling Che vuoi dire?
Giovanni Botta,

"Java API for JSON Processing (JSON-P)" è il titolo del documento a cui ti colleghi. E mi ha confuso, perché sapevo che JSONP significava qualcos'altro.
Chris Wesseling,

1
@ChrisWesseling oh che è confuso. Questo è quello che hanno scelto per le specifiche. Comunque, come ho detto, andrei direttamente a Jackson.
Giovanni Botta,

22

Poiché nessuno lo ha ancora menzionato, ecco l'inizio di una soluzione che utilizza Nashorn (parte di runtime JavaScript di Java 8, ma obsoleta in Java 11).

Soluzione

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

Confronto delle prestazioni

Ho scritto contenuti JSON contenenti tre array rispettivamente di 20, 20 e 100 elementi. Voglio solo ottenere i 100 elementi dal terzo array. Uso la seguente funzione JavaScript per analizzare e ottenere le mie voci.

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

L'esecuzione della chiamata un milione di volte utilizzando Nashorn richiede 7,5 ~ 7,8 secondi

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

org.json impiega 20 ~ 21 secondi

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

Jackson impiega 6,5 ​​~ 7 secondi

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

In questo caso Jackson si comporta meglio di Nashorn, che si comporta molto meglio di org.json. L'API Nashorn è più difficile da usare rispetto a quella di org.json o di Jackson. A seconda delle esigenze, Jackson e Nashorn possono essere entrambe soluzioni valide.


1
Qual è l'unità " ""? Non pollici? Sono secondi? Minuti?
Peter Mortensen,

1
@PeterMortensen significa secondi. Dal momento che sembra poco chiaro lo cambierò. Grazie per la recensione
otonglet,

2
Sfortunatamente, Nashorn è deprecato in Java 11. JEP 335 .
Per Mildner,

1
So che Nashorn è deprecato, ma mi è piaciuta questa risposta perché non volevo dipendenze; tuttavia, ho dovuto rielaborare un po 'l'esempio:ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript"); engine.eval("var fun = function(raw) { return JSON.parse(raw); };"); Map<String, Object> json = (Map<String, Object>) ((Invocable) engine).invokeFunction("fun", jsonString);
kgibm

21

L'esempio seguente mostra come leggere il testo nella domanda, rappresentato come variabile "jsonText". Questa soluzione utilizza l' API Java EE7 javax.json (menzionata in alcune delle altre risposte). Il motivo per cui l'ho aggiunto come risposta separata è che il codice seguente mostra come accedere effettivamente ad alcuni dei valori mostrati nella domanda. Un'implementazione delle API javax.json sarebbe necessario per far correre questo codice. Il pacchetto completo per ciascuna delle classi richieste è stato incluso poiché non volevo dichiarare dichiarazioni di "importazione".

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

Ora, prima che qualcuno vada e declassi questa risposta perché non utilizza GSON, org.json, Jackson o uno qualsiasi degli altri framework di terze parti disponibili, è un esempio di "codice richiesto" per la domanda per analizzare il testo fornito. Sono ben consapevole che l' adesione all'attuale standard JSR 353 non è stata presa in considerazione per JDK 9 e come tale le specifiche JSR 353 dovrebbero essere trattate allo stesso modo di qualsiasi altra implementazione di gestione JSON di terze parti.


15

Questo mi ha fatto impazzire di quanto fosse facile. Puoi semplicemente passare un Stringtrattenendo il tuo JSON al costruttore di un JSONObject nel pacchetto org.json predefinito.

JSONArray rootOfPage =  new JSONArray(JSONString);

Fatto. Microfono a gocce . Funziona anche con JSONObjects. Dopodiché, puoi semplicemente guardare attraverso la tua gerarchia di Objectsusare i get()metodi sui tuoi oggetti.


13
Il JSONArraytipo non fa parte dell'API JDK J2SE e non si specifica quale API o libreria di terze parti fornisce questo tipo.
Bobulous,

2
Non che consiglierei di usarlo, ma penso che questo si riferisca al pacchetto "org.json" di json.org/java . Era usato prima che diventassero disponibili buone librerie Java, ma questo era anni fa (2008 o prima)
StaxMan

1
O brainmurphy1 significa JSONArray in Android?
Alexander Farber,

12

Esistono molte librerie JSON disponibili in Java.

I più famosi sono: Jackson, GSON, Genson, FastJson e org.json.

In genere ci sono tre cose che uno dovrebbe cercare per scegliere qualsiasi libreria:

  1. Prestazione
  2. Facilità d'uso (il codice è semplice da scrivere e leggibile) - questo si accompagna alle funzionalità.
  3. Per le app mobili: dipendenza / dimensione del vaso

In particolare per le librerie JSON (e tutte le librerie di serializzazione / deserializzazione), anche il databinding è di solito interessante in quanto elimina la necessità di scrivere il codice della piastra della caldaia per comprimere / decomprimere i dati.

Per 1, vedi questo benchmark: https://github.com/fabienrenaud/java-json-benchmark che ho fatto usando JMH che confronta (jackson, gson, genson, fastjson, org.json, jsonp) le prestazioni di serializzatori e deserializzatori usando stream e databind API. Per 2, puoi trovare numerosi esempi su Internet. Il benchmark sopra può anche essere usato come fonte di esempi ...

Rapida acquisizione del benchmark: Jackson ha prestazioni da 5 a 6 volte migliori rispetto a org.json e più del doppio rispetto a GSON.

Per il tuo esempio particolare, il seguente codice decodifica il tuo json con 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.
    }
}

Fatemi sapere se avete domande.


11

Oltre ad altre risposte, raccomando questo servizio open source online jsonschema2pojo.org per la generazione rapida di classi Java dallo schema json o json per GSON, Jackson 1.xo Jackson 2.x. Ad esempio, se hai:

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

Il jsonschema2pojo.org per GSON ha generato:

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

9

Se hai qualche classe Java (ad esempio Messaggio) che rappresenta la stringa JSON (jsonString), puoi utilizzare la libreria Jackson JSON con:

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

e dall'oggetto messaggio puoi recuperare qualsiasi suo attributo.


9

Gson è facile da imparare e implementare, ciò che dobbiamo sapere sono i seguenti due metodi

  • toJson () - Converte l'oggetto Java in formato JSON

  • fromJson () - Converti JSON in oggetto Java

`

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

    }
}

`


Per una conoscenza completa su Gson, consultare i collegamenti seguenti. github.com/google/gson/blob/master/UserGuide.md
venkat

9

Esistono molte librerie open source presenti per analizzare il contenuto JSON su un oggetto o semplicemente per leggere i valori JSON. Il tuo requisito è solo quello di leggere i valori e analizzarli in oggetti personalizzati. Quindi la libreria org.json è sufficiente nel tuo caso.

Utilizzare la libreria org.json per analizzarla e creare JsonObject:

JSONObject jsonObj = new JSONObject(<jsonStr>);

Ora usa questo oggetto per ottenere i tuoi valori:

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

Puoi vedere un esempio completo qui:

Come analizzare JSON in Java


Sembra che tutte le tue risposte contengano un link a quel sito. Se è spam, ti preghiamo di smettere. In caso contrario, scusate la confusione, ma non penso che sia necessario pubblicare un link in tutte le vostre risposte.
Donald Duck

1
È difficile dare una risposta, dove puoi spiegare tutti gli scenari. Come in questo caso, come leggere array json o più oggetti json. Anche se lo facessi, la risposta sarebbe molto lunga e la persona potrebbe confondersi. Quindi do un link in cui viene fornita una spiegazione corretta, con l'esempio corretto. Può scegliere di visitare o può usare solo la mia spiegazione.
lalitbhagtani,

1
Mi sembra che il link che hai fornito dimostri solo come leggere JSON. Dove posso trovare informazioni su come utilizzare anche JSON?
Lampros Tzanetos,

Scusa, ma non ho capito la tua domanda: - "su come fare anche JSON"
lalitbhagtani,

7

Per favore, fai qualcosa del genere:

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

10
Ehm, che biblioteca è questa?
Stewart,

2
Penso che stia usando org.json.simple
Lasitha Yapa il

7

È possibile utilizzare la libreria Gson per analizzare la stringa 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();

È inoltre possibile eseguire il loop nell'array "posts" in questo modo:

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

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

9
Spiega la tua risposta poiché le risposte di solo codice aiutano gli altri molto meno di un codice ben documentato. Vedi "dai un pesce a un uomo e gli dai da mangiare per un giorno; insegna a un uomo a pescare e gli dai da mangiare per tutta la vita" .
Wai Ha Lee,

Sarebbe bene ricordare che questo è per lib "org.json". Tuttavia, non penso che questo sia un buon modo per farlo essendo molto prolisso e la stessa libreria "org.json" è obsoleta (API lenta e ingombrante). Ci sono scelte migliori: GSON, Jackson, Boon, Genson da usare.
StaxMan,

5

Leggi il seguente post sul blog, JSON in Java .

Questo post è un po 'vecchio, ma voglio ancora rispondere alla tua domanda.

Passaggio 1: creare una classe POJO dei dati.

Passaggio 2: ora crea un oggetto usando JSON.

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

Per ulteriori riferimenti è possibile fare riferimento al seguente link .


4

Le risposte migliori in questa pagina usano esempi troppo semplici come oggetto con una proprietà (ad es. {Nome: valore}). Penso che l'esempio ancora semplice ma reale possa aiutare qualcuno.

Quindi questo è il JSON restituito dall'API di Google Translate:

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

Voglio recuperare il valore dell'attributo "translateText", ad esempio "Arbeit", utilizzando Gson di Google.

Due possibili approcci:

  1. Recupera solo un attributo necessario

    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. Crea un oggetto Java da 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

Per prima cosa devi selezionare una libreria di implementazione per farlo.

L' API Java per l'elaborazione JSON (JSR 353) fornisce API portatili per analizzare, generare, trasformare e interrogare JSON utilizzando il modello a oggetti e le API di streaming.

L' implementazione di riferimento è qui: https://jsonp.java.net/

Qui puoi trovare un elenco di implementazioni di JSR 353:

Quali sono le API che implementano JSR-353 (JSON)

E per aiutarti a decidere ... Ho trovato anche questo articolo:

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

Se vai per Jackson, ecco un buon articolo sulla conversione tra JSON in / da Java usando Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json- Jackson /

Spero che sia d'aiuto!


Stai indicando la versione 1 della libreria Jackson. Consiglio vivamente di utilizzare la versione corrente della libreria Jackson.
Herbert Yu,

4

Puoi usare Jayway JsonPath . Di seguito è riportato un link GitHub con codice sorgente, dettagli pom e buona documentazione.

https://github.com/jayway/JsonPath

Seguire i passaggi seguenti.

Passaggio 1 : aggiungere la dipendenza del percorso JSON jayway nel percorso della classe utilizzando Maven o scaricare il file JAR e aggiungerlo manualmente.

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

Passaggio 2 : salvare il file JSON di input come file per questo esempio. Nel mio caso ho salvato il tuo JSON come sampleJson.txt. Nota che hai perso una virgola tra pageInfo e post.

Passaggio 3 : leggere i contenuti JSON dal file sopra usando bufferedReader e salvarlo come 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();

Passaggio 4 : analizzare la stringa JSON utilizzando il parser JSON jayway.

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

Passaggio 5 : leggi i dettagli come di seguito.

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

L'output sarà :

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

3

Ho JSON in questo modo:

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

Classe Java

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Codice per convertire questo JSON in una classe Java.

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

Esperto di

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

2

È possibile utilizzare l' annotazione Apache @Model per creare classi di modelli Java che rappresentano la struttura dei file JSON e utilizzarli per accedere a vari elementi nella struttura JSON . A differenza di altre soluzioni, questa funziona completamente senza riflessione ed è quindi adatta ad ambienti in cui la riflessione è impossibile o comporta un notevole sovraccarico.

C'è un progetto Maven di esempio che mostra l'utilizzo. Innanzitutto definisce la struttura:

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

e quindi utilizza le classi RepositoryInfo e Owner generate per analizzare il flusso di input fornito e raccogliere determinate informazioni mentre lo fa:

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

Questo è tutto! Oltre a questo, ecco un esempio dal vivo che mostra un esempio simile insieme alla comunicazione di rete asincrona.


2

jsoniter(jsoniterator) è una libreria json relativamente nuova e semplice, progettata per essere semplice e veloce. Tutto quello che devi fare per deserializzare i dati JSON è

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

dove jsonDataè una stringa di dati json.

Controlla il sito ufficiale per ulteriori informazioni.


1

È possibile utilizzare la classe JSONObject per convertire una stringa JSON in un oggetto JSON e iterare sull'oggetto JSON. Usa il seguente codice.

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

2
Questo è solo Android
Ľubomír


1
@DermotCanniffe è solo Android.
user4020527,

1

È possibile utilizzare la libreria di analisi del flusso DSM per l'analisi di documenti json e XML complessi. DSM analizza i dati solo una volta e non carica tutti i dati in memoria.

Diciamo che abbiamo la classe Page per deserializzare dati json dati.

Classe di pagina

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

    // getter/setter

}

Crea un file di mappatura yaml.

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

Usa DSM per estrarre i campi.

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

variabile di pagina serializzata su json:

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

DSM è ottimo per json e xml complessi.


0

È possibile utilizzare JsonNodeper una rappresentazione ad albero strutturato della stringa JSON. Fa parte della libreria rock solid jackson che è onnipresente.

ObjectMapper mapper = new ObjectMapper();
JsonNode yourObj = mapper.readTree("{\"k\":\"v\"}");
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.