Conversión de datos JSON a objeto Java

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 del aspecto que puede tener 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 cualquier objeto dado que posee una propiedad de grupo que contiene otros objetos JSON. Miré el Gson de Google como un posible complemento JSON. ¿Alguien puede ofrecer alguna forma de orientación sobre cómo puedo generar Java a partir de esta cadena JSON?

Miré el Gson de Google como un posible complemento JSON. ¿Alguien puede ofrecer alguna forma de orientación sobre cómo puedo generar Java a partir de esta cadena JSON?

Google Gson admite genéricos y beans anidados. El []en JSON representa una matriz y debe correlacionarse con una colección de Java como Listo simplemente una matriz de Java simple. El {}en JSON representa un objeto y debe mapearse a una Mapclase Java o solo a alguna clase JavaBean.

Tiene un objeto JSON con varias propiedades cuya groupspropiedad representa una matriz de objetos anidados del mismo tipo. Esto se puede analizar con Gson de la siguiente manera:

package com.stackoverflow.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í? Solo tenga un JavaBean adecuado y llame Gson#fromJson().

Ver también:

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

Bewaaaaare de Gson! Es muy bueno, muy grande, pero el segundo desea hacer otra cosa que simples objetos nada, que fácilmente podría necesitar para empezar a construir sus propios serializadores (que no es que dura).

Además, si tiene una matriz de Objetos y deserializa algo de json en esa matriz de Objetos, ¡los tipos verdaderos están PERDIDOS! ¡Los objetos completos ni siquiera se copiarán! Use XStream .. Que, si usa el jsondriver y establece la configuración adecuada, codificará los tipos feos en el json real, para que no pierda nada. Un pequeño precio a pagar (feo json) por la verdadera serialización.

Tenga en cuenta que Jackson soluciona estos problemas y es más rápido que GSON.

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

Aquí hay más buenas opciones:

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

EDITAR (agosto / 2013):

Uno más a considerar:

• Genson : funcionalidad similar a Jackson, cuyo objetivo es ser más fácil de configurar por el desarrollador

O con Jackson:

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

Si, por cualquier cambio, se encuentra en una aplicación que ya utiliza http://restfb.com/ , puede hacer lo siguiente:

import com.restfb.json.JsonObject;

...

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

etc.

Código java fácil y funcional para convertir JSONObjectaJava Object

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

    }
}

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

Si utiliza algún tipo de mapas especiales con claves o valores también de mapas especiales, verá que no está contemplado por la implementación de google.

¿Qué hay de malo con las cosas estándar?

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

Prueba boon:

https://github.com/RichardHightower/boon

Es malvado 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 fuera de los 100 de la 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 Maps y Lists más rápido que cualquier otra lib puede analizar a un JSON DOM y eso es sin el modo Index Overlay. Con el modo Boon Index Overlay, es aún 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, directo desde el modo de bytes con codificación UTF-8 sobre la marcha).

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

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

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 = new ObjectMapper (). ReadValue (jSONString, Message.class);

La forma más fácil es que puede utilizar este método de conversión de valores suaves, que es un método personalizado en el que puede convertir jsonData en su clase Dto específica.

Dto response = softConvertValue(jsonData, Dto.class);


public static <T> T softConvertValue(Object fromValue, Class<T> toValueType) 
{
    ObjectMapper objMapper = new ObjectMapper();
    return objMapper
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
        .convertValue(fromValue, toValueType);
}