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

762
2018-04-07 09:00


origen


Respuestas:


los org.json la biblioteca 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


575
2017-09-25 06:56



Por el bien del ejemplo, supongamos que tienes una clase Person 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 deserialización de objetos sino simplemente obtener un atributo, puede probar org.json (¡o mira el ejemplo 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

409
2017-07-31 09:54



  1. Si uno quiere crear un objeto JAVA a partir de JSON y viceversa, use jarrones 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");
    

68
2018-02-18 23:34



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

61
2018-02-24 06:24



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:

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

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.


25
2017-12-16 13:51



A - Explicación

Puedes usar Jackson bibliotecas, para enlazar la Cadena JSON 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 atravesar los métodos (usando 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 compuesto objeto, 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 Página objeto. Página objeto consiste en una Información de la página objeto y una Enviar matriz de objetos.

Entonces, tenemos que crear tres clases de POJO diferentes;

  • Página Clase, un compuesto de Información de la página Clase y variedad de Enviar Instancias
  • Información de la página Clase
  • 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

24
2017-07-12 19:06



Podrías 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<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 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.


20
2018-06-01 15:20



Utilizar 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:

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

19
2017-08-15 19:57