library - read json file java

Cómo analizar JSON en Java

Question

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

Answer 1

A - Explicación

Puede usar las bibliotecas Jackson , para enlazar cadenas JSON en instancias de POJO ( objeto Java antiguo llano ). POJO es simplemente una clase con solo campos privados y métodos de obtención / configuración públicos. Jackson va a atravesar los métodos (utilizando la reflexión ) y asigna el objeto JSON a la instancia POJO a medida que los nombres de los campos de la clase se ajustan a los nombres de los campos del objeto JSON.

En su objeto JSON, que en realidad es un objeto compuesto , el objeto principal consiste en dos subobjetos. Por lo tanto, nuestras clases POJO deben tener la misma jerarquía. Llamaré a todo el objeto JSON como objeto de página . El objeto de página consta de un objeto PageInfo y una matriz de objetos de publicación .

Así que tenemos que crear tres clases diferentes de POJO;

• Page Class, un compuesto de PageInfo Class y matriz de Post Instances
• Clase PageInfo
• Clase de mensajes

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

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-anotaciones-2.5.0.jar

Aquí está el código requerido;

B - Clase principal de 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: 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 - Clase POJO infantil: Mensaje

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 ejemplo JSON en este archivo y lo puse 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 - Salida 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

Answer 2

1. Si uno quiere crear un objeto Java desde JSON y viceversa, use los tarros de terceros de 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 cree una cadena JSON desde cero para enviarla por cable) simplemente use el jar JaveEE que contiene JsonReader, JsonArray, JsonObject, etc. Si lo desea, puede descargar la implementación de ese Especificaciones como javax.json. Con estos dos tarros puedo analizar el json y usar los valores.

   Estas API siguen realmente 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");

Answer 3

Además de otras respuestas, recomiendo este servicio de código this línea this para generar rápidamente clases en Java desde el esquema json o json para GSON, Jackson 1.x o 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 this para GSON generado:

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

Answer 4

Casi todas las respuestas proporcionadas requieren una deserialización completa de 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 la buena gente de JayWay ha creado una implementación de Java para la especificación que puede encontrar aquí: https://github.com/jayway/JsonPath

Básicamente, para usarlo, agréguelo a su proyecto, por ejemplo:

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

y utilizar:

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 de JsonPath para obtener más información sobre las otras formas de transversar JSON.

Answer 5

Como nadie lo ha mencionado aún, este es el comienzo de una solución que utiliza Nashorn (parte de tiempo de ejecución de JavaScript de Java 8, pero está obsoleta en Java 11).

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 contiene tres matrices de 20, 20 y 100 elementos respectivamente. Solo quiero obtener los 100 elementos de la tercera matriz. Utilizo 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 usando Nashorn toma 7.5 ~ 7.8 segundos

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

org.json toma 20 ~ 21 segundos

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

Jackson toma 6.5 ~ 7 segundos

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

En este caso, Jackson se desempeña mejor que Nashorn, que funciona mucho mejor que org.json. La API de Nashorn es más difícil de usar que la de org.json o la de Jackson. Dependiendo de sus requisitos, Jackson y Nashorn pueden ser soluciones viables.

Answer 6

Creo que la mejor práctica debería ser ir a través de la API oficial de Java JSON que todavía están en proceso.

Answer 7

El siguiente ejemplo muestra cómo leer el texto de la pregunta, representado como la variable "jsonText". Esta solución utiliza la API javax.json de Java EE7 (que se menciona en algunas de las otras respuestas). La razón por la que lo agregué como respuesta por separado es que el siguiente código muestra cómo acceder realmente a algunos de los valores que se muestran en la pregunta. Se requiere una implementación de la API javax.json para hacer que este código se ejecute. El paquete completo para cada una de las clases requeridas se incluyó, 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 rebote esta respuesta porque no usa GSON, org.json, Jackson o cualquiera de los otros marcos de trabajo 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, como tal, la especificación JSR 353 debe tratarse de la misma manera que cualquier otra implementación de manejo JSON de terceros.

Answer 8

Esto me asombró con lo fácil que era. Solo puede pasar una String contiene su JSON al constructor de un JSONObject en el paquete org.json predeterminado.

JSONArray rootOfPage = new JSONArray(JSONString);

Hecho. Gotas de micrófono . Esto funciona con JSONObjects también. Después de eso, simplemente puede mirar a través de su jerarquía de Objects usando los métodos get() en sus objetos.

Answer 9

Hay muchas bibliotecas JSON disponibles en Java.

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

Por lo general, hay tres cosas que uno debe considerar para elegir cualquier biblioteca:

1. Actuación
2. Facilidad de uso (el código es fácil de escribir y legible), que viene con características.
3. Para aplicaciones móviles: dependencia / tamaño jar

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

Para 1, vea este punto de referencia: github.com/fabienrenaud/java-json-benchmark Hice usando JMH que compara (jackson, gson, genson, fastjson, org.json, jsonp) el rendimiento de los serializadores y deserializadores usando corriente y APIs de base de datos. Para 2, puedes encontrar numerosos ejemplos en internet. El punto de referencia anterior también se puede utilizar como fuente de ejemplos ...

Para llevar rápidamente al punto de referencia: Jackson tiene un rendimiento de 5 a 6 veces mejor que org.json y más de dos veces mejor que GSON.

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

Hazme saber si tienes alguna pregunta.

Answer 10

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

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

JSONObject jsonObj = new JSONObject(<jsonStr>);

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

Answer 11

La biblioteca org.json es fácil de usar. Código de ejemplo 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");
......
}

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

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

Answer 12

Las respuestas principales en esta página utilizan ejemplos demasiado simples como objetos con una propiedad (por ejemplo, {nombre: valor}). Creo que un ejemplo simple pero real de la vida puede ayudar a alguien.

Así que este es el JSON devuelto por la API de Google Translate:

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

Quiero recuperar el valor del atributo "translateText", por ejemplo, "Arbeit" utilizando Gson de Google.

Dos posibles enfoques:

1. Recupera solo un atributo necesario

   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. Crear objeto Java desde 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;

Answer 13

Podrías usar Google Gson .

Usando esta biblioteca solo necesita 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 nombres diferentes.

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

Ahora puedes analizar usando la biblioteca de Gson:

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

Puedes generar un modelo desde JSON automáticamente usando herramientas en línea como this .

Answer 14

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 / des-serializació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, también puede hacerlo fácilmente con la biblioteca de Google:

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

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

Si no necesita la des-serialización de objetos pero simplemente para obtener un atributo, puede probar org.json (¡ o ver el ejemplo de GSON arriba! )

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

Answer 15

Por favor, haga algo como esto:

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

Answer 16

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" así:

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

Answer 17

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

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

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

Answer 18

Use minimal-json que es muy rápido y fácil de usar. Puedes 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

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

Answer 19

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

caracteristicas:

• Cumple con la especificación JSON (RFC4627)
• Analizador JSON de alto rendimiento
• Soporta enfoque de análisis flexible / configurable
• Validación configurable de pares clave / valor de cualquier jerarquía JSON
• Fácil de usar # Muy pequeña huella
• Genera excepciones fáciles de usar y fáciles de rastrear.
• Compatibilidad con la validación personalizada conectable: las claves / valores se pueden validar mediante la configuración de validadores personalizados cuando se encuentran
• Validación y no validación de soporte de analizador
• Compatibilidad con dos tipos de configuración (JSON / XML) para utilizar el analizador de validación quick-JSON
• Requiere JDK 1.5
• Sin dependencia de bibliotecas externas.
• Soporte para JSON Generation a través de serialización de objetos.
• Soporte para la selección del 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);

Answer 20

jsoniter(jsoniterator) es una biblioteca json relativamente nueva y simple, diseñada para ser simple y rápida. Todo lo que necesita hacer para deserializar los datos json es

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

donde jsonDataes una cadena de datos json.

Echa un vistazo a la página web oficial para más información.

Answer 21

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

• toJson () - Convertir objeto Java a formato JSON

• fromJson () - Convierte JSON en 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();
}
}
}

`

Answer 22

Tengo a JSON así:

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

Clase de Java

class PageInfo {
private String pageName;
private String pagePic;
// Getters and setters
}

Código para convertir este JSON a una clase Java.

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

Maven

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

Answer 23

En primer lugar, esto no es un dato de json válido.

Tienes que poner una coma entre los dos elementos json pageInfoy posts.

Aquí está el json válido:

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

Ahora puede analizarlo usando cualquiera de los métodos descritos anteriormente, o si implementa org.json , entonces es mejor.

Answer 24

Lee la siguiente entrada del blog, JSON en Java .

Esta publicación es un poco antigua, pero aún así quiero responder tu pregunta.

Paso 1: Crea una clase POJO de tus datos.

Paso 2: ahora crea un objeto 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();
}

Para mayor referencia puede consultar el siguiente enlace .

Answer 25

Podemos usar la clase JSONObject para convertir una cadena JSON en un objeto JSON, y para iterar sobre el objeto JSON. Usa el siguiente código.

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

Answer 26

Primero necesitas seleccionar una biblioteca de implementación para hacer eso.

La API de Java para el procesamiento de JSON (JSR 353) proporciona API portátiles para analizar, generar, transformar y consultar JSON utilizando el modelo de objetos y las API de transmisión.

La implementación de referencia está aquí: https://jsonp.java.net/

Aquí puede encontrar una lista de implementaciones de JSR 353:

¿Cuáles son las API que implementan JSR-353 (JSON)?

Y para ayudarte a decidir ... También encontré este artículo:

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

Si elige Jackson, aquí hay un buen artículo sobre la conversión de JSON a / desde Java utilizando Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

¡Espero eso ayude!

Answer 27

Puede utilizar JsonNodepara una representación de árbol estructurado de su cadena JSON. Es parte de la Jackson rock solid Jackson que está omnipresente.

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

Answer 28

Puedes usar Jayway JsonPath . A continuación se muestra un enlace de GitHub con código fuente, detalles de pom y buena documentación.

https://github.com/jayway/JsonPath

Por favor, siga los pasos a continuación.

Paso 1 : Agregue la dependencia de la ruta JSON de jayway en su ruta de clase usando Maven o descargue el archivo JAR y agréguelo manualmente.

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

Paso 2 : guarde su entrada JSON como un archivo para este ejemplo. En mi caso guardé tu JSON como sampleJson.txt. Tenga en cuenta que perdió una coma entre pageInfo y mensajes.

Paso 3 : lea el contenido JSON del archivo anterior usando bufferedReader y guárdelo como una cadena.

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

Paso 4 : Analice su cadena JSON utilizando el analizador JSON jayway.

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

Paso 5 : Lea los detalles como abajo.

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

La salida será :

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

Answer 29

Se puede usar la anotación Apache @Model para crear clases de modelos Java que representan la estructura de los archivos JSON y usarlos para acceder a varios elementos en el árbol JSON . A diferencia de otras soluciones, ésta funciona completamente sin reflexión y, por lo tanto, es adecuada para entornos donde la reflexión es imposible o conlleva una sobrecarga considerable.

Hay un proyecto de muestra de Maven que muestra el uso. En primer lugar define la estructura:

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

y luego utiliza las clases de RepositoryInfo y Propietario generadas para analizar la secuencia de entrada proporcionada y recoger cierta información mientras hace eso:

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

¡Eso es! Además, aquí hay una idea en vivo que muestra un ejemplo similar junto con la comunicación de red asíncrona.

Answer 30

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