La conversion des données JSON pour objet Java
https://stackoverflow.com/questions/1688099
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Je veux être en mesure d'accéder aux propriétés d'une chaîne JSON dans mon mode d'action de Java. La chaîne est disponible en disant simplement myJsonString = object.getJson(). Ci-dessous un exemple de ce que la chaîne peut ressembler à:
{
'title': 'ComputingandInformationsystems',
'id': 1,
'children': 'true',
'groups': [{
'title': 'LeveloneCIS',
'id': 2,
'children': 'true',
'groups': [{
'title': 'IntroToComputingandInternet',
'id': 3,
'children': 'false',
'groups': []
}]
}]
}
Dans cette chaîne chaque objet JSON contient un tableau d'autres objets JSON. L'intention est d'extraire une liste d'ID où un objet donné possédant une propriété de groupe qui contient d'autres objets JSON. Je regardais Gson de Google comme un plugin JSON potentiel. Quelqu'un peut-il offrir une certaine forme de conseils sur la façon que je peux générer Java à partir de cette chaîne JSON?
La solution
J'ai regardé Gson Google comme un plugin JSON potentiel. Quelqu'un peut-il offrir une certaine forme de conseils sur la façon que je peux générer Java à partir de cette chaîne JSON?
Google Gson prend en charge les génériques et les haricots imbriqués. Le [] JSON représente un tableau et devrait mapper une collection Java comme List ou tout simplement un tableau Java simple. Le {} JSON représente un objet et doit correspondre à un Java Map ou tout simplement une classe JavaBean.
Vous avez un objet JSON avec plusieurs propriétés dont la propriété groups représente un tableau d'objets imbriqués du type même. Cela peut être analysé avec Gson la manière suivante:
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);
}
}
Assez simple, est-ce pas? Juste un JavaBean approprié et appeler Gson#fromJson() .
Voir aussi:
Autres conseils
Bewaaaaare de Gson! Il est très cool, très grande, mais la seconde vous voulez faire autre chose que des objets simples, vous pouvez facilement besoin de commencer à construire vos propres serializers (ce qui est que dur).
En outre, si vous avez un tableau d'objets, et vous désérialiser certains JSON dans ce tableau d'objets, les vrais types sont perdus! Les objets complets ne seront même pas copiés! Utilisez XStream .. Ce qui, si vous utilisez le jsondriver et le réglage des paramètres appropriés, encode types laids dans la JSON réelle, de sorte que vous faites quelque chose ne lâche. Un petit prix à payer (JSON laid) pour vrai sérialisation.
Notez que Jackson fixe ces questions, et plus rapide que GSON.
Bizarrement, le seul processeur JSON décent mentionné a été jusqu'à présent GSON.
Voici plus de bons choix:
- Jackson ( Github ) - données puissantes de liaison (JSON / de POJO), le streaming (ultra-rapide), modèle d'arbre (pratique pour l'accès typées)
- Flex-JSON - sérialisation hautement configurable
EDIT (août / 2013):
Un plus à considérer:
- Genson - une fonctionnalité similaire à Jackson, visant à être plus facile à configurer par le développeur
Ou avec Jackson:
String json = "...
ObjectMapper m = new ObjectMapper();
Set<Product> products = m.readValue(json, new TypeReference<Set<Product>>() {});
Si, par un changement, vous êtes dans une application qui utilise déjà http://restfb.com/ puis vous pouvez faire:
import com.restfb.json.JsonObject;
...
JsonObject json = new JsonObject(jsonString);
json.get("title");
etc.
Si vous utilisez tout type de cartes spéciales avec des clés ou des valeurs aussi des cartes spéciales, vous trouverez ce n'est pas envisagé par la mise en œuvre de Google.
Simple et facile à travailler code Java pour convertir JSONObject à 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'est-ce qui ne va pas avec les choses standards?
JSONObject jsonObject = new JSONObject(someJsonString);
JSONArray jsonArray = jsonObject.getJSONArray("someJsonArray");
String value = jsonArray.optJSONObject(i).getString("someJsonValue");
Donner boon essayer:
https://github.com/RichardHightower/boon
Il est méchant rapide:
https://github.com/RichardHightower/json-parsers-benchmark
Ne prenez pas ma parole ... vérifier la référence Gatling.
https://github.com/gatling/json-parsers-benchmark
(jusqu'à 4x est certains cas, et hors des 100s de test. Il dispose également d'un mode de superposition d'index qui est encore plus rapide. Il est jeune mais a déjà certains utilisateurs.)
Il peut analyser JSON Cartes et listes plus rapidement que tout autre lib peut analyser à un JSON DOM et qui est sans index dans le mode de recouvrement. Avec le mode Index Boon Overlay, il est encore plus rapide.
Il a également un mode laxiste JSON très rapide et un mode d'analyseur PLIST. :) (et a une mémoire super bas, mode direct à partir des octets de codage UTF-8 à la volée).
Il a également le plus rapide JSON en mode JavaBean aussi.
Il est nouveau, mais si la vitesse et l'API simple est ce que vous cherchez, je ne pense pas qu'il y ait une API plus rapide ou plus minimaliste.
En fonction de l'entrée format JSON (chaîne / fichier) créer un jSONString. On peut obtenir l'échantillon objet de classe de message correspondant à JSON comme ci-dessous:
Message msgFromJSON = new ObjectMapper () readValue (jSONString, Message.class).
Le plus simple est que vous pouvez utiliser cette méthode softconvertvalue qui est une méthode personnalisée dans laquelle vous pouvez convertir jsonData dans votre classe spécifique 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);
}
