Cómo analizar JSON en Java

Tengo el siguiente texto JSON. ¿Cómo puedo analizarlo para obtener pageName , pagePic , post_id , etc.?

 { "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 biblioteca org.json es fácil de usar. Ejemplo de código a continuación:

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

Puede encontrar más ejemplos de: Parse JSON en Java

Frasco descargable: http://mvnrepository.com/artifact/org.json/json

Por el bien del ejemplo, supongamos que tiene una Person clase con solo un name .

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

Google GSON ( Maven )

Mi favorito personal en cuanto a la gran serialización / deserialización JSON de objetos.

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

Actualizar

Si desea obtener un único atributo, puede hacerlo fácilmente con la biblioteca de Google también:

 JsonObject jsonObject = new JsonParser().parse("{\"name\": \"John\"}").getAsJsonObject(); System.out.println(jsonObject.get("name").getAsString()); //John 

Org.JSON ( Maven )

Si no necesita la deserialización de objetos sino simplemente obtener un atributo, puede probar org.json (¡ o buscar el ejemplo de GSON anterior! )

 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. Si uno quiere crear un objeto Java a partir de JSON y viceversa, use jarras de terceros GSON o JACKSON, etc.

     //from object to JSON Gson gson = new Gson(); gson.toJson(yourObject); // from JSON to object yourObject o = gson.fromJson(JSONString,yourObject.class); 
  2. Pero si uno solo quiere analizar una cadena JSON y obtener algunos valores, (O crear una cadena JSON desde cero para enviarla por cable) simplemente use el jar JaveEE que contenga JsonReader, JsonArray, JsonObject, etc. Puede descargar la implementación de esa cadena. especificaciones como javax.json. Con estos dos tarros, puedo analizar el json y usar los valores.

    Estas API en realidad siguen el modelo de análisis DOM / SAX de 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"); 

El analizador rápido-json es muy sencillo, flexible, muy rápido y personalizable. Intentalo

caracteristicas:

  • Cumple con la especificación JSON (RFC4627)
  • Analizador JSON de alto rendimiento
  • Admite un método de análisis flexible / configurable
  • Validación configurable de pares clave / valor de cualquier Jerarquía JSON
  • Fácil de usar # Huella muy pequeña
  • Incrementa las excepciones amigables y fáciles de rastrear del desarrollador
  • Compatibilidad de validación personalizada conectable: las claves / valores se pueden validar configurando validadores personalizados cuando se encuentran
  • Soporte de analizador validación y no validación
  • Soporte para dos tipos de configuración (JSON / XML) para usar el analizador de validación JSON rápida
  • Requiere JDK 1.5
  • Sin dependencia de las bibliotecas externas
  • Soporte para JSON Generation a través de la serialización de objetos
  • Soporte para selección de tipo de colección durante el proceso de análisis

Se puede usar así:

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

Casi todas las respuestas dadas requieren una deserialización completa del JSON en un objeto Java antes de acceder al valor en la propiedad de interés. Otra alternativa, que no sigue esta ruta, es usar JsonPATH, que es como XPath para JSON y permite atravesar objetos JSON.

Es una especificación y las buenas personas de JayWay han creado una implementación de Java para la especificación que puede encontrar aquí: https://github.com/jayway/JsonPath

Así que, básicamente, para usarlo, agréguelo a su proyecto, por ejemplo:

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

y para usar:

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

etc …

Consulte la página de especificaciones JsonPath para obtener más información sobre las otras formas de transverse JSON.

A – Explicación

Puede usar las bibliotecas de Jackson para vincular Cadena JSON en instancias de POJO ( Objeto Java antiguo normal ). POJO es simplemente una clase con solo campos privados y métodos públicos getter / setter. Jackson va a recorrer los métodos (utilizando la reflexión ) y mapea el objeto JSON en la instancia POJO, ya que los nombres de campo de la clase se ajustan a los nombres de campo del objeto JSON.

En su objeto JSON, que en realidad es un objeto compuesto , el objeto principal consiste en dos subobjetos. Entonces, nuestras clases POJO deberían tener la misma jerarquía. Llamaré a todo el objeto JSON como objeto de página . El objeto de página consiste en un objeto PageInfo y una matriz de objetos Post .

Entonces, tenemos que crear tres clases de POJO diferentes;

  • Clase de página , un compuesto de clase de página de información y una matriz de instancias de publicación
  • Clase de página de información
  • Publicaciones Clase

El único paquete que he usado es Jackson ObjectMapper, lo que hacemos es datos vinculantes;

 com.fasterxml.jackson.databind.ObjectMapper 

Las dependencias requeridas, los archivos jar se enumeran a continuación;

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

Aquí está el código requerido;

B – Clase principal POJO: Página

 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 – Clase POJO infantil: información de página

 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 – Clase POJO infantil: publicación

 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 – Archivo JSON de muestra: sampleJSONFile.json

Acabo de copiar su muestra JSON en este archivo y ponerlo en la carpeta del proyecto.

 { "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 – Código de demostración

 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 – Producción de demostración

 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 

Podría usar Google Gson .

Usando esta biblioteca solo necesitas crear un modelo con la misma estructura JSON. Luego, el modelo se completa automáticamente. Debe llamar a sus variables como sus claves JSON, o usar @SerializedName si desea usar diferentes nombres.

Para tu ejemplo:

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

}

Modelo:

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

Ahora puede analizar usando la biblioteca Gson:

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

Puede generar el modelo de JSON automáticamente usando herramientas en línea como esta .

Use minimal-json, que es muy rápido y fácil de usar. Puede analizar desde String obj y Stream.

Data de muestra:

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

Análisis:

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

Creando JSON:

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

Maven:

  com.eclipsesource.minimal-json minimal-json 0.9.4  

Creo que la mejor práctica debería ser pasar por la API Java JSON oficial, que todavía está en progreso.

El siguiente ejemplo muestra cómo leer el texto en la pregunta, representada como la variable “jsonText”. Esta solución utiliza la API Java EE7 javax.json (que se menciona en algunas de las otras respuestas). La razón por la que lo he agregado como una respuesta separada es que el siguiente código muestra cómo acceder realmente a algunos de los valores que se muestran en la pregunta. Se requeriría una implementación de la API javax.json para ejecutar este código. Se incluyó el paquete completo para cada una de las clases requeridas ya que no quería declarar declaraciones de “importación”.

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

Ahora, antes de que alguien vaya y vote negativamente esta respuesta porque no usa GSON, org.json, Jackson o cualquiera de los otros marcos de terceros disponibles, es un ejemplo de “código requerido” según la pregunta para analizar el texto proporcionado. Soy muy consciente de que el cumplimiento del estándar actual JSR 353 no se estaba considerando para JDK 9 y, por lo tanto, la especificación JSR 353 debe tratarse de la misma manera que cualquier otra implementación de manejo JSON de terceros.

Como nadie lo mencionó aún, aquí hay un comienzo de una solución que usa Nashorn (parte de tiempo de ejecución de JavaScript de Java 8).

Solución

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

Comparación de rendimiento

Escribí contenido JSON que contenía tres arreglos de 20, 20 y 100 elementos respectivamente. Solo quiero obtener los 100 elementos de la tercera matriz. Uso la siguiente función de JavaScript para analizar y obtener mis entradas.

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

Ejecutar la llamada un millón de veces con Nashorn toma 7.5 ~ 7.8 segundos

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

org.json toma 20 ~ 21 segundos

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

Jackson tarda 6.5 ~ 7 segundos

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

En este caso, Jackson se comporta mejor que Nashorn, que tiene un rendimiento mucho mejor que org.json. Nashorn API es más difícil de usar que org.json’s o Jackson’s. Dependiendo de sus requisitos, Jackson y Nashorn pueden ser soluciones viables.

Esto me dejó alucinado con lo fácil que era. Puede pasar una String que contenga su JSON al constructor de un JSONObject en el paquete org.json predeterminado.

 JSONArray rootOfPage = new JSONArray(JSONString); 

Hecho. Suelta el micrófono . Esto también funciona con JSONObjects . Después de eso, puedes mirar a través de tu jerarquía de Objects usando los métodos get() en tus objetos.

Si tiene alguna clase Java (por ejemplo, Message) que represente la cadena JSON (jsonString), puede usar la biblioteca Jackson JSON con:

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

y desde el objeto de mensaje puede obtener cualquiera de sus atributos.

Además de otras respuestas, recomiendo este servicio en línea de código abierto jsonschema2pojo.org para generar rápidamente clases Java a partir de los esquemas json o json para GSON, Jackson 1.xo Jackson 2.x. Por ejemplo, si tiene:

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

El jsonschema2pojo.org para GSON generado:

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

Hay muchas bibliotecas JSON disponibles en Java.

Los más notorios son: Jackson, GSON, Genson, FastJson y org.json.

Normalmente hay tres cosas que uno debe considerar para elegir cualquier biblioteca:

  1. Actuación
  2. Facilidad de uso (el código es simple de escribir y legible) – eso va con las características.
  3. Para aplicaciones móviles: dependencia / tamaño de jar

Específicamente para bibliotecas JSON (y cualquier biblioteca de serialización / deserialización), el enlace de datos también suele ser de interés, ya que elimina la necesidad de escribir código de placa de caldera para empaquetar / desempaquetar los datos.

Para 1, vea este punto de referencia: https://github.com/fabienrenaud/java-json-benchmark Lo hice usando JMH que compara (jackson, gson, genson, fastjson, org.json, jsonp) el rendimiento de los serializadores y deserializadores usando stream y las API de enlace de datos. Para 2, puede encontrar numerosos ejemplos en Internet. El índice de referencia anterior también se puede usar como fuente de ejemplos …

Rápido punto de referencia del benchmark: Jackson se desempeña de 5 a 6 veces mejor que org.json y más del doble que GSON.

Para su ejemplo particular, el siguiente código decodifica su 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. } } 

Hazme saber si tienes alguna pregunta.

Gson es fácil de aprender e implementar, lo que necesitamos saber es seguir dos métodos

  • toJson () – Convierte el objeto Java a formato JSON

  • fromJson () – Convierta JSON en un objeto 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(); } } } 

`

Hay muchas bibliotecas de código abierto presentes para analizar el contenido JSON de un objeto o simplemente para leer valores JSON. Su requisito es solo leer valores y analizarlos en objetos personalizados. Así que la biblioteca org.json es suficiente en tu caso.

Use la biblioteca org.json para analizarlo y crear JsonObject:

 JSONObject jsonObj = new JSONObject(); 

Ahora usa este objeto para obtener tus valores:

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

Puedes ver un ejemplo completo aquí:

Cómo analizar JSON en Java

Puede usar la Biblioteca Gson para analizar la cadena 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(); 

También puede recorrer la matriz de “publicaciones” de la siguiente manera:

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

Por favor haz algo como esto:

 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.

Dos posibles enfoques:

  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/

¡Espero eso ayude!

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 classes representing structure of JSON files and use them to access various elements in the JSON tree. Unlike other solutions this one works completely without reflection and is thus suitable for environments where reflection is impossible or comes with significant overhead.

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

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

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

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

¡Eso es! 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 classes.

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