Conversion de données JSON en objet Java

Bewaaaaare de Gson! C'est très cool, très génial, mais à la seconde où vous voulez faire autre chose que de simples objets, vous pourriez facilement avoir besoin de commencer à construire vos propres sérialiseurs (ce qui n'est pas that hard).

De plus, si vous avez un tableau d'objets et que vous désérialisez du json dans ce tableau d'objets, les vrais types sont PERDUS! Les objets complets ne seront même pas copiés! Utilisez XStream.. Qui, si vous utilisez le jsondriver et définissez les paramètres appropriés, encodera les types laids dans le json réel, afin que vous ne perdiez rien. Un petit prix à payer (laid json) pour une véritable sérialisation.

Remarque que Jackson résout ces problèmes, et est rapidement que GSON.

Curieusement, le seul processeur JSON décent mentionné jusqu'à présent a été GSON.

Voici plus de bons choix:

• Jackson (Github ) binding liaison de données puissante (JSON vers / depuis POJOs), streaming (ultra rapide), modèle d'arborescence (pratique pour un accès non typé)
• Flex-JSON {[7] } ser sérialisation hautement configurable

MODIFIER (août/2013):

Un de plus à considérer:

• Genson functionality 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/, alors vous pouvez faire:

import com.restfb.json.JsonObject;

...

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

Etc.

Code java facile et fonctionnel pour convertir JSONObject en Java Object

Employé.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 vous utilisez n'importe quel type de cartes spéciales avec des clés ou des valeurs également de cartes spéciales, vous constaterez que ce n'est pas envisagé par l'implémentation de Google.

Quel est le problème avec les trucs standard?

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

Essayez boon:

Https://github.com/RichardHightower/boon

Il est méchant rapide:

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

Ne me croyez pas sur parole... consultez le benchmark gatling.

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

(Jusqu'à 4x est certains cas, et sur les 100 de test. Il dispose également d'un mode de superposition d'index qui est encore plus rapide. Il est jeune mais en a déjà utilisateur.)

Il peut analyser JSON en Cartes et listes plus rapidement que toute autre bibliothèque peut analyser en un DOM JSON et c'est sans mode de superposition d'index. Avec le mode de superposition d'index Boon, c'est encore plus rapide.

Il a également un mode JSON lax très rapide et un mode d'analyseur PLIST. :) (et a une mémoire super faible, directement à partir du mode octets avec encodage UTF-8 à la volée).

Il a également le mode JSON vers JavaBean le plus rapide.

C'est nouveau, mais si la vitesse et l'API simple sont ce que vous recherchez, Je ne pense pas qu'il existe une API plus rapide ou plus minimaliste.

Le moyen le plus simple est d'utiliser cette méthode softconvertvalue qui est une méthode personnalisée dans laquelle vous pouvez convertir jsonData en votre classe Dto spécifique.

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

En fonction du format JSON d'entrée(chaîne/fichier), créez un jSONString. Exemple d'objet de classe de message correspondant à JSON peut être obtenu comme ci-dessous:

Message msgFromJSON = new ObjectMapper().readValue(jSONString, Message.class);