Come analizzare JSON in Java

Ho il seguente testo JSON. Come posso analizzarlo per ottenere pageName , pagePic , post_id , ecc.?

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

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

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

Puoi trovare altri esempi da: Parse JSON in Java

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

Per amore dell’esempio, supponiamo di avere una Person class con un solo name .

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

Google GSON ( Maven )

Il mio preferito per la seria serializzazione / de-serializzazione degli oggetti.

 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 de-serializzazione degli oggetti ma semplicemente ottieni un attributo, puoi provare org.json ( o guardare l’esempio di 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 
  1. Se si desidera creare un object Java da JSON e viceversa, utilizzare i contenitori di terze parti di 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 vuole solo analizzare una stringa JSON e ottenere alcuni valori, (OPPURE creare una stringa JSON da zero per inviare su un filo) basta usare JaveEE jar che contiene JsonReader, JsonArray, JsonObject ecc. Si potrebbe voler scaricare l’implementazione di quella specifiche come javax.json. Con questi due vasi sono in grado di analizzare il suono e usare i valori.

    Queste API seguono effettivamente 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"); 

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

Caratteristiche:

  • Conforms alle specifiche JSON (RFC4627)
  • Parser JSON ad alte prestazioni
  • Supporta l’approccio di parsing flessibile / configurabile
  • Convalida configurabile delle coppie chiave / valore di qualsiasi gerarchia JSON
  • Facile da usare # Impronta molto piccola
  • Aumenta le eccezioni facili da tracciare per gli sviluppatori
  • Supporto Validation Custom Validation: chiavi / valori possono essere convalidati configurando validatori personalizzati come e quando incontrati
  • Convalida e non convalida del supporto del parser
  • Supporto per due tipi di configurazione (JSON / XML) per l’utilizzo del parser di convalida JSON veloce
  • Richiede JDK 1.5
  • Nessuna dipendenza da librerie esterne
  • Supporto per la generazione JSON attraverso la serializzazione degli 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); 

Quasi tutte le risposte fornite richiedono una deserializzazione completa del JSON in un object Java prima di accedere al valore nella proprietà di interesse. Un’altra alternativa, che non va in questa direzione, è 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 le specifiche che puoi trovare qui: https://github.com/jayway/JsonPath

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

  com.jayway.jsonpath json-path ${version}  

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…

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

A – Spiegazione

È ansible utilizzare le librerie Jackson , per il binding delle stringhe JSON in istanze POJO ( Plain Old Java Object ). POJO è semplicemente una class con solo campi privati ​​e metodi getter / setter pubblici. Jackson sta per attraversare i metodi (usando la riflessione ) e mappa l’object JSON nell’istanza POJO poiché i nomi dei campi della class si adattano ai nomi dei campi dell’object JSON.

Nel tuo object JSON, che in realtà è un object composito , l’object principale è costituito da due sottooggetti. Quindi, le nostre classi POJO dovrebbero avere la stessa gerarchia. Chiamerò l’intero object JSON come object Page . L’ object pagina è costituito da un object PageInfo e da un array di oggetti Post .

Quindi dobbiamo creare tre diverse classi POJO;

  • Page Class, un composto di PageInfo Class e array di istanze Post
  • PageInfo Class
  • Post Class

L’unico pacchetto che ho usato è Jackson ObjectMapper, quello che facciamo sono dati vincolanti;

 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 – Main POJO Class: Page

 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 – Esempio di file JSON: sampleJSONFile.json

Ho appena copiato il tuo campione JSON in questo file e lo metto 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 

Potresti usare Google Gson .

Usando questa libreria hai solo bisogno di creare un modello con la stessa struttura JSON. Quindi il modello viene compilato automaticamente. Devi chiamare le tue variabili come chiavi JSON, oppure usare @SerializedName se vuoi usare nomi diversi.

Per il tuo esempio:

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

}

Modello:

 class MyModel { private PageInfo pageInfo; private ArrayList 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 comments; private String timeOfPost; } 

Ora puoi analizzare usando la libreria Gson:

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

È ansible generare il modello da JSON automaticamente utilizzando strumenti online come questo .

Usa minimal-json che è molto veloce e facile da usare. È ansible 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 } ] } 

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

Maven:

  com.eclipsesource.minimal-json minimal-json 0.9.4  

Credo che la migliore pratica dovrebbe essere quella di passare attraverso l’ API Java JSON ufficiale, che è ancora in corso.

L’esempio seguente mostra come leggere il testo nella domanda, rappresentato come variabile “jsonText”. Questa soluzione utilizza l’API javax.json Java EE7 (che è 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. Sarebbe necessaria un’implementazione dell’API javax.json per eseguire questo codice. Il pacchetto completo per ciascuna delle classi richieste era incluso poiché non volevo dichiarare dichiarazioni “import”.

 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 parli e scali questa risposta perché non usa GSON, org.json, Jackson, o qualsiasi altra struttura di terze parti disponibile, è un esempio di “codice richiesto” per la domanda per analizzare il testo fornito. Sono ben consapevole che l’ aderenza all’attuale standard JSR 353 non è stata considerata per JDK 9 e pertanto la specifica JSR 353 dovrebbe essere trattata come qualsiasi altra implementazione di gestione JSON di terze parti.

Poiché nessuno lo ha ancora menzionato, ecco un inizio di una soluzione che utilizza Nashorn (parte runtime JavaScript di Java 8).

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 di rispettivamente 20, 20 e 100 elementi. Voglio solo ottenere i 100 elementi dal terzo array. Io uso la seguente funzione JavaScript per analizzare e ottenere le mie voci.

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

Eseguire la chiamata un milione di volte usando Nashorn richiede 7,5 ~ 7,8 secondi

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

org.json richiede 20 ~ 21 secondi

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

Jackson prende 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 utilizzare rispetto a quella di org.json o di Jackson. A seconda delle tue esigenze, Jackson e Nashorn possono essere entrambe soluzioni valide.

Questo mi ha sconvolto per quanto sia stato facile. Puoi semplicemente passare una String contenente il tuo JSON al costruttore di un object JSONObject nel pacchetto org.json predefinito.

 JSONArray rootOfPage = new JSONArray(JSONString); 

Fatto. Goccia microfono . Funziona anche con JSONObjects . Dopodiché, puoi semplicemente guardare attraverso la tua gerarchia di Objects usando i metodi get() sui tuoi oggetti.

Se si dispone di una class Java (ad esempio Message) che rappresenta la stringa JSON (jsonString), è ansible utilizzare la libreria Jackson JSON con:

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

e dall’object messaggio puoi recuperare qualsiasi attributo.

In aggiunta ad altre risposte, raccomando questo servizio online opensource 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 generato:

 @Generated("org.jsonschema2pojo") public class Container { @SerializedName("pageInfo") @Expose public PageInfo pageInfo; @SerializedName("posts") @Expose public List posts = new ArrayList(); } @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 comments = new ArrayList(); @SerializedName("timeOfPost") @Expose public long timeOfPost; } 

Ci sono molte librerie JSON disponibili in Java.

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

Di solito ci sono tre cose da considerare per la scelta di qualsiasi libreria:

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

Specificamente per le librerie JSON (e qualsiasi librerie di serializzazione / deserializzazione), anche il databinding è di solito di interesse in quanto elimina la necessità di scrivere il codice della piastra della caldaia per impacchettare / decomprimere i dati.

Per 1, vedere questo benchmark: https://github.com/fabienrenaud/java-json-benchmark Ho usato JMH che confronta (jackson, gson, genson, fastjson, org.json, jsonp) le prestazioni di serializzatori e deserializzatori usando lo streaming e le API del database. Per 2, puoi trovare numerosi esempi su Internet. Il benchmark qui sopra può anche essere usato come fonte di esempi …

Quick take away del benchmark: Jackson si comporta da 5 a 6 volte meglio di org.json e più del doppio di GSON.

Per il tuo esempio particolare, il seguente codice decodifica il tuo json con jackson:

 public class MyObj { private PageInfo pageInfo; private List 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 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.

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

  • toJson () – Converti object Java in formato JSON

  • fromJson () – Converti JSON in object 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(); } } } 

`

Esistono molte librerie open source presenti per analizzare il contenuto JSON su un object o solo per leggere i valori JSON. Il tuo requisito è solo quello di leggere i valori e analizzarli su un object personalizzato. Quindi la libreria org.json è abbastanza nel tuo caso.

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

 JSONObject jsonObj = new JSONObject(); 

Ora, usa questo object per ottenere i tuoi valori:

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

Puoi vedere un esempio completo qui:

Come analizzare JSON in Java

È ansible utilizzare Gson Library 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(); 

Puoi anche eseguire il looping della matrice “posts” in questo modo:

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

Per favore fai qualcosa del genere:

 JSONParser jsonParser = new JSONParser(); JSONObject obj = (JSONObject) jsonParser.parse(contentString); String product = (String) jsonObject.get("productId"); 
 { "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 } 

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; 

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/

Spero che sia d’aiuto!

Read the following blog post, JSON in Java .

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

Step 1: Create a POJO class of your data.

Step 2: Now create a object using JSON.

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

For further reference you can refer to the following link .

You can use 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.

  com.jayway.jsonpath json-path 2.2.0  

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 

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

  com.jayway.jsonpath json-path 2.2.0  

One can use Apache @Model annotation to create Java model classs 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 classs to parse the provided input stream and pick certain information up while doing that:

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

È così! In addition to that here is a live gist showing similar example together with asynchronous network communication.

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

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

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

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

You need to use JsonNode and ObjectMapper class from the jackson library to fetch the nodes of your Json tree.Add the below dependency in your pom.xml to get an access to the Jackson classs.

   com.fasterxml.jackson.core jackson-databind 2.9.5  

You shall give a try on the below code, this would work :

 import com.fasterxml.jackson.core.JsonGenerationException; import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; Class JsonNodeExtractor{ public void convertToJson(){ String filepath = "c:\\data.json"; ObjectMapper mapper = new ObjectMapper(); JsonNode node = mapper.readTree(filepath); // create a JsonNode for every root or subroot element in the Json String JsonNode pageInfoRoot = node.path("pageInfo"); // Fetching elements under 'pageInfo' String pageName = pageInfoRoot.path("pageName").asText(); String pagePic = pageInfoRoot.path("pagePic").asText(); // Now fetching elements under posts JsonNode postsNode = node.path("posts"); String post_id = postsNode .path("post_id").asText(); String nameOfPersonWhoPosted = postsNode .path("nameOfPersonWhoPosted").asText(); } }