La conversión de datos JSON a objetos Java
https://stackoverflow.com/questions/1688099
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
Quiero ser capaz de acceder a las propiedades de una cadena JSON dentro de mi método de acción de Java. La cadena está disponible con sólo decir myJsonString = object.getJson(). A continuación se muestra un ejemplo de lo que la cadena puede ser:
{
'title': 'ComputingandInformationsystems',
'id': 1,
'children': 'true',
'groups': [{
'title': 'LeveloneCIS',
'id': 2,
'children': 'true',
'groups': [{
'title': 'IntroToComputingandInternet',
'id': 3,
'children': 'false',
'groups': []
}]
}]
}
En esta cadena de cada objeto JSON contiene una matriz de otros objetos JSON. La intención es extraer una lista de ID, donde cualquier objeto dado que poseen una propiedad de grupo que contiene otros objetos JSON. Miré a Gson de Google como un potencial complemento JSON. ¿Alguien puede ofrecer algún tipo de orientación en cuanto a cómo puedo generar Java desde esta cadena JSON?
Solución
Miré a Gson de Google como un potencial complemento JSON. ¿Alguien puede ofrecer algún tipo de orientación en cuanto a cómo puedo generar Java desde esta cadena JSON?
Google Gson es compatible con los genéricos y los frijoles anidados. El [] en JSON representa una matriz y debe asignar a una colección Java tales como List o simplemente una matriz de Java normal. El {} en JSON representa un objeto y debe asignar a una rel="noreferrer"> Java Map o simplemente alguna clase JavaBean.
tiene un objeto JSON con varias propiedades de las cuales la propiedad groups representa una matriz de objetos anidados de la muy mismo tipo. Esto se puede analizar con Gson 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, ¿verdad? Sólo tienen un JavaBean adecuado y llamar Gson#fromJson() .
Ver también:
- Json.org - Introducción a JSON
- Guía del usuario Gson - Introducción a Gson
Otros consejos
Bewaaaaare de Gson! Es muy fresco, 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 duro).
Además, si usted tiene una gran variedad de objetos, y deserializar algunos JSON en esa matriz de objetos, los verdaderos tipos se pierden! Los objetos completos ni siquiera se pueden copiar! Uso xstream .. Lo cual, si se utiliza el jsondriver y establecer los ajustes adecuados, codificará tipos feos en el JSON real, de modo que no perder nada. Un pequeño precio a pagar (JSON feo) para la verdadera serialización.
Tenga en cuenta que Jackson corrige estos problemas, y es más rápido de lo GSON.
Curiosamente, el único procesador JSON decente mencionado hasta ahora ha sido GSON.
Aquí hay más buenas opciones:
- Jackson Github ) - datos de gran alcance vinculante (JSON a / desde POJOs), streaming (ultra rápida), modelo de árbol (conveniente para el acceso sin tipo)
- Flex-JSON - serialización altamente configurable
Edit (Ago / 2013):
Uno más a considerar:
- Genson - una funcionalidad similar a Jackson, con el objetivo de 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/ entonces que puede hacer:
import com.restfb.json.JsonObject;
...
JsonObject json = new JsonObject(jsonString);
json.get("title");
etc.
Si utiliza cualquier tipo de mapas especiales con claves o valores también de mapas especiales, se encuentra que no está contemplado por la aplicación de Google.
Fácil y trabajando código de Java para convertir JSONObject a Java 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());
}
¿Qué pasa con el material estándar?
JSONObject jsonObject = new JSONObject(someJsonString);
JSONArray jsonArray = jsonObject.getJSONArray("someJsonArray");
String value = jsonArray.optJSONObject(i).getString("someJsonValue");
Dar una oportunidad de gran ayuda:
https://github.com/RichardHightower/boon
Es malvado rápido:
https://github.com/RichardHightower/json-parsers-benchmark
No tome mi palabra para ella ... comprobar el nivel Gatling.
https://github.com/gatling/json-parsers-benchmark
(hasta 4x es algunos casos, y fuera de los 100s de prueba. También tiene un modo de índice de superposición que es aún más rápido. Es joven, pero ya tiene algunos usuarios.)
Se puede analizar JSON para mapas y listas más rápido que cualquier otro lib puede analizar a un JSON DOM y que es sin el modo de índice de superposición. Con el modo de Boon Índice de superposición, es incluso más rápido.
También tiene un modo laxo JSON muy rápido y un modo PLIST analizador. :) (y tiene una memoria super bajo, directamente desde el modo de bytes con codificación UTF-8 sobre la marcha).
También tiene la JSON más rápida de modo JavaBean también.
Es nuevo, pero si la velocidad y la API simple es lo que busca, no creo que hay una API minimalista más rápido o más.
Según el formato JSON de entrada (cadena / archivo) crear un jsonString. objeto de clase de mensaje de muestra correspondiente a JSON se puede obtener como a continuación:
Mensaje msgFromJSON = new ObjectMapper () readValue (jsonString, Message.class);.
La forma más fácil es que se puede utilizar este método softconvertvalue que es un método personalizado en el que se puede convertir jsonData en su clase específica Dto.
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);
}
