leer - Convertir datos JSON en objeto Java

jsonobject java

Question

Quiero poder acceder a las propiedades desde una cadena JSON dentro de mi método de acción Java. La cadena está disponible simplemente diciendo myJsonString = object.getJson() . A continuación se muestra un ejemplo de cómo puede verse la cadena:

{
    ''title'': ''ComputingandInformationsystems'',
    ''id'': 1,
    ''children'': ''true'',
    ''groups'': [{
        ''title'': ''LeveloneCIS'',
        ''id'': 2,
        ''children'': ''true'',
        ''groups'': [{
            ''title'': ''IntroToComputingandInternet'',
            ''id'': 3,
            ''children'': ''false'',
            ''groups'': []
        }]
    }]
}

En esta cadena, cada objeto JSON contiene una matriz de otros objetos JSON. La intención es extraer una lista de ID donde un objeto dado posee una propiedad de grupo que contiene otros objetos JSON. Miré a Gson de Google como un potencial complemento de JSON. ¿Puede alguien ofrecer algún tipo de orientación sobre cómo puedo generar Java a partir de esta cadena JSON?

Answer 1

Miré a Gson de Google como un potencial complemento de JSON. ¿Puede alguien ofrecer algún tipo de orientación sobre cómo puedo generar Java a partir de esta cadena JSON?

Google Gson soporta genéricos y beans anidados. La [] en JSON representa una matriz y debe asignarse a una colección de Java como List o simplemente a una matriz Java simple. La {} en JSON representa un objeto y debe asignarse a un Map Java o solo a alguna clase de JavaBean.

Tiene un objeto JSON con varias propiedades de las cuales la propiedad de los groups representa una matriz de objetos anidados del mismo tipo. Esto se puede analizar con Gson de la siguiente manera:

package com..q1688099;

import java.util.List;
import com.google.gson.Gson;

public class Test {

    public static void main(String... args) throws Exception {
        String json = 
            "{"
                + "''title'': ''Computing and Information systems'',"
                + "''id'' : 1,"
                + "''children'' : ''true'',"
                + "''groups'' : [{"
                    + "''title'' : ''Level one CIS'',"
                    + "''id'' : 2,"
                    + "''children'' : ''true'',"
                    + "''groups'' : [{"
                        + "''title'' : ''Intro To Computing and Internet'',"
                        + "''id'' : 3,"
                        + "''children'': ''false'',"
                        + "''groups'':[]"
                    + "}]" 
                + "}]"
            + "}";

        // Now do the magic.
        Data data = new Gson().fromJson(json, Data.class);

        // Show it.
        System.out.println(data);
    }

}

class Data {
    private String title;
    private Long id;
    private Boolean children;
    private List<Data> groups;

    public String getTitle() { return title; }
    public Long getId() { return id; }
    public Boolean getChildren() { return children; }
    public List<Data> getGroups() { return groups; }

    public void setTitle(String title) { this.title = title; }
    public void setId(Long id) { this.id = id; }
    public void setChildren(Boolean children) { this.children = children; }
    public void setGroups(List<Data> groups) { this.groups = groups; }

    public String toString() {
        return String.format("title:%s,id:%d,children:%s,groups:%s", title, id, children, groups);
    }
}

Bastante simple, ¿no es así? Simplemente tenga un JavaBean adecuado y llame a Gson#fromJson() .

Ver también:

• Json.org - Introducción a JSON
• Guía del usuario de Gson - Introducción a Gson

Answer 2

Código Java JSONObject y funcional para convertir JSONObject a Java Object

Empleado.java

import java.util.HashMap;
import java.util.Map;

import javax.annotation.Generated;

import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;

@JsonInclude(JsonInclude.Include.NON_NULL)
@Generated("org.jsonschema2pojo")
@JsonPropertyOrder({
"id",
"firstName",
"lastName"
})
public class Employee {

@JsonProperty("id")
private Integer id;
@JsonProperty("firstName")
private String firstName;
@JsonProperty("lastName")
private String lastName;
@JsonIgnore
private Map<String, Object> additionalProperties = new HashMap<String, Object>();

/**
*
* @return
* The id
*/
@JsonProperty("id")
public Integer getId() {
return id;
}

/**
*
* @param id
* The id
*/
@JsonProperty("id")
public void setId(Integer id) {
this.id = id;
}

/**
*
* @return
* The firstName
*/
@JsonProperty("firstName")
public String getFirstName() {
return firstName;
}

/**
*
* @param firstName
* The firstName
*/
@JsonProperty("firstName")
public void setFirstName(String firstName) {
this.firstName = firstName;
}

/**
*
* @return
* The lastName
*/
@JsonProperty("lastName")
public String getLastName() {
return lastName;
}

/**
*
* @param lastName
* The lastName
*/
@JsonProperty("lastName")
public void setLastName(String lastName) {
this.lastName = lastName;
}

@JsonAnyGetter
public Map<String, Object> getAdditionalProperties() {
return this.additionalProperties;
}

@JsonAnySetter
public void setAdditionalProperty(String name, Object value) {
this.additionalProperties.put(name, value);
}

}

LoadFromJSON.java

import org.codehaus.jettison.json.JSONObject;

import com.fasterxml.jackson.databind.ObjectMapper;

public class LoadFromJSON {

    public static void main(String args[]) throws Exception {
        JSONObject json = new JSONObject();
        json.put("id", 2);
        json.put("firstName", "hello");
        json.put("lastName", "world");

        byte[] jsonData = json.toString().getBytes();

        ObjectMapper mapper = new ObjectMapper();
        Employee employee = mapper.readValue(jsonData, Employee.class);

        System.out.print(employee.getLastName());

    }
}

Answer 3

¿Qué pasa con las cosas estándar?

JSONObject jsonObject = new JSONObject(someJsonString);
JSONArray jsonArray = jsonObject.getJSONArray("someJsonArray");
String value = jsonArray.optJSONObject(i).getString("someJsonValue");

Answer 4

Bewaaaaare de Gson! Es genial, muy bueno, pero en el segundo momento en el que quieras hacer algo que no sean objetos simples, es posible que necesites comenzar a construir tus propios serializadores (lo cual no es tan difícil).

Además, si tiene una matriz de Objetos y deserializa algo de json en esa matriz de Objetos, ¡los tipos verdaderos se PIERDEN! ¡Los objetos completos ni siquiera serán copiados! Use XStream ... Lo cual, si usa el jsondriver y configura las configuraciones adecuadas, codificará tipos feos en el json real, para que no pierda nada. Un pequeño precio a pagar (feo json) para una verdadera serialización.

Tenga en cuenta que Jackson soluciona estos problemas y es faster que GSON.

Answer 5

Curiosamente, el único procesador JSON decente mencionado hasta ahora ha sido GSON.

Aquí hay más buenas opciones:

• Jackson ( Github ): enlace de datos potente (JSON a / desde POJOs), transmisión (ultra rápido), modelo de árbol (conveniente para acceso sin tipo)
• Flex-JSON - serialización altamente configurable

EDITAR (agosto / 2013):

Una más a tener en cuenta:

• Genson : funcionalidad similar a Jackson, diseñada para ser más fácil de configurar por el desarrollador

Answer 6

Dale una oportunidad a Boon

https://github.com/RichardHightower/boon

Es perversamente rápido:

https://github.com/RichardHightower/json-parsers-benchmark

No confíes en mi palabra ... mira el punto de referencia de gatling.

https://github.com/gatling/json-parsers-benchmark

(Hasta 4 veces en algunos casos, y de los 100 segundos de prueba. También tiene un modo de superposición de índice que es aún más rápido. Es joven pero ya tiene algunos usuarios).

Puede analizar JSON a mapas y listas más rápido que cualquier otra biblioteca. Puede analizar a un JSON DOM y eso es sin modo de superposición de índice. Con el modo Boon Index Overlay, es incluso más rápido.

También tiene un modo JSON lax muy rápido y un modo de analizador PLIST. :) (y tiene una memoria súper baja, directa desde el modo de bytes con codificación UTF-8 sobre la marcha).

También tiene el modo JSON to JavaBean más rápido.

Es nuevo, pero si lo que buscas es velocidad y una API simple, no creo que haya una API más rápida o más minimalista.

Answer 7

Dependiendo del formato JSON de entrada (cadena / archivo), cree un jSONString. El objeto de clase de mensaje de muestra correspondiente a JSON se puede obtener de la siguiente manera:

Mensaje msgFromJSON = nuevo ObjectMapper (). ReadValue (jSONString, Message.class);

Answer 8

O con Jackson:

String json = "...
ObjectMapper m = new ObjectMapper();
Set<Product> products = m.readValue(json, new TypeReference<Set<Product>>() {});

Answer 9

Si utiliza cualquier tipo de mapas especiales con claves o valores también de mapas especiales, encontrará que no está contemplado en la implementación de Google.

Answer 10

Si, por cualquier cambio, está en una aplicación que ya usa http://restfb.com/ entonces puede hacer:

import com.restfb.json.JsonObject;

...

JsonObject json = new JsonObject(jsonString);
json.get("title");

etc.

Answer 11

HashMap keyArrayList = new HashMap();
        Iterator itr = yourJson.keys();
        while (itr.hasNext())
        {
            String key =(String) itr.next();
            keyArrayList.put(key, yourJson.get(key).toString());
        }