Cómo analizar JSON en Java

Tengo el siguiente texto JSON. ¿Cómo puedo analizarlo para obtener los valores de 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"
             }
        ]
    }

preguntado el 07 de abril de 10 a las 06:04

Las bibliotecas JSON integradas de Java son la forma más rápida de hacerlo, pero en mi experiencia, GSON es la mejor biblioteca para analizar un JSON en un POJO sin dolor. -

Esta es la primera pregunta protegida y altamente votada cuyas respuestas encontré más confusas:

@JaysonMinard estuvo de acuerdo. Pidió intervención mod. Esto debería estar cerrado realmente. Inicialmente asumí (erróneamente) que no podría hacerlo mientras la pregunta estuviera protegida, así que la desprotegí e hice lo mío. Vuelva a protegerlo ahora para evitar respuestas de baja repetición y cosas por el estilo, mientras espera un mod. -

"Esta pregunta no muestra ningún esfuerzo de investigación" (descripción emergente del botón de voto negativo)

Esta pregunta esta siendo discutido en Meta. -

30 Respuestas

Las org.json la biblioteca es fácil de usar.

Solo recuerda (mientras envías contenido o utilizas métodos como getJSONObject y getJSONArray) que en notación JSON

  • [ … ] representa una matriz, por lo que la biblioteca la analizará para JSONArray
  • { … } representa un objeto, por lo que la biblioteca lo analizará para JSONObject

Código de ejemplo a continuación:

import org.json.*;

String jsonString = ... ; //assign your JSON String here
JSONObject obj = new JSONObject(jsonString);
String pageName = obj.getJSONObject("pageInfo").getString("pageName");

JSONArray arr = obj.getJSONArray("posts"); // notice that `"posts": [...]`
for (int i = 0; i < arr.length(); i++)
{
    String post_id = arr.getJSONObject(i).getString("post_id");
    ......
}

Puede encontrar más ejemplos en: Analizar JSON en Java

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

Respondido el 01 de enero de 21 a las 19:01

Estoy de acuerdo con @StaxMan. Acabo de probar org.json y es terriblemente engorroso. Realmente no funciona con los tipos estándar de Colección Java, por ejemplo. - Ken Williams

@StaxMan yo elegiría org.json sobre otras bibliotecas para un análisis JSON simple sin siquiera mirar. Es la biblioteca de referencia que creó Douglas Crockford (el descubridor de JSON). - Omar Al Ithawi

@OmarIthawi eso es una tontería. Es una prueba de concepto con una API incómoda e implementación ineficiente. Creo que es mejor considerar las bibliotecas por sus propios méritos, en lugar de intentar deducir la calidad de la visibilidad de sus autores: Doug ha logrado muchas cosas, pero eso no cambia realmente las cualidades de la biblioteca en particular. Hace 10 años era el único juego en la ciudad, pero desde entonces ha habido muchos avances positivos. Es como Struts of json libs. - StaxMan

org.json se encuentra entre las peores bibliotecas json. Uno debe mirar el conjunto de características y el rendimiento de las bibliotecas json disponibles antes de elegir. Aquí hay un punto de referencia que hice comparando jackson, gson, org.json, genson usando JMH: github.com/fabienrenaud/java-json-benchmark. jackson es el claro ganador aquí. - Fabian

La licencia no incluye ninguna licencia de código abierto de uso común y también tiene derechos de autor. - Cristian Vielma

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

private class Person {
    public String name;

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

GSON de Google (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"}

Noticias

Si desea obtener un solo 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 (Maven)

Si no necesita la deserialización de objetos, sino simplemente obtener un atributo, puede probar org.json (¡O mira 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

Respondido 01 Abr '16, 20:04

Buena respuesta. Una sugerencia para una mejora menor: tanto GSON como Jackson también admiten el uso de la representación del árbol JSON (para Jackson, estos son JsonNodes, GSON tiene algo similar). Podría ser bueno mostrar fragmentos, ya que es similar a la única forma en que org.json ofrece. - StaxMan

Otras dos bibliotecas que vale la pena mencionar (en aras de la integridad): json-simple y JSONP de Oracle - Jake Stayman

@NeonWarge, ¿por qué? Me parece que esta respuesta supone que uno ya ha definido una clase Java que contiene exactamente los mismos campos que la cadena JSON, nada menos y nada más. Ésta es una suposición bastante sólida. - andrea lazarotto

json-simple y jsonp de Oracle funcionan terriblemente: github.com/fabienrenaud/java-json-benchmark Para el rendimiento, elija jackson o dsljson. - Fabian

GSON no admite el filtrado dinámico de campos en niveles distintos al raíz. - gangnus

  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 enviar por cable) simplemente use JaveEE jar que contiene JsonReader, JsonArray, JsonObject, etc. Es posible que desee descargar la implementación de eso especificaciones como javax.json. Con estos dos frascos, 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");
    

Respondido 25 ago 18, 00:08

@nondescript Si tuviera que adivinar, diría que se votó en contra porque no responde a la pregunta del póster original: "¿Cuál es el código requerido?" Las respuestas que se votaron a favor proporcionaron fragmentos de código. - jewbix.cube

Nota: Jackson y GSON admiten enlaces de estilo de árbol y / o mapas / listas, por lo que no es necesario utilizar el paquete Java EE (javax.json). javax.json tiene poco que ofrecer más allá de Jackson o GSON. - StaxMan

Sugiero agregar un enlace a la biblioteca JavaEE. - Albahaca bourque

analizador sintáctico json rápido es muy sencillo, flexible, muy rápido y personalizable. Intentalo

Características:

  • Cumple con la especificación JSON (RFC4627)
  • Analizador JSON de alto rendimiento
  • Admite un enfoque 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
  • Genera excepciones amigables para el desarrollador y fáciles de rastrear
  • Soporte de validación personalizada conectable: las claves / valores se pueden validar configurando validadores personalizados cuando se encuentren
  • Compatibilidad con analizadores de validación y no validación
  • Soporte para dos tipos de configuración (JSON / XML) para usar el analizador de validación de JSON rápido
  • Requiere JDK 1.5
  • Sin dependencia de bibliotecas externas
  • Soporte para la generación JSON a través de la 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);

Respondido 27 Feb 17, 13:02

¿Hay un javadoc disponible? - jboi

Este paquete no puede manejar valores vacíos al analizar. Por ejemplo: ... "descripción": "" ... arroja una excepción - Ivan

He solucionado este problema (y muchos otros) en code.google.com/p/quick-json/issues/detail?id=11 Espero que el autor se tome el tiempo de arreglarlo en el lanzamiento oficial. - noamik

De las funciones enumeradas, nada es único en comparación con otras opciones, y la afirmación de alto rendimiento no es compatible con nada; a diferencia de las bibliotecas más maduras (Gson, Jackson, Genson, Boon) que se incluyen en puntos de referencia como github.com/eishay/jvm-serializers, github.com/novoj/JavaJsonPerformanceTest or desarrollador.com/lang/jscript/… - No he visto esta biblioteca incluida en las pruebas, ni se menciona que se use ampliamente. - StaxMan

Este proyecto parece estar muerto y parece que ya no está alojado en el repositorio central de Maven. - 8bitjunkie

Podrías usar Google Gson.

Con 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 claves JSON, o usar @SerializedName si desea utilizar nombres diferentes.

JSON

De tu ejemplo:

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

Parsing

Ahora puede analizar usando la biblioteca Gson:

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

Importación de Gradle

Recuerde importar la biblioteca en el archivo Gradle de la aplicación

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

Generación automática de modelos

Puede generar un modelo a partir de JSON automáticamente utilizando herramientas en línea como este.

Respondido el 22 de enero de 20 a las 17:01

Casi todas las respuestas dadas requieren una deserialización completa del JSON en un objeto Java antes de acceder al valor de la propiedad de interés. Otra alternativa, que no sigue esta ruta, es utilizar 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

Entonces, 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 transversales JSON.

Respondido el 16 de diciembre de 15 a las 13:12

Esta es una biblioteca muy buena, especialmente para leer y actualizar JSON, pero tenga cuidado con algunos problemas conocidos sobre esta biblioteca. Ver [1]: github.com/json-path/JsonPath/issues/272 [2]: github.com/json-path/JsonPath/issues/375 - papigio

A - Explicación

Puedes usar Jackson bibliotecas, para vincular JSON String en POJO (Plain Old Java Objeto) instancias. POJO es simplemente una clase con solo campos privados y métodos públicos getter / setter. Jackson va a recorrer los métodos (usando reflexión) y asigna el objeto JSON a la instancia de 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 compuesto objeto, el objeto principal consta de dos subobjetos. Entonces, nuestras clases POJO deberían tener la misma jerarquía. Llamaré a todo el objeto JSON como Página objeto. Página el objeto consta de un Información de la página objeto, y un Publicación matriz de objetos.

Entonces tenemos que crear tres clases POJO diferentes;

  • Página Clase, un compuesto de Información de la página Clase y variedad de Publicación Instancias
  • Información de la página Clase
  • Artículos Clase

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

com.fasterxml.jackson.databind.ObjectMapper

Las dependencias necesarias, 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 Child POJO: 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 infantil POJO: Post

package com.levo.jsonex.model;

public class Post {

    private String post_id;
    private String actor_id;
    private String picOfPersonWhoPosted;
    private String nameOfPersonWhoPosted;
    private String message;
    private int likesCount;
    private String[] comments;
    private int timeOfPost;

    public String getPost_id() {
        return post_id;
    }

    public void setPost_id(String post_id) {
        this.post_id = post_id;
    }

    public String getActor_id() {
        return actor_id;
    }

    public void setActor_id(String actor_id) {
        this.actor_id = actor_id;
    }

    public String getPicOfPersonWhoPosted() {
        return picOfPersonWhoPosted;
    }

    public void setPicOfPersonWhoPosted(String picOfPersonWhoPosted) {
        this.picOfPersonWhoPosted = picOfPersonWhoPosted;
    }

    public String getNameOfPersonWhoPosted() {
        return nameOfPersonWhoPosted;
    }

    public void setNameOfPersonWhoPosted(String nameOfPersonWhoPosted) {
        this.nameOfPersonWhoPosted = nameOfPersonWhoPosted;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public int getLikesCount() {
        return likesCount;
    }

    public void setLikesCount(int likesCount) {
        this.likesCount = likesCount;
    }

    public String[] getComments() {
        return comments;
    }

    public void setComments(String[] comments) {
        this.comments = comments;
    }

    public int getTimeOfPost() {
        return timeOfPost;
    }

    public void setTimeOfPost(int timeOfPost) {
        this.timeOfPost = timeOfPost;
    }

}

E - Archivo JSON de muestra: sampleJSONFile.json

Acabo de copiar su muestra JSON en este archivo y la coloqué 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

Respondido 12 Jul 16, 20:07

Utilice las mínimo-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
    }
  ]
}

Analizando:

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

Experto:

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

Respondido 04 Feb 18, 18:02

¿Cómo se verá el pojo? - Jesse

Para Pojo, use gson. Esta biblioteca no admite archivos. - sakib sami

Como nadie lo mencionó todavía, aquí está el comienzo de una solución que usa Nashorn (El tiempo de ejecución de JavaScript es parte de Java 8, pero en desuso 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};

Ejecutando la llamada un millón de veces usando Nashorn tarda 7.5 ~ 7.8 segundos

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

org.json tarda 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 desempeña mejor que Nashorn, que se desempeña mucho mejor que org.json. La API de Nashorn es más difícil de usar que org.json o Jackson. Dependiendo de sus requisitos, Jackson y Nashorn pueden ser soluciones viables.

Respondido 26 Oct 18, 11:10

¿Qué es la unidad?"¿No son pulgadas? ¿Son segundos? ¿Minutos? - Pedro Mortensen

@PeterMortensen significa segundos. Como no parece claro, lo cambiaré. Gracias por la reseña. - otonglet

Desafortunadamente, Nashorn está obsoleto en Java 11. JEP 335. - Por Mildner

Sé que Nashorn está en desuso, pero me gustó esta respuesta porque no quería ninguna dependencia; sin embargo, tuve que volver a trabajar un poco el ejemplo: ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript"); engine.eval("var fun = function(raw) { return JSON.parse(raw); };"); Map<String, Object> json = (Map<String, Object>) ((Invocable) engine).invokeFunction("fun", jsonString); - kgibm

@kgibm ¡Impresionante! ¿Sabe cómo acceder a los elementos de la matriz desde el Objects devuelto? La clase es ScriptObjectMirror pero no es accesible ... - Mateo

Creo que la mejor práctica debería ser pasar por el oficial API JSON de Java que todavía están en proceso.

Respondido 14 ago 15, 01:08

Desde que respondí, comencé a usar Jackson y creo que es una de las mejores bibliotecas que existen para la deserialización de JSON. - giovanni botta

¿Por qué reutilizan JSONP para significar algo diferente a JSON con relleno? ... - chris wesseling

@ChrisWesseling ¿A qué te refieres? - giovanni botta

"API de Java para procesamiento JSON (JSON-P)" es el título del documento al que se vincula. Y me confundió, porque sabía que JSONP significaba algo más. - chris wesseling

@ChrisWesseling oh eso es confuso. Eso es lo que eligieron para la especificación. Sin embargo, como dije, iría directamente a Jackson. - giovanni botta

El siguiente ejemplo muestra cómo leer el texto de la pregunta, representado como la variable "jsonText". Esta solución utiliza Java EE7 javax.json API (que se menciona en algunas de las otras respuestas). La razón por la que lo agregué como una respuesta separada es que el siguiente código muestra cómo Realmente acceder a algunos de los valores que se muestran en la pregunta. Un implementación de la API javax.json sería necesario 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 la adhesión al estándar actual JSR 353 no se estaba considerando para JDK 9 y como tal el Especificaciones JSR 353 debe tratarse de la misma manera que cualquier otra implementación de manejo de JSON de terceros.

contestado el 02 de mayo de 16 a las 22:05

Esto me dejó alucinado con lo fácil que fue. Puedes pasar un String manteniendo su JSON en el 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, puede mirar a través de su jerarquía de Objects usando el get() métodos en sus objetos.

Respondido el 15 de enero de 16 a las 19:01

Las JSONArray type no forma parte de la API J2SE JDK y no indica qué API o biblioteca de terceros proporciona este tipo. - Bobuloso

No es que recomiende usarlo, pero creo que se refiere al paquete "org.json" de json.org/java. Solía ​​usarse antes de que estuvieran disponibles buenas bibliotecas de Java, pero esto fue hace años (2008 o antes): StaxMan

¿O significa brainmurphy1 Matriz JSON en Android? - alejandro farber

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 tener en cuenta para elegir cualquier biblioteca:

  1. Rendimiento
  2. Facilidad de uso (el código es fácil de escribir y legible), eso va con las funciones.
  3. Para aplicaciones móviles: dependencia / tamaño de jar

Específicamente para las bibliotecas JSON (y cualquier biblioteca de serialización / deserialización), la vinculación 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, consulte 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 serializadores y deserializadores utilizando API de transmisión y enlace de datos. Para 2, puede encontrar numerosos ejemplos en Internet. El punto de referencia anterior también se puede utilizar como fuente de ejemplos ...

Conclusión rápida del punto de referencia: Jackson funciona 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<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.

Respondido el 29 de junio de 16 a las 06:06

Además de otras respuestas, recomiendo este servicio de código abierto en línea jsonschema2pojo.org para generar rápidamente clases de Java a partir del esquema 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
         }
    ]
}

Las jsonschema2pojo.org 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;
}

Respondido el 16 de diciembre de 15 a las 21:12

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

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

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

Respondido 06 Oct 15, 19:10

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

    }
}

`

Respondido 05 Feb 16, 06:02

Para obtener un conocimiento completo sobre Gson, consulte los enlaces a continuación. github.com/google/gson/blob/master/UserGuide.md - venkat

Hay muchas bibliotecas de código abierto presentes para analizar el contenido JSON en un objeto o simplemente para leer valores JSON. Su requisito es simplemente leer valores y analizarlos en un objeto personalizado. Entonces, la biblioteca org.json es suficiente en su caso.

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

JSONObject jsonObj = new JSONObject(<jsonStr>);

Ahora, use este objeto para obtener sus valores:

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

Puedes ver un ejemplo completo aquí:

Cómo analizar JSON en Java

Respondido 04 Feb 18, 19:02

Parece que todas sus respuestas contienen un enlace a ese sitio. Si es spam, deténgase. Si no es así, disculpe la confusión, pero no creo que sea necesario publicar un enlace en todas sus respuestas. - Pato Donald

Es difícil dar una respuesta en la que puedas explicar todos los escenarios. Como en este caso, cómo leer una matriz json o varios objetos json. Incluso si lo hago, la respuesta sería muy larga y la persona podría confundirse. Así que doy un enlace donde se da la explicación adecuada, con el ejemplo adecuado. Él puede elegir visitar o usar solo mi explicación. - lalitbhagtani

Me parece que el enlace que ha proporcionado solo demuestra cómo leer JSON. ¿Dónde puedo encontrar información sobre cómo utilizar JSON también? - Lampros Tzanetos

Lo siento, pero no entendí tu pregunta: - "sobre cómo usar JSON también" - lalitbhagtani

Lea la siguiente publicación del blog, JSON en Java.

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

Paso 1: cree una clase POJO de sus 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 lo siguiente aquí.

Respondido 26 ago 20, 11:08

Por favor haz algo como esto:

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

Respondido 14 Jul 15, 05:07

Er, ¿qué biblioteca es esta? - Stewart

Creo que está usando org.json.simple - Lasita Yapa

Puede utilizar 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 "publicaciones" de la siguiente manera:

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

Respondido 19 Oct 17, 18:10

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

Respondido 28 Jul 15, 15:07

Explique su respuesta, ya que las respuestas de solo código ayudan a otros mucho menos que un código bien documentado. Ver "Dale un pescado a un hombre y lo alimentarás por un día; enséñale a pescar y lo alimentarás toda la vida". - Wai Ha Lee

Sería bueno mencionar que esto es para 'org.json' lib. Sin embargo, no creo que esta sea una buena manera de hacerlo, ya que es muy detallado y la propia lib 'org.json' es obsoleta (API lenta y engorrosa). Hay mejores opciones: GSON, Jackson, Boon, Genson para usar. - StaxMan

Primero debe seleccionar un biblioteca de implementación Para hacer eso.

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

Las Implementación de referencia está aquí: https://jsonp.java.net/

Aquí puedes encontrar un 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 opta por Jackson, aquí hay un buen artículo sobre la conversión entre JSON a / desde Java usando Jackson: https://www.mkyong.com/java/how-to-convert-java-object-to-from-json-jackson/

¡Espero eso ayude!

contestado el 23 de mayo de 17 a las 13:05

Estás apuntando a la versión 1 de la biblioteca de Jackson. Sugiero encarecidamente utilizar la versión actual de la biblioteca de Jackson. - herbert yu

Las respuestas principales en esta página usan ejemplos demasiado simples como objeto con una propiedad (por ejemplo, {nombre: valor}). Creo que ese ejemplo aún simple pero de la vida real 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. Recupere 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. Crea un objeto Java a partir de 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;
    

Respondido 23 Jul 16, 15:07

Puedes usar JaywayJsonPath. 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 jayway JSON 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 JSON de entrada como un archivo para este ejemplo. En mi caso, guardé su JSON como sampleJson.txt. Tenga en cuenta que se perdió una coma entre pageInfo y las publicaciones.

Paso 3: Lea el contenido JSON del archivo anterior usando bufferedReader y guárdelo como 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();

Paso 4: Analiza tu cadena JSON con el analizador jayway JSON.

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

Paso 5: Lea los detalles a continuación.

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

Respondido 04 Feb 18, 18:02

Tengo JSON como este:

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

Clase Java

class PageInfo {

    private String pageName;
    private String pagePic;

    // Getters and setters
}

Código para convertir este JSON en 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>

Respondido 04 Feb 18, 18:02

Si tiene un proyecto maven, agregue la dependencia a continuación o el proyecto normal agregue json-simple jar.

<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20180813</version>
</dependency>

Escriba a continuación el código java para convertir la cadena JSON en una matriz JSON.

JSONArray ja = new JSONArray(String jsonString);

Respondido 26 ago 20, 11:08

Uno puede usar Anotación Apache @Model crear Java clases modelo que representan la estructura de JSON archivos y utilícelos para acceder a varios elementos en el JSON árbol. A diferencia de otras soluciones, esta funciona completamente sin reflejos y, por lo tanto, es adecuado para entornos donde la reflexión es imposible o viene con una sobrecarga significativa.

Hay un muestra de proyecto Maven mostrando 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 usa las clases RepositoryInfo y Owner generadas para analizar el flujo de entrada proporcionado y recoger cierta información mientras lo hace:

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 de eso, aquí hay un esencia viva mostrando un ejemplo similar junto con la comunicación de red asíncrona.

respondido 21 nov., 17:07

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

sin que importe jsonData es una cadena de datos json.

Primero eche un vistazo al sitio web de la página página web oficial para obtener más información.

Respondido 19 Oct 18, 01:10

Puedes usar JsonNode para una representación de árbol estructurada de su cadena JSON. Es parte de la roca sólida jackson bibliotecas que es omnipresente.

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

Respondido 04 Feb 18, 18:02

Podemos usar la clase JSONObject para convertir una cadena JSON en un objeto JSON y para iterar sobre el objeto JSON. Utilice 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));
  }
}

Respondido 04 Feb 18, 19:02

Esto es solo para Android - Ľubomir

@DermotCanniffe es solo Android. - user4020527

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.